obsidian-integration-testing 6.0.0 → 7.0.0

package/dist/lib/cjs/eval-in-obsidian.d.cts

@@ -16,17 +16,109 @@ export interface CommonArgs {
      * The Obsidian {@link App} instance.
      */
     app: App;
+    /**
+     * The shared library bag injected into every callback — see {@link Lib}.
+     *
+     * Never empty: the harness pre-populates a **base** set of renderer-driving
+     * helpers (trusted input — `typeIntoEditor` / `pressKey` / `moveMouse` /
+     * `hoverElement` / `unhoverElement` — and `waitUntil`), and provider packages
+     * (chiefly `obsidian-dev-utils`) `Object.assign` their whole renderer-safe
+     * library on top via {@link registerLibResolver}. A serialized closure reaches
+     * every shared helper through `lib` — `lib.typeIntoEditor({ editor, text })`,
+     * `lib.getFileOrNull({ app, … })` — instead of importing or hand-rolling them.
+     */
+    lib: Lib;
+    /**
+     * The `obsidian` module, resolved at runtime inside the Obsidian process.
+     */
+    obsidianModule: typeof obsidian;
+}
+/**
+ * Parameters for {@link evalInObsidian}.
+ */
+export interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {
+    /**
+     * Additional arguments to pass to the function. Values may include functions —
+     * they are serialized via `toString()`.
+     */
+    readonly args?: Args;
+    /**
+     * A {@link ContextId} linking this call to a persistent store on `window`
+     * in the Obsidian process. The callback receives a typed `context` object
+     * that survives across calls sharing the same ID.
+     *
+     * When omitted, `context` is a fresh empty object each call.
+     */
+    readonly contextId?: TContextId;
+    /**
+     * The function to evaluate in the Obsidian context.
+     */
+    fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;
+    /**
+     * Skips pre-flight checks (vault registration, CLI availability).
+     * Used internally by vault registration functions.
+     *
+     * @internal
+     */
+    readonly shouldSkipPreflightChecks?: boolean;
+    /**
+     * Override the transport for this call. When omitted, uses the transport
+     * configured via the context provider (set by the framework adapter's global setup).
+     */
+    readonly transport?: ObsidianTransport;
+    /**
+     * The path to the Obsidian vault. Defaults to `process.cwd()`.
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * A plain object with string keys.
+ */
+export type GenericObject = Record<string, unknown>;
+/**
+ * Parameters for {@link CommonArgs.hoverElement}.
+ */
+export interface HoverElementParams {
+    /**
+     * The element to hover. The pointer is moved to its center. This is a live
+     * renderer DOM node — the callback runs in-renderer, so no cross-process
+     * serialization is needed (same as {@link TypeIntoEditorParams.editor}).
+     */
+    readonly element: HTMLElement;
+}
+/**
+ * The shared library bag injected into every {@link evalInObsidian} callback as
+ * {@link CommonArgs.lib}.
+ *
+ * Two layers compose into this one bag. The **base** — the harness-provided
+ * renderer-driving helpers declared below (the trusted-input primitives and
+ * {@link Lib.waitUntil}) — is always present. On top, provider packages register
+ * a renderer-side resolver via {@link registerLibResolver} to `Object.assign`
+ * their whole renderer-safe library at runtime, and augment this **augmentable**
+ * interface (the `i18next` `CustomTypeOptions` idiom) via
+ * `declare module 'obsidian-integration-testing'` to type it. Multiple providers
+ * compose: their exports merge at runtime and their augmentations merge in the
+ * type system (`interface Lib extends …`).
+ *
+ * @example
+ * ```ts
+ * declare module 'obsidian-integration-testing' {
+ *   interface Lib extends (typeof import('obsidian-dev-utils/__merged')) {}
+ * }
+ * ```
+ */
+export interface Lib {
     /**
      * Moves the mouse pointer to the center of an element using **trusted**
      * Electron pointer input, then polls until the element actually matches
      * `:hover`.
      *
-     * Because the move is trusted (see {@link CommonArgs.moveMouse}), the real
-     * `:hover` state takes effect in the CSS engine — real theme `var()` values
-     * and real compositing — instead of a hand-simulated cascade. It polls the
-     * live `element.matches(':hover')` state (not a fixed delay), so it is robust
-     * under shared-instance load. It targets the single shared window's
-     * **global** pointer, so only one element is hovered at a time.
+     * Because the move is trusted (see {@link Lib.moveMouse}), the real `:hover`
+     * state takes effect in the CSS engine — real theme `var()` values and real
+     * compositing — instead of a hand-simulated cascade. It polls the live
+     * `element.matches(':hover')` state (not a fixed delay), so it is robust under
+     * shared-instance load. It targets the single shared window's **global**
+     * pointer, so only one element is hovered at a time.
      *
      * @param params - The element to hover.
      * @returns A {@link Promise} that resolves once the element matches `:hover`.
@@ -44,41 +136,35 @@ export interface CommonArgs {
      *
      * This is the low-level primitive: it performs a single move and does **not**
      * wait for any state to settle (callers poll their own readiness signal).
-     * Prefer {@link CommonArgs.hoverElement} / {@link CommonArgs.unhoverElement}
-     * for element-relative moves; use `moveMouse` directly when an
-     * element-relative target does not fit (e.g. an element spanning the full
-     * viewport width).
+     * Prefer {@link Lib.hoverElement} / {@link Lib.unhoverElement} for
+     * element-relative moves; use `moveMouse` directly when an element-relative
+     * target does not fit (e.g. an element spanning the full viewport width).
      *
      * @param params - The web-contents DIP coordinates to move to.
      * @returns A {@link Promise} that resolves once the move has been injected.
      */
     moveMouse(this: void, params: MoveMouseParams): Promise<void>;
-    /**
-     * The `obsidian` module, resolved at runtime inside the Obsidian process.
-     */
-    obsidianModule: typeof obsidian;
     /**
      * Presses a single key (optionally with modifiers) using **trusted** Electron
      * keyboard input, firing the full real key pipeline —
      * `keydown` → `keypress` → `beforeinput` → `input` → `keyup`.
      *
-     * This is the key-press analog of {@link CommonArgs.typeIntoEditor}: it
-     * injects a trusted `keyDown` → `char` → `keyUp` sequence via Electron's
+     * This is the key-press analog of {@link Lib.typeIntoEditor}: it injects a
+     * trusted `keyDown` → `char` → `keyUp` sequence via Electron's
      * `webContents.sendInputEvent`, so it is delivered to the window's DOM-focused
      * element and flows through the real input pipeline — unlike
      * `dispatchEvent(new KeyboardEvent(...))`, which is untrusted (`isTrusted:
      * false`) and ignored by CodeMirror and most key handlers. Use it for special
      * keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations
-     * (`Shift+Enter`, `Ctrl+A`) that {@link CommonArgs.typeIntoEditor} (which
-     * types printable text) does not cover.
+     * (`Shift+Enter`, `Ctrl+A`) that {@link Lib.typeIntoEditor} (which types
+     * printable text) does not cover.
      *
      * This is the low-level primitive: it injects the key press and does **not**
      * poll for any effect (a key press has no universal observable outcome —
      * `Enter` edits the document, `Escape` closes a modal, `ArrowDown` moves the
      * selection). The caller focuses the intended target first, then awaits the
-     * expected effect via {@link CommonArgs.waitUntil}. It targets the single
-     * shared window's **global** focus, so only the DOM-focused element receives
-     * the key.
+     * expected effect via {@link Lib.waitUntil}. It targets the single shared
+     * window's **global** focus, so only the DOM-focused element receives the key.
      *
      * @param params - The key to press and any modifiers to hold.
      * @returns A {@link Promise} that resolves once the key press has been
@@ -91,11 +177,10 @@ export interface CommonArgs {
      *
      * Typing is pressing each character key in turn: this focuses the editor
      * (caret to end) and presses every code point of `text` via
-     * {@link CommonArgs.pressKey} — the same trusted `keyDown` → `char` → `keyUp`
-     * a real user produces. Each keystroke is delivered to the window's
-     * DOM-focused element and flows through CodeMirror's real input pipeline, so
-     * the typed text reaches the document **only if the editor genuinely holds
-     * focus**.
+     * {@link Lib.pressKey} — the same trusted `keyDown` → `char` → `keyUp` a real
+     * user produces. Each keystroke is delivered to the window's DOM-focused
+     * element and flows through CodeMirror's real input pipeline, so the typed
+     * text reaches the document **only if the editor genuinely holds focus**.
      * This makes "the user typed into the editor" a faithful end-to-end check,
      * unlike `dispatchEvent(new KeyboardEvent(...))` (untrusted — ignored by
      * CodeMirror) or `execCommand('insertText')` (mutates the selection even
@@ -114,11 +199,11 @@ export interface CommonArgs {
      * using a **trusted** Electron pointer move, then polls until the element no
      * longer matches `:hover`.
      *
-     * The inverse of {@link CommonArgs.hoverElement}. It targets the single
-     * shared window's **global** pointer, so only one element is hovered at a
-     * time. When an element spans the full viewport (no point outside its box is
-     * reachable), use {@link CommonArgs.moveMouse} directly to move the pointer
-     * to a known empty coordinate instead.
+     * The inverse of {@link Lib.hoverElement}. It targets the single shared
+     * window's **global** pointer, so only one element is hovered at a time. When
+     * an element spans the full viewport (no point outside its box is reachable),
+     * use {@link Lib.moveMouse} directly to move the pointer to a known empty
+     * coordinate instead.
      *
      * @param params - The element to move the pointer away from.
      * @returns A {@link Promise} that resolves once the element no longer matches
@@ -133,9 +218,9 @@ export interface CommonArgs {
      * asynchronous effect to settle (a view to open, a DOM node to appear, a
      * setting to apply). Because the callback is serialized via `toString()` and
      * cannot import modules, it can't reuse `obsidian-dev-utils`'
-     * `retryWithTimeout` / `runWithTimeout`. This helper is the shared,
-     * injected replacement for the per-closure poll loops consumers would
-     * otherwise hand-roll.
+     * `retryWithTimeout` / `runWithTimeout`. This helper is the shared, injected
+     * replacement for the per-closure poll loops consumers would otherwise
+     * hand-roll.
      *
      * The `predicate` may be synchronous or asynchronous — it is awaited on every
      * poll. It is checked immediately, then re-checked every
@@ -149,59 +234,6 @@ export interface CommonArgs {
      */
     waitUntil(this: void, params: WaitUntilParams): Promise<void>;
 }
-/**
- * Parameters for {@link evalInObsidian}.
- */
-export interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {
-    /**
-     * Additional arguments to pass to the function. Values may include functions —
-     * they are serialized via `toString()`.
-     */
-    readonly args?: Args;
-    /**
-     * A {@link ContextId} linking this call to a persistent store on `window`
-     * in the Obsidian process. The callback receives a typed `context` object
-     * that survives across calls sharing the same ID.
-     *
-     * When omitted, `context` is a fresh empty object each call.
-     */
-    readonly contextId?: TContextId;
-    /**
-     * The function to evaluate in the Obsidian context.
-     */
-    fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;
-    /**
-     * Skips pre-flight checks (vault registration, CLI availability).
-     * Used internally by vault registration functions.
-     *
-     * @internal
-     */
-    readonly shouldSkipPreflightChecks?: boolean;
-    /**
-     * Override the transport for this call. When omitted, uses the transport
-     * configured via the context provider (set by the framework adapter's global setup).
-     */
-    readonly transport?: ObsidianTransport;
-    /**
-     * The path to the Obsidian vault. Defaults to `process.cwd()`.
-     */
-    readonly vaultPath?: string;
-}
-/**
- * A plain object with string keys.
- */
-export type GenericObject = Record<string, unknown>;
-/**
- * Parameters for {@link CommonArgs.hoverElement}.
- */
-export interface HoverElementParams {
-    /**
-     * The element to hover. The pointer is moved to its center. This is a live
-     * renderer DOM node — the callback runs in-renderer, so no cross-process
-     * serialization is needed (same as {@link TypeIntoEditorParams.editor}).
-     */
-    readonly element: HTMLElement;
-}
 /**
  * Parameters for {@link CommonArgs.moveMouse}.
  */

package/dist/lib/cjs/index.cjs

@@ -25,6 +25,7 @@ __export(index_exports, {
   connectToCdp: () => import_connect_to_cdp.connectToCdp,
   createTransportFromOptions: () => import_transport_factory.createTransportFromOptions,
   evalInObsidian: () => import_eval_in_obsidian.evalInObsidian,
+  registerLibResolver: () => import_lib_registry.registerLibResolver,
   registerVault: () => import_vault_registry.registerVault,
   setTransportOptionsResolver: () => import_context_provider.setTransportOptionsResolver,
   setVaultPathResolver: () => import_context_provider.setVaultPathResolver,
@@ -35,6 +36,7 @@ var import_connect_to_cdp = require("./connect-to-cdp.cjs");
 var import_context_id = require("./context-id.cjs");
 var import_context_provider = require("./context-provider.cjs");
 var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
+var import_lib_registry = require("./lib-registry.cjs");
 var import_temp_vault = require("./temp-vault.cjs");
 var import_transport_appium = require("./transport-appium.cjs");
 var import_transport_desktop_cdp = require("./transport-desktop-cdp.cjs");
@@ -49,9 +51,10 @@ var import_vault_registry = require("./vault-registry.cjs");
   connectToCdp,
   createTransportFromOptions,
   evalInObsidian,
+  registerLibResolver,
   registerVault,
   setTransportOptionsResolver,
   setVaultPathResolver,
   unregisterVault
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogQ29udGFpbnMgdGhlIGVudHJ5IHBvaW50IGZvciB0aGUgaW50ZWdyYXRpb24gdGVzdGluZyBtb2R1bGUuXG4gKi9cblxuZXhwb3J0IHR5cGUge1xuICBDZHBDb25uZWN0aW9uLFxuICBDb25uZWN0VG9DZHBPcHRpb25zXG59IGZyb20gJy4vY29ubmVjdC10by1jZHAuY2pzJztcbmV4cG9ydCB7IGNvbm5lY3RUb0NkcCB9IGZyb20gJy4vY29ubmVjdC10by1jZHAuY2pzJztcbmV4cG9ydCB7IENvbnRleHRJZCB9IGZyb20gJy4vY29udGV4dC1pZC5janMnO1xuZXhwb3J0IHR5cGUge1xuICBUcmFuc3BvcnRPcHRpb25zUmVzb2x2ZXIsXG4gIFZhdWx0UGF0aFJlc29sdmVyXG59IGZyb20gJy4vY29udGV4dC1wcm92aWRlci5janMnO1xuZXhwb3J0IHtcbiAgc2V0VHJhbnNwb3J0T3B0aW9uc1Jlc29sdmVyLFxuICBzZXRWYXVsdFBhdGhSZXNvbHZlclxufSBmcm9tICcuL2NvbnRleHQtcHJvdmlkZXIuY2pzJztcbmV4cG9ydCB0eXBlIHtcbiAgRXZhbEluT2JzaWRpYW5QYXJhbXMsXG4gIEhvdmVyRWxlbWVudFBhcmFtcyxcbiAgTGliLFxuICBNb3ZlTW91c2VQYXJhbXMsXG4gIFByZXNzS2V5UGFyYW1zLFxuICBUeXBlSW50b0VkaXRvclBhcmFtcyxcbiAgVW5ob3ZlckVsZW1lbnRQYXJhbXMsXG4gIFdhaXRVbnRpbFBhcmFtc1xufSBmcm9tICcuL2V2YWwtaW4tb2JzaWRpYW4uY2pzJztcbmV4cG9ydCB7IGV2YWxJbk9ic2lkaWFuIH0gZnJvbSAnLi9ldmFsLWluLW9ic2lkaWFuLmNqcyc7XG5leHBvcnQgdHlwZSB7IExpYlJlc29sdmVyIH0gZnJvbSAnLi9saWItcmVnaXN0cnkuY2pzJztcbmV4cG9ydCB7IHJlZ2lzdGVyTGliUmVzb2x2ZXIgfSBmcm9tICcuL2xpYi1yZWdpc3RyeS5janMnO1xuZXhwb3J0IHR5cGUge1xuICBQb3B1bGF0ZUZpbGVDb250ZW50LFxuICBQb3B1bGF0ZUZpbGVzUGFyYW1zXG59IGZyb20gJy4vdGVtcC12YXVsdC5janMnO1xuZXhwb3J0IHsgVGVtcFZhdWx0IH0gZnJvbSAnLi90ZW1wLXZhdWx0LmNqcyc7XG5leHBvcnQgdHlwZSB7XG4gIEFwcGl1bVNlc3Npb25JbmZvLFxuICBBcHBpdW1UcmFuc3BvcnRDb25maWdcbn0gZnJvbSAnLi90cmFuc3BvcnQtYXBwaXVtLmNqcyc7XG5leHBvcnQgeyBBcHBpdW1UcmFuc3BvcnQgfSBmcm9tICcuL3RyYW5zcG9ydC1hcHBpdW0uY2pzJztcbmV4cG9ydCB0eXBlIHtcbiAgRGVza3RvcENkcFRyYW5zcG9ydENvbmZpZyxcbiAgT3duZWRJbnN0YW5jZUFzYXIsXG4gIE93bmVkSW5zdGFuY2VDb25maWdcbn0gZnJvbSAnLi90cmFuc3BvcnQtZGVza3RvcC1jZHAuY2pzJztcbmV4cG9ydCB7IERlc2t0b3BDZHBUcmFuc3BvcnQgfSBmcm9tICcuL3RyYW5zcG9ydC1kZXNrdG9wLWNkcC5janMnO1xuZXhwb3J0IHsgY3JlYXRlVHJhbnNwb3J0RnJvbU9wdGlvbnMgfSBmcm9tICcuL3RyYW5zcG9ydC1mYWN0b3J5LmNqcyc7XG5leHBvcnQgdHlwZSB7XG4gIE9ic2lkaWFuQW5kcm9pZEFwcGl1bVRyYW5zcG9ydE9wdGlvbnMsXG4gIE9ic2lkaWFuQ2RwVHJhbnNwb3J0T3B0aW9ucyxcbiAgT2JzaWRpYW5UcmFuc3BvcnRPcHRpb25zXG59IGZyb20gJy4vdHJhbnNwb3J0LW9wdGlvbnMuY2pzJztcbmV4cG9ydCB0eXBlIHtcbiAgT2JzaWRpYW5UcmFuc3BvcnQsXG4gIFRyYW5zcG9ydEV2YWxPcHRpb25zXG59IGZyb20gJy4vdHJhbnNwb3J0LmNqcyc7XG5leHBvcnQge1xuICByZWdpc3RlclZhdWx0LFxuICB1bnJlZ2lzdGVyVmF1bHRcbn0gZnJvbSAnLi92YXVsdC1yZWdpc3RyeS5janMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFVQSw0QkFBNkI7QUFDN0Isd0JBQTBCO0FBSzFCLDhCQUdPO0FBV1AsOEJBQStCO0FBRS9CLDBCQUFvQztBQUtwQyx3QkFBMEI7QUFLMUIsOEJBQWdDO0FBTWhDLG1DQUFvQztBQUNwQywrQkFBMkM7QUFVM0MsNEJBR087IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/cjs/index.d.cts

@@ -8,8 +8,10 @@ export { connectToCdp } from './connect-to-cdp.cjs';
 export { ContextId } from './context-id.cjs';
 export type { TransportOptionsResolver, VaultPathResolver } from './context-provider.cjs';
 export { setTransportOptionsResolver, setVaultPathResolver } from './context-provider.cjs';
-export type { EvalInObsidianParams, HoverElementParams, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams, WaitUntilParams } from './eval-in-obsidian.cjs';
+export type { EvalInObsidianParams, HoverElementParams, Lib, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams, WaitUntilParams } from './eval-in-obsidian.cjs';
 export { evalInObsidian } from './eval-in-obsidian.cjs';
+export type { LibResolver } from './lib-registry.cjs';
+export { registerLibResolver } from './lib-registry.cjs';
 export type { PopulateFileContent, PopulateFilesParams } from './temp-vault.cjs';
 export { TempVault } from './temp-vault.cjs';
 export type { AppiumSessionInfo, AppiumTransportConfig } from './transport-appium.cjs';

package/dist/lib/cjs/lib-registry.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lib_registry_exports = {};
+__export(lib_registry_exports, {
+  computeBootstrapVersion: () => computeBootstrapVersion,
+  getBootstrapVersion: () => getBootstrapVersion,
+  getRegisteredLibResolvers: () => getRegisteredLibResolvers,
+  registerLibResolver: () => registerLibResolver
+});
+module.exports = __toCommonJS(lib_registry_exports);
+var import_library = require("./library.cjs");
+const libResolvers = [];
+const registeredResolverSources = /* @__PURE__ */ new Set();
+function computeBootstrapVersion(version, resolvers) {
+  if (resolvers.length === 0) {
+    return version;
+  }
+  const SEPARATOR = "\0";
+  const sources = resolvers.map((resolver) => resolver.toString()).join(SEPARATOR);
+  return `${version}${SEPARATOR}${sources}`;
+}
+function getBootstrapVersion() {
+  return computeBootstrapVersion(import_library.LIBRARY_VERSION, libResolvers);
+}
+function getRegisteredLibResolvers() {
+  return libResolvers;
+}
+function registerLibResolver(resolver) {
+  const source = resolver.toString();
+  if (registeredResolverSources.has(source)) {
+    return;
+  }
+  registeredResolverSources.add(source);
+  libResolvers.push(resolver);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeBootstrapVersion,
+  getBootstrapVersion,
+  getRegisteredLibResolvers,
+  registerLibResolver
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/lib-registry.d.cts

@@ -0,0 +1,67 @@
+/**
+ * @file
+ *
+ * Registry of renderer-side resolvers that populate the `lib` argument injected
+ * into every {@link evalInObsidian} callback.
+ *
+ * A provider package (e.g. `obsidian-dev-utils`) registers a resolver via
+ * {@link registerLibResolver} from its per-worker test setup (`setupFiles`),
+ * like the context resolvers in `context-provider.ts` — registration must happen
+ * in the worker because the namespace bootstrap is generated per-worker. Each
+ * resolver is a self-contained function that runs inside the Obsidian renderer
+ * and returns an object; the harness serializes it into the bootstrap and
+ * `Object.assign`s every resolver's result into the single `lib` bag.
+ */
+/**
+ * A self-contained function, evaluated inside the Obsidian renderer, that returns
+ * an object whose own enumerable properties are merged (via `Object.assign`) into
+ * the injected `lib` bag.
+ *
+ * It is serialized via `toString()` and must not close over any module scope
+ * (imports are unavailable in the serialized renderer closure); read a renderer
+ * global instead (e.g. a value a fixture plugin published on `window`). Returning
+ * `null`/`undefined` is tolerated at runtime (`Object.assign` ignores it).
+ *
+ * @returns The object whose own enumerable properties are merged into `lib`.
+ */
+export type LibResolver = (this: void) => object;
+/**
+ * Computes the namespace-bootstrap version string, folding the registered
+ * resolver sources into the base library version so that a changed resolver set
+ * forces a re-bootstrap of the shared Obsidian instance.
+ *
+ * Pure — takes the resolver array explicitly so it can be unit-tested without
+ * touching the module-level registry.
+ *
+ * @param version - The base library version.
+ * @param resolvers - The registered resolvers.
+ * @returns The base version when `resolvers` is empty; otherwise the base version
+ *   combined with every resolver's source text.
+ */
+export declare function computeBootstrapVersion(version: string, resolvers: readonly LibResolver[]): string;
+/**
+ * Returns the namespace-bootstrap version for the currently registered
+ * resolvers — {@link computeBootstrapVersion} applied to
+ * {@link getRegisteredLibResolvers}.
+ *
+ * @returns The bootstrap version string.
+ */
+export declare function getBootstrapVersion(): string;
+/**
+ * Returns every registered {@link LibResolver}, in registration order.
+ *
+ * @returns The registered resolvers.
+ */
+export declare function getRegisteredLibResolvers(): readonly LibResolver[];
+/**
+ * Registers a renderer-side resolver whose result is merged into the `lib`
+ * argument of every {@link evalInObsidian} callback. Call from a provider's
+ * per-worker test setup (`setupFiles`), like the context resolvers.
+ *
+ * Registration is idempotent by source text: registering a resolver whose
+ * `toString()` matches an already-registered one is a no-op, so a setup module
+ * evaluated more than once does not merge the same library twice.
+ *
+ * @param resolver - The resolver function.
+ */
+export declare function registerLibResolver(resolver: LibResolver): void;

package/dist/lib/cjs/library.cjs

@@ -21,7 +21,7 @@ __export(library_exports, {
   LIBRARY_VERSION: () => LIBRARY_VERSION
 });
 module.exports = __toCommonJS(library_exports);
-const LIBRARY_VERSION = false ? "dev" : "5.6.0";
+const LIBRARY_VERSION = false ? "dev" : "6.2.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LIBRARY_VERSION