obsidian-integration-testing 8.3.0 → 9.0.0

package/dist/lib/cjs/connect-to-cdp.cjs

@@ -22,6 +22,7 @@ __export(connect_to_cdp_exports, {
 });
 module.exports = __toCommonJS(connect_to_cdp_exports);
 var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
+var import_normalize_optional_properties = require("./normalize-optional-properties.cjs");
 var import_temp_vault = require("./temp-vault.cjs");
 var import_transport_desktop_cdp = require("./transport-desktop-cdp.cjs");
 var import_transport_factory = require("./transport-factory.cjs");
@@ -33,10 +34,12 @@ async function connectToCdp(options) {
   await vault.register(transport);
   const { host, port } = resolveEndpoint(transport, options);
   const cdpUrl = `http://${host}:${String(port)}`;
+  const asarFallback = transport instanceof import_transport_desktop_cdp.DesktopCdpTransport ? transport.getAsarFallback() : void 0;
   const compatibility = transport instanceof import_transport_desktop_cdp.DesktopCdpTransport ? transport.getCompatibility() : void 0;
   const electronCompatibility = transport instanceof import_transport_desktop_cdp.DesktopCdpTransport ? transport.getElectronCompatibility() : void 0;
   const connection = {
     cdpUrl,
+    ...asarFallback && { asarFallback },
     ...compatibility && { compatibility },
     ...electronCompatibility && { electronCompatibility },
     async dispose() {
@@ -65,24 +68,20 @@ async function connectToCdp(options) {
   return connection;
 }
 function buildCdpTransportOptions(options) {
-  return {
+  return (0, import_normalize_optional_properties.normalizeOptionalProperties)({
+    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,
+    deadBootGraceInMilliseconds: options?.deadBootGraceInMilliseconds,
+    host: options?.host,
     isObsidianAppVisible: options?.isObsidianAppVisible ?? true,
-    type: "obsidian-cdp",
-    ...options?.commandTimeoutInMilliseconds !== void 0 && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds },
-    ...options?.deadBootGraceInMilliseconds !== void 0 && { deadBootGraceInMilliseconds: options.deadBootGraceInMilliseconds },
-    ...options?.host !== void 0 && { host: options.host },
-    ...options?.obsidianInstallerVersion !== void 0 && { obsidianInstallerVersion: options.obsidianInstallerVersion },
-    ...options?.obsidianVersion !== void 0 && { obsidianVersion: options.obsidianVersion },
-    ...options?.port !== void 0 && { port: options.port },
-    ...options?.shouldDisableSandbox !== void 0 && { shouldDisableSandbox: options.shouldDisableSandbox },
-    ...buildCompatibilityTransportOptions(options)
-  };
-}
-function buildCompatibilityTransportOptions(options) {
-  return {
-    ...options?.shouldThrowOnIncompatibleInstaller !== void 0 && { shouldThrowOnIncompatibleInstaller: options.shouldThrowOnIncompatibleInstaller },
-    ...options?.shouldWarnOnCompatibilityIssues !== void 0 && { shouldWarnOnCompatibilityIssues: options.shouldWarnOnCompatibilityIssues }
-  };
+    obsidianInstallerVersion: options?.obsidianInstallerVersion,
+    obsidianVersion: options?.obsidianVersion,
+    port: options?.port,
+    shouldDisableSandbox: options?.shouldDisableSandbox,
+    shouldThrowOnIncompatibleInstaller: options?.shouldThrowOnIncompatibleInstaller,
+    shouldThrowOnSilentAsarFallback: options?.shouldThrowOnSilentAsarFallback,
+    shouldWarnOnCompatibilityIssues: options?.shouldWarnOnCompatibilityIssues,
+    type: "obsidian-cdp"
+  });
 }
 function resolveEndpoint(transport, options) {
   if (transport instanceof import_transport_desktop_cdp.DesktopCdpTransport) {
@@ -100,4 +99,4 @@ function resolveEndpoint(transport, options) {
 0 && (module.exports = {
   connectToCdp
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * the base `lib` helpers, `errorToString`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { ContextId } from './context-id.cjs';\nimport type { ElectronCompatibility } from './electron-compatibility.cjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { InstallerCompatibility } from './installer-compatibility.cjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.cjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { TempVault } from './temp-vault.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * The resolved installer\u2194app compatibility verdict for an owned instance, when\n   * it could be determined. `undefined` in attach mode, or when the verdict is\n   * unknown (undetectable shell version, or the app version is absent from the\n   * table). An `'unrunnable'` verdict reaches here only when the proactive throw\n   * is disabled ({@link ConnectToCdpOptions.shouldThrowOnIncompatibleInstaller}\n   * `false`); otherwise it throws `IncompatibleInstallerVersionError` before the\n   * connection is created.\n   */\n  readonly compatibility?: InstallerCompatibility | undefined;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * The runtime Electron compatibility verdict for an owned instance, read live\n   * after boot: whether the Electron version it is actually running is new enough\n   * for the running app version. `undefined` in attach mode, or when the verdict\n   * is unknown (the live version was unreadable, or the app version carries no\n   * recommended Electron version). An old Electron never blocks \u2014 it only warns \u2014\n   * so unlike {@link compatibility} there is no throwing tier.\n   */\n  readonly electronCompatibility?: ElectronCompatibility | undefined;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, lib, obsidianModule, context }` plus any `args`\n   * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors\n   * the top-level `evalInObsidian`, with the transport and vault path pre-bound\n   * to this connection.\n   *\n   * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `fn`.\n   */\n  evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TempVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * Grace window in milliseconds for fast-failing a dead boot of the owned\n   * instance \u2014 the renderer loaded but the app never bootstrapped (empty\n   * `<body>`, no `window.app`), the terminal state when the asar cannot run on\n   * the launched Electron shell. Once it has held this long a\n   * `RendererFailedToInitializeError` is thrown instead of waiting out the full\n   * readiness timeout. Ignored in attach mode ({@link port} set). Set `0` to\n   * disable fast-fail.\n   *\n   * @default `10000`\n   */\n  readonly deadBootGraceInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Whether the Obsidian window is shown on screen. Defaults to `true`; set\n   * `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to launch the owned instance with Chromium's sandbox disabled\n   * (`--no-sandbox`).\n   *\n   * Needed to boot on Linux without a correctly-configured setuid\n   * `chrome-sandbox` helper (e.g. an installer-extracted portable shell, or CI\n   * running as a non-root user); harmless on Windows/macOS. Ignored in attach\n   * mode ({@link port} set).\n   *\n   * @default `false`\n   */\n  readonly shouldDisableSandbox?: boolean;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Whether an **unrunnable** installer\u2194app version pair fails fast before launch.\n   *\n   * When `true` (the default), an installer below the app's run floor throws\n   * `IncompatibleInstallerVersionError` from version resolution before anything is\n   * downloaded or launched. Set `false` to let the pin proceed to launch \u2014 where\n   * the reactive dead-boot fast-fail still catches the black-screen boot, and the\n   * `'unrunnable'` verdict is surfaced on {@link CdpConnection.compatibility}\n   * rather than thrown. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnIncompatibleInstaller?: boolean;\n\n  /**\n   * Whether the owned-instance compatibility **nag warnings** are emitted.\n   *\n   * Covers both the offline installer\u2194app warning and the post-boot\n   * runtime-Electron warning. When `true` (the default) each fires via the harness\n   * log; set `false` to silence both \u2014 the verdicts are still surfaced on\n   * {@link CdpConnection.compatibility} / {@link CdpConnection.electronCompatibility},\n   * only the log is suppressed. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldWarnOnCompatibilityIssues?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transport = await createTransportFromOptions(buildCdpTransportOptions(options));\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n  const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : undefined;\n  const electronCompatibility = transport instanceof DesktopCdpTransport ? transport.getElectronCompatibility() : undefined;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n    ...(compatibility && { compatibility }),\n    ...(electronCompatibility && { electronCompatibility }),\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Args, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Builds the {@link ObsidianCdpTransportOptions} for a connection, threading only\n * the provided {@link ConnectToCdpOptions} through (owned-visible defaults to\n * `true`, unlike the hidden-by-default test transports).\n *\n * @param options - The connection options.\n * @returns The transport options to create the connection's transport from.\n */\nfunction buildCdpTransportOptions(options?: ConnectToCdpOptions): ObsidianCdpTransportOptions {\n  return {\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    type: 'obsidian-cdp',\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    ...(options?.deadBootGraceInMilliseconds !== undefined && { deadBootGraceInMilliseconds: options.deadBootGraceInMilliseconds }),\n    ...(options?.host !== undefined && { host: options.host }),\n    ...(options?.obsidianInstallerVersion !== undefined && { obsidianInstallerVersion: options.obsidianInstallerVersion }),\n    ...(options?.obsidianVersion !== undefined && { obsidianVersion: options.obsidianVersion }),\n    ...(options?.port !== undefined && { port: options.port }),\n    ...(options?.shouldDisableSandbox !== undefined && { shouldDisableSandbox: options.shouldDisableSandbox }),\n    ...buildCompatibilityTransportOptions(options)\n  };\n}\n\n/**\n * Builds the compatibility-knob passthrough options ({@link ObsidianCdpTransportOptions.shouldThrowOnIncompatibleInstaller}\n * / {@link ObsidianCdpTransportOptions.shouldWarnOnCompatibilityIssues}) for a\n * connection, split out of {@link buildCdpTransportOptions} to keep its\n * complexity in bounds. Only forwards knobs the caller actually set.\n *\n * @param options - The connection options.\n * @returns The compatibility passthrough options (possibly empty).\n */\nfunction buildCompatibilityTransportOptions(options?: ConnectToCdpOptions): Partial<ObsidianCdpTransportOptions> {\n  return {\n    ...(options?.shouldThrowOnIncompatibleInstaller !== undefined && { shouldThrowOnIncompatibleInstaller: options.shouldThrowOnIncompatibleInstaller }),\n    ...(options?.shouldWarnOnCompatibilityIssues !== undefined && { shouldWarnOnCompatibilityIssues: options.shouldWarnOnCompatibilityIssues })\n  };\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BA,8BAA+B;AAC/B,wBAA0B;AAC1B,mCAAoC;AACpC,+BAA2C;AAE3C,MAAM,mBAAmB;AA8NzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,YAAY,UAAM,qDAA2B,yBAAyB,OAAO,CAAC;AACpF,QAAM,QAAQ,IAAI,4BAAU,SAAS,KAAK;AAC1C,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAK9F,QAAM,MAAM,SAAS,SAAS;AAE9B,QAAM,EAAE,MAAM,KAAK,IAAI,gBAAgB,WAAW,OAAO;AACzD,QAAM,SAAS,UAAU,IAAI,IAAI,OAAO,IAAI,CAAC;AAC7C,QAAM,gBAAgB,qBAAqB,mDAAsB,UAAU,iBAAiB,IAAI;AAChG,QAAM,wBAAwB,qBAAqB,mDAAsB,UAAU,yBAAyB,IAAI;AAEhH,QAAM,aAA4B;AAAA,IAChC;AAAA,IACA,GAAI,iBAAiB,EAAE,cAAc;AAAA,IACrC,GAAI,yBAAyB,EAAE,sBAAsB;AAAA,IAErD,MAAM,UAAyB;AAC7B,UAAI;AACF,YAAI,4BAA4B;AAC9B,gBAAM,MAAM,QAAQ,SAAS;AAAA,QAC/B,OAAO;AACL,gBAAM,UAAU,gBAAgB,MAAM,IAAI;AAAA,QAC5C;AAAA,MACF,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,iBAAO,wCAAyC,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IACjG;AAAA,IAEA,MAAM,OAAO,YAAqC;AAChD,aAAO,UAAU,SAAS,YAAY,EAAE,KAAK,MAAM,KAAK,CAAC;AAAA,IAC3D;AAAA,IAEA;AAAA,IAEA,OAAO,OAAO,YAAY,IAAmB;AAC3C,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,IAEA;AAAA,EACF;AAEA,SAAO;AACT;AAUA,SAAS,yBAAyB,SAA4D;AAC5F,SAAO;AAAA,IACL,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,MAAM;AAAA,IACN,GAAI,SAAS,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IAChI,GAAI,SAAS,gCAAgC,UAAa,EAAE,6BAA6B,QAAQ,4BAA4B;AAAA,IAC7H,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,6BAA6B,UAAa,EAAE,0BAA0B,QAAQ,yBAAyB;AAAA,IACpH,GAAI,SAAS,oBAAoB,UAAa,EAAE,iBAAiB,QAAQ,gBAAgB;AAAA,IACzF,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,yBAAyB,UAAa,EAAE,sBAAsB,QAAQ,qBAAqB;AAAA,IACxG,GAAG,mCAAmC,OAAO;AAAA,EAC/C;AACF;AAWA,SAAS,mCAAmC,SAAqE;AAC/G,SAAO;AAAA,IACL,GAAI,SAAS,uCAAuC,UAAa,EAAE,oCAAoC,QAAQ,mCAAmC;AAAA,IAClJ,GAAI,SAAS,oCAAoC,UAAa,EAAE,iCAAiC,QAAQ,gCAAgC;AAAA,EAC3I;AACF;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,kDAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * the base `lib` helpers, `errorToString`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { AsarFallback } from './asar-fallback-detection.cjs';\nimport type { ContextId } from './context-id.cjs';\nimport type { ElectronCompatibility } from './electron-compatibility.cjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { InstallerCompatibility } from './installer-compatibility.cjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.cjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.cjs';\nimport { TempVault } from './temp-vault.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The silent-asar-fallback verdict for an owned instance, read live after boot:\n   * whether the app version it is actually running matches the swapped-in pin, or\n   * the installer silently reverted to its own bundled asar. `undefined` in attach\n   * mode, when no asar was swapped, or when the running version was unreadable. A\n   * `'fallback'` verdict reaches here only when the throw is disabled\n   * ({@link ConnectToCdpOptions.shouldThrowOnSilentAsarFallback} `false`);\n   * otherwise it throws `SilentAsarFallbackError` before the connection is created.\n   */\n  readonly asarFallback?: AsarFallback | undefined;\n\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * The resolved installer\u2194app compatibility verdict for an owned instance, when\n   * it could be determined. `undefined` in attach mode, or when the verdict is\n   * unknown (undetectable shell version, or the app version is absent from the\n   * table). An `'unrunnable'` verdict reaches here only when the proactive throw\n   * is disabled ({@link ConnectToCdpOptions.shouldThrowOnIncompatibleInstaller}\n   * `false`); otherwise it throws `IncompatibleInstallerVersionError` before the\n   * connection is created.\n   */\n  readonly compatibility?: InstallerCompatibility | undefined;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * The runtime Electron compatibility verdict for an owned instance, read live\n   * after boot: whether the Electron version it is actually running is new enough\n   * for the running app version. `undefined` in attach mode, or when the verdict\n   * is unknown (the live version was unreadable, or the app version carries no\n   * recommended Electron version). An old Electron never blocks \u2014 it only warns \u2014\n   * so unlike {@link compatibility} there is no throwing tier.\n   */\n  readonly electronCompatibility?: ElectronCompatibility | undefined;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, lib, obsidianModule, context }` plus any `args`\n   * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors\n   * the top-level `evalInObsidian`, with the transport and vault path pre-bound\n   * to this connection.\n   *\n   * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `fn`.\n   */\n  evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TempVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * Grace window in milliseconds for fast-failing a dead boot of the owned\n   * instance \u2014 the renderer loaded but the app never bootstrapped (empty\n   * `<body>`, no `window.app`), the terminal state when the asar cannot run on\n   * the launched Electron shell. Once it has held this long a\n   * `RendererFailedToInitializeError` is thrown instead of waiting out the full\n   * readiness timeout. Ignored in attach mode ({@link port} set). Set `0` to\n   * disable fast-fail.\n   *\n   * @default `10000`\n   */\n  readonly deadBootGraceInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Whether the Obsidian window is shown on screen. Defaults to `true`; set\n   * `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to launch the owned instance with Chromium's sandbox disabled\n   * (`--no-sandbox`).\n   *\n   * Needed to boot on Linux without a correctly-configured setuid\n   * `chrome-sandbox` helper (e.g. an installer-extracted portable shell, or CI\n   * running as a non-root user); harmless on Windows/macOS. Ignored in attach\n   * mode ({@link port} set).\n   *\n   * @default `false`\n   */\n  readonly shouldDisableSandbox?: boolean;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Whether an **unrunnable** installer\u2194app version pair fails fast before launch.\n   *\n   * When `true` (the default), an installer below the app's run floor throws\n   * `IncompatibleInstallerVersionError` from version resolution before anything is\n   * downloaded or launched. Set `false` to let the pin proceed to launch \u2014 where\n   * the reactive dead-boot fast-fail still catches the black-screen boot, and the\n   * `'unrunnable'` verdict is surfaced on {@link CdpConnection.compatibility}\n   * rather than thrown. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnIncompatibleInstaller?: boolean;\n\n  /**\n   * Whether a post-boot **silent asar fallback** fails fast.\n   *\n   * When an asar is swapped onto an installer shell too old for it, the instance\n   * may silently revert to the installer's own bundled asar and run the **wrong\n   * (older)** version behind a healthy UI. When `true` (the default), the running\n   * app version is verified against the pin post-boot and a mismatch throws\n   * `SilentAsarFallbackError`. Set `false` to let the boot proceed \u2014 the mismatch\n   * is then surfaced on {@link CdpConnection.asarFallback} rather than thrown.\n   * Ignored in attach mode ({@link port} set) and when no asar is swapped.\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnSilentAsarFallback?: boolean;\n\n  /**\n   * Whether the owned-instance compatibility **nag warnings** are emitted.\n   *\n   * Covers both the offline installer\u2194app warning and the post-boot\n   * runtime-Electron warning. When `true` (the default) each fires via the harness\n   * log; set `false` to silence both \u2014 the verdicts are still surfaced on\n   * {@link CdpConnection.compatibility} / {@link CdpConnection.electronCompatibility},\n   * only the log is suppressed. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldWarnOnCompatibilityIssues?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transport = await createTransportFromOptions(buildCdpTransportOptions(options));\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n  const asarFallback = transport instanceof DesktopCdpTransport ? transport.getAsarFallback() : undefined;\n  const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : undefined;\n  const electronCompatibility = transport instanceof DesktopCdpTransport ? transport.getElectronCompatibility() : undefined;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n    ...(asarFallback && { asarFallback }),\n    ...(compatibility && { compatibility }),\n    ...(electronCompatibility && { electronCompatibility }),\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Args, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Builds the {@link ObsidianCdpTransportOptions} for a connection, threading only\n * the provided {@link ConnectToCdpOptions} through (owned-visible defaults to\n * `true`, unlike the hidden-by-default test transports). Unset knobs pass through\n * as `undefined` and are read with `?? default` / `!== undefined` guards\n * downstream, so an explicit `undefined` is indistinguishable from an absent key.\n *\n * @param options - The connection options.\n * @returns The transport options to create the connection's transport from.\n */\nfunction buildCdpTransportOptions(options?: ConnectToCdpOptions): ObsidianCdpTransportOptions {\n  return normalizeOptionalProperties<ObsidianCdpTransportOptions>({\n    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,\n    deadBootGraceInMilliseconds: options?.deadBootGraceInMilliseconds,\n    host: options?.host,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    obsidianInstallerVersion: options?.obsidianInstallerVersion,\n    obsidianVersion: options?.obsidianVersion,\n    port: options?.port,\n    shouldDisableSandbox: options?.shouldDisableSandbox,\n    shouldThrowOnIncompatibleInstaller: options?.shouldThrowOnIncompatibleInstaller,\n    shouldThrowOnSilentAsarFallback: options?.shouldThrowOnSilentAsarFallback,\n    shouldWarnOnCompatibilityIssues: options?.shouldWarnOnCompatibilityIssues,\n    type: 'obsidian-cdp'\n  });\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BA,8BAA+B;AAC/B,2CAA4C;AAC5C,wBAA0B;AAC1B,mCAAoC;AACpC,+BAA2C;AAE3C,MAAM,mBAAmB;AAwPzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,YAAY,UAAM,qDAA2B,yBAAyB,OAAO,CAAC;AACpF,QAAM,QAAQ,IAAI,4BAAU,SAAS,KAAK;AAC1C,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAK9F,QAAM,MAAM,SAAS,SAAS;AAE9B,QAAM,EAAE,MAAM,KAAK,IAAI,gBAAgB,WAAW,OAAO;AACzD,QAAM,SAAS,UAAU,IAAI,IAAI,OAAO,IAAI,CAAC;AAC7C,QAAM,eAAe,qBAAqB,mDAAsB,UAAU,gBAAgB,IAAI;AAC9F,QAAM,gBAAgB,qBAAqB,mDAAsB,UAAU,iBAAiB,IAAI;AAChG,QAAM,wBAAwB,qBAAqB,mDAAsB,UAAU,yBAAyB,IAAI;AAEhH,QAAM,aAA4B;AAAA,IAChC;AAAA,IACA,GAAI,gBAAgB,EAAE,aAAa;AAAA,IACnC,GAAI,iBAAiB,EAAE,cAAc;AAAA,IACrC,GAAI,yBAAyB,EAAE,sBAAsB;AAAA,IAErD,MAAM,UAAyB;AAC7B,UAAI;AACF,YAAI,4BAA4B;AAC9B,gBAAM,MAAM,QAAQ,SAAS;AAAA,QAC/B,OAAO;AACL,gBAAM,UAAU,gBAAgB,MAAM,IAAI;AAAA,QAC5C;AAAA,MACF,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,iBAAO,wCAAyC,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IACjG;AAAA,IAEA,MAAM,OAAO,YAAqC;AAChD,aAAO,UAAU,SAAS,YAAY,EAAE,KAAK,MAAM,KAAK,CAAC;AAAA,IAC3D;AAAA,IAEA;AAAA,IAEA,OAAO,OAAO,YAAY,IAAmB;AAC3C,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,IAEA;AAAA,EACF;AAEA,SAAO;AACT;AAYA,SAAS,yBAAyB,SAA4D;AAC5F,aAAO,kEAAyD;AAAA,IAC9D,8BAA8B,SAAS;AAAA,IACvC,6BAA6B,SAAS;AAAA,IACtC,MAAM,SAAS;AAAA,IACf,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,0BAA0B,SAAS;AAAA,IACnC,iBAAiB,SAAS;AAAA,IAC1B,MAAM,SAAS;AAAA,IACf,sBAAsB,SAAS;AAAA,IAC/B,oCAAoC,SAAS;AAAA,IAC7C,iCAAiC,SAAS;AAAA,IAC1C,iCAAiC,SAAS;AAAA,IAC1C,MAAM;AAAA,EACR,CAAC;AACH;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,kDAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
  "names": []
}


package/dist/lib/cjs/connect-to-cdp.d.cts

@@ -11,6 +11,7 @@
  * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.
  */
 import type { Except } from 'type-fest';
+import type { AsarFallback } from './asar-fallback-detection.cjs';
 import type { ContextId } from './context-id.cjs';
 import type { ElectronCompatibility } from './electron-compatibility.cjs';
 import type { EvalInObsidianParams, GenericObject } from './eval-in-obsidian.cjs';
@@ -25,6 +26,16 @@ import { TempVault } from './temp-vault.cjs';
  * removing its directory) automatically.
  */
 export interface CdpConnection extends AsyncDisposable {
+    /**
+     * The silent-asar-fallback verdict for an owned instance, read live after boot:
+     * whether the app version it is actually running matches the swapped-in pin, or
+     * the installer silently reverted to its own bundled asar. `undefined` in attach
+     * mode, when no asar was swapped, or when the running version was unreadable. A
+     * `'fallback'` verdict reaches here only when the throw is disabled
+     * ({@link ConnectToCdpOptions.shouldThrowOnSilentAsarFallback} `false`);
+     * otherwise it throws `SilentAsarFallbackError` before the connection is created.
+     */
+    readonly asarFallback?: AsarFallback | undefined;
     /**
      * The base CDP URL, e.g. `http://localhost:51888`.
      */
@@ -178,6 +189,20 @@ export interface ConnectToCdpOptions {
      * @default `true`
      */
     readonly shouldThrowOnIncompatibleInstaller?: boolean;
+    /**
+     * Whether a post-boot **silent asar fallback** fails fast.
+     *
+     * When an asar is swapped onto an installer shell too old for it, the instance
+     * may silently revert to the installer's own bundled asar and run the **wrong
+     * (older)** version behind a healthy UI. When `true` (the default), the running
+     * app version is verified against the pin post-boot and a mismatch throws
+     * `SilentAsarFallbackError`. Set `false` to let the boot proceed — the mismatch
+     * is then surfaced on {@link CdpConnection.asarFallback} rather than thrown.
+     * Ignored in attach mode ({@link port} set) and when no asar is swapped.
+     *
+     * @default `true`
+     */
+    readonly shouldThrowOnSilentAsarFallback?: boolean;
     /**
      * Whether the owned-instance compatibility **nag warnings** are emitted.
      *

package/dist/lib/cjs/demo-vault-tree.cjs

@@ -0,0 +1,52 @@
+"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 demo_vault_tree_exports = {};
+__export(demo_vault_tree_exports, {
+  readDemoVaultTree: () => readDemoVaultTree
+});
+module.exports = __toCommonJS(demo_vault_tree_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+const DEFAULT_EXCLUDED_NAMES = [".git", ".obsidian"];
+function readDemoVaultTree(params) {
+  const { demoVaultPath } = params;
+  const excludedNames = new Set(params.excludedNames ?? DEFAULT_EXCLUDED_NAMES);
+  const map = {};
+  collect(demoVaultPath, demoVaultPath, excludedNames, map);
+  return map;
+}
+function collect(root, dir, excludedNames, map) {
+  for (const entry of (0, import_node_fs.readdirSync)(dir, { withFileTypes: true })) {
+    if (excludedNames.has(entry.name)) {
+      continue;
+    }
+    const absolutePath = (0, import_node_path.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      collect(root, absolutePath, excludedNames, map);
+      continue;
+    }
+    const relativePath = (0, import_node_path.relative)(root, absolutePath).split(import_node_path.sep).join("/");
+    map[relativePath] = (0, import_node_fs.readFileSync)(absolutePath);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readDemoVaultTree
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/demo-vault-tree.d.cts

@@ -0,0 +1,34 @@
+/**
+ * @file
+ *
+ * Reads a plugin's in-repo `demo-vault/` tree into a populate map so a Vitest/Jest global setup can
+ * seed it into the temp vault BEFORE Obsidian opens it. Seeding pre-launch lets Obsidian's startup scan
+ * index every note in one pass, avoiding the file-watcher race that silently drops events under a bulk
+ * post-launch {@link TempVault.populate}.
+ */
+import type { PopulateFilesParams } from './temp-vault.cjs';
+/**
+ * Parameters for {@link readDemoVaultTree}.
+ */
+export interface ReadDemoVaultTreeParams {
+    /**
+     * Absolute path to the demo vault directory to read.
+     */
+    readonly demoVaultPath: string;
+    /**
+     * Names (of files or directories, matched at any depth) to skip. Defaults to `.git` and `.obsidian`:
+     * the harness provisions `.obsidian/plugins/<id>` itself, so the vault's own `.obsidian` must not be
+     * copied over it.
+     *
+     * @default `['.git', '.obsidian']`
+     */
+    readonly excludedNames?: Iterable<string>;
+}
+/**
+ * Reads a demo vault directory tree recursively into a {@link PopulateFilesParams} map (vault-relative
+ * POSIX path to file bytes), skipping {@link ReadDemoVaultTreeParams.excludedNames}.
+ *
+ * @param params - The {@link ReadDemoVaultTreeParams}.
+ * @returns The populate map, ready to hand to {@link TempVault.populate} or a global setup's `populate`.
+ */
+export declare function readDemoVaultTree(params: ReadDemoVaultTreeParams): PopulateFilesParams;

package/dist/lib/cjs/ecmascript-version.cjs

@@ -0,0 +1,63 @@
+"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 ecmascript_version_exports = {};
+__export(ecmascript_version_exports, {
+  deriveEcmaScriptVersion: () => deriveEcmaScriptVersion
+});
+module.exports = __toCommonJS(ecmascript_version_exports);
+const CHROME_MAJOR_FOR_ES2015 = 51;
+const CHROME_MAJOR_FOR_ES2016 = 52;
+const CHROME_MAJOR_FOR_ES2017 = 58;
+const CHROME_MAJOR_FOR_ES2018 = 64;
+const CHROME_MAJOR_FOR_ES2019 = 73;
+const CHROME_MAJOR_FOR_ES2020 = 80;
+const CHROME_MAJOR_FOR_ES2021 = 85;
+const CHROME_MAJOR_FOR_ES2022 = 94;
+const CHROME_MAJOR_FOR_ES2023 = 110;
+const CHROME_MAJOR_FOR_ES2024 = 122;
+const ECMA_SCRIPT_BREAKPOINTS = [
+  { ecmaScriptVersion: "ES2024", minChromeMajor: CHROME_MAJOR_FOR_ES2024 },
+  { ecmaScriptVersion: "ES2023", minChromeMajor: CHROME_MAJOR_FOR_ES2023 },
+  { ecmaScriptVersion: "ES2022", minChromeMajor: CHROME_MAJOR_FOR_ES2022 },
+  { ecmaScriptVersion: "ES2021", minChromeMajor: CHROME_MAJOR_FOR_ES2021 },
+  { ecmaScriptVersion: "ES2020", minChromeMajor: CHROME_MAJOR_FOR_ES2020 },
+  { ecmaScriptVersion: "ES2019", minChromeMajor: CHROME_MAJOR_FOR_ES2019 },
+  { ecmaScriptVersion: "ES2018", minChromeMajor: CHROME_MAJOR_FOR_ES2018 },
+  { ecmaScriptVersion: "ES2017", minChromeMajor: CHROME_MAJOR_FOR_ES2017 },
+  { ecmaScriptVersion: "ES2016", minChromeMajor: CHROME_MAJOR_FOR_ES2016 },
+  { ecmaScriptVersion: "ES2015", minChromeMajor: CHROME_MAJOR_FOR_ES2015 }
+];
+const DECIMAL_RADIX = 10;
+function deriveEcmaScriptVersion(chromeVersion) {
+  const chromeMajor = Number.parseInt(chromeVersion, DECIMAL_RADIX);
+  if (Number.isNaN(chromeMajor)) {
+    return void 0;
+  }
+  for (const breakpoint of ECMA_SCRIPT_BREAKPOINTS) {
+    if (chromeMajor >= breakpoint.minChromeMajor) {
+      return breakpoint.ecmaScriptVersion;
+    }
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deriveEcmaScriptVersion
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/ecmascript-version.d.cts

@@ -0,0 +1,28 @@
+/**
+ * @file
+ *
+ * Pure derivation of the ECMAScript language level supported by a given
+ * Chromium (V8) version, expressed as an ECMAScript-edition string (e.g. `'ES2022'`).
+ *
+ * A serialized `evalInObsidian` closure runs in Obsidian's Chromium renderer, so
+ * the ES features it may safely use are bounded by that shell's Chromium version.
+ * The empirically-collected `runtimeVersions.chrome` (see
+ * {@link ObsidianRuntimeVersions} and `scripts/collect-runtime-versions.ts`) is
+ * fed through {@link deriveEcmaScriptVersion} to bake a per-version
+ * `ecmaScriptVersion` into `metadata.json`, so a consumer pinning an installer can
+ * tell offline which ES level is safe.
+ *
+ * The Chromium-major → ES-year breakpoints below are the Chromium releases at
+ * which each yearly ECMAScript edition became fully supported, per MDN /
+ * caniuse / the ECMAScript compatibility tables. They are a curated table, not
+ * derived from anything else, so this module is pure and unit-tested to the 100% gate.
+ */
+/**
+ * Derives the highest fully-supported ECMAScript edition for a Chromium version.
+ *
+ * @param chromeVersion - A Chromium version string (e.g. `'114.0.5735.289'`);
+ *   only the leading major segment is significant.
+ * @returns The ECMAScript-edition label (e.g. `'ES2022'`), or `undefined` when the
+ *   version cannot be parsed or its Chromium major predates the earliest tracked edition.
+ */
+export declare function deriveEcmaScriptVersion(chromeVersion: string): string | undefined;