Registration

Context provides register* methods for modules to contribute capabilities. Every method returns a cleanup callback except registerEvent (hands Obsidian EventRef to plugin cleanup) and registerI18n (returns void). Store cleanup callbacks and invoke them from dispose.

export default class MyModule {
  private readonly cleanup: Array<() => void> = [];
  constructor(private readonly ctx: Context) {}

  start(): void {
    this.cleanup.push(this.ctx.registerRemoteFsWrapper(/* ... */));
    this.ctx.registerI18n('en', { hello: 'Hello' });
  }

  dispose(): void {
    this.cleanup.splice(0).forEach((fn) => fn());
  }
}

Filesystem Wrappers

Register middleware that wraps the local or remote filesystem. See file system: wrapper chain for implementation guidance.

type FsWrapperEntry = { priority: number; apply: (fs: Fs) => Fs | undefined };

ctx.registerLocalFsWrapper(entry: FsWrapperEntry): () => boolean;
ctx.registerRemoteFsWrapper(entry: FsWrapperEntry): () => boolean;

Returning undefined from apply declines the entry.

Backends

Register a remote backend implementation. See file system: RootFs for the contract.

type CheckConnectionResult = { success: true } | { success: false; reason: string };

type RemoteFsEntry = {
  prettyName: () => string;
  instantiate: (request: Request) => RootFs;
  checkConnection: (request: Request) => MaybePromise<CheckConnectionResult>;
};

ctx.registerRemoteFs(id: string, entry: RemoteFsEntry): () => boolean;

Batch Optimizers

Register local or remote batch optimizers. See file system: batch optimization for atom behavior.

type OptimizerEntry = {
  priority: number;
  apply: (input: OptimizerInput) => OptimizerOutput | undefined;
};

ctx.registerLocalOptimizer(entry: OptimizerEntry): () => boolean;
ctx.registerRemoteOptimizer(entry: OptimizerEntry): () => boolean;

Request Middleware

Register remote or local request middleware. See request middleware for the two separate systems.

type RemoteRequestMiddlewareEntry = {
  priority: number;
  apply: (request: Request) => Request | undefined;
};
type LocalRequestMiddlewareEntry = {
  priority: number;
  apply: (request: VaultRequest) => VaultRequest | undefined;
};

ctx.registerRemoteRequestMiddleware(entry: RemoteRequestMiddlewareEntry): () => boolean;
ctx.registerLocalRequestMiddleware(entry: LocalRequestMiddlewareEntry): () => boolean;

Sync Trigger

Register an entry that supplies sync options for a trigger name. See sync: sync trigger.

type TriggerEntry = {
  priority: number;
  options?: () => SyncOptions;
};

ctx.registerTrigger(key: string, entry: TriggerEntry): () => boolean;

Decider

Register a sync decision strategy. See sync: decider.

type DeciderEntry = { decider: Decider; prettyName: () => string };

ctx.registerDecider(id: string, entry: DeciderEntry): () => boolean;

Conflict Resolver

Register a conflict resolution strategy. See sync: conflict resolver.

type ConflictResolverEntry = { prettyName: () => string; resolver: ConflictResolver };

ctx.registerConflictResolver(id: string, entry: ConflictResolverEntry): () => boolean;

Settings and UI

Register nested setting definitions, translations, and migration-aware controls as described in Settings and UI.

CSS

ctx.registerCss(css: string): () => void;

Injects CSS into the document. Returns a callback that removes the injected style element.

Events

Pass Obsidian event references for automatic plugin cleanup. See events.

ctx.registerEvent(ref: EventRef): void;