obsidian-integration-testing 8.4.0 → 9.0.0

package/dist/lib/esm/jest/global-setup-no-plugin.d.mts

@@ -0,0 +1,26 @@
+/**
+ * @file
+ *
+ * Jest **plugin-less** global setup entry point.
+ *
+ * The counterpart to `./global-setup.ts` (which installs and enables the built
+ * plugin). This one runs {@link createSetup} with `installPlugin: false`, so it
+ * registers an **empty** temp vault and publishes the owned-instance endpoint to
+ * workers without copying or enabling any plugin. Its default export is the setup
+ * function, as Jest's `globalSetup` loader requires.
+ */
+/**
+ * Jest global setup function (plugin-less).
+ *
+ * Registers an empty temp vault and populates `globalThis.__obsidianIntegrationTesting`
+ * for tests, without copying or enabling any plugin.
+ */
+export declare const setup: (this: void) => Promise<void>;
+/**
+ * Jest global teardown function.
+ *
+ * Removes the temporary vault created during setup.
+ */
+export declare const teardown: (this: void) => Promise<void>;
+export { getTempVault, getTransportOptions } from './global-setup.mjs';
+export default setup;

package/dist/lib/esm/jest/global-setup-no-plugin.mjs

@@ -0,0 +1,17 @@
+import { createSetup } from "./global-setup.mjs";
+const noPluginGlobalSetup = createSetup({ installPlugin: false });
+const setup = noPluginGlobalSetup.setup;
+const teardown = noPluginGlobalSetup.teardown;
+import {
+  getTempVault,
+  getTransportOptions
+} from "./global-setup.mjs";
+var global_setup_no_plugin_default = setup;
+export {
+  global_setup_no_plugin_default as default,
+  getTempVault,
+  getTransportOptions,
+  setup,
+  teardown
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/jest/global-setup.d.mts

@@ -32,6 +32,15 @@ declare global {
  * Options for {@link createSetup}.
  */
 export interface CreateSetupOptions {
+    /**
+     * Whether to install and enable the built plugin in the temp vault. Defaults
+     * to `true`. Set to `false` for a **non-plugin** consumer that only needs a
+     * registered, empty vault to `evalInObsidian` against — the owned instance is
+     * still launched and its endpoint published to workers, so re-exporting
+     * `createSetup({ installPlugin: false })` reuses the same attach wiring with no
+     * plugin copy/enable. See {@link CoreSetupParams.installPlugin}.
+     */
+    readonly installPlugin?: boolean;
     /**
      * Returns files/folders to write into the vault before Obsidian opens it (see
      * {@link CoreSetupParams.populate}). A thunk so large fixtures are built lazily,
@@ -50,7 +59,8 @@ export interface JestGlobalSetup {
  * Creates a Jest global setup/teardown pair, optionally pre-populating the vault
  * before Obsidian opens it — use this for a dedicated large-vault/performance
  * setup. The plain {@link setup} / {@link teardown} exports are the no-populate
- * case (`createSetup()`).
+ * case (`createSetup()`). Pass `{ installPlugin: false }` for a non-plugin consumer
+ * that only needs a registered, empty vault (see {@link CreateSetupOptions.installPlugin}).
  *
  * @param options - Setup options.
  * @returns The `setup` and `teardown` functions to re-export from a `globalSetup` module.

package/dist/lib/esm/jest/global-setup.mjs

@@ -14,7 +14,7 @@ function createSetup(options) {
   return { setup: setup2, teardown: teardown2 };
   async function setup2() {
     const transportOptions = globalThis.__obsidianIntegrationTesting?.transportOptions;
-    setupResult = await coreSetup({ populate: options?.populate?.(), transportOptions });
+    setupResult = await coreSetup({ installPlugin: options?.installPlugin, populate: options?.populate?.(), transportOptions });
     globalThis.__obsidianIntegrationTesting = {
       ...globalThis.__obsidianIntegrationTesting,
       tempVaultPath: setupResult.tempVault.path,
@@ -49,4 +49,4 @@ export {
   setup,
   teardown
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/jest/global-setup.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Jest global setup and teardown adapter.\n *\n * Delegates to the framework-agnostic core and bridges context\n * to test workers via `globalThis.__obsidianIntegrationTesting`.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { CoreSetupResult } from '../global-setup-core.mjs';\nimport type { PopulateFilesParams } from '../temp-vault.mjs';\nimport type { ObsidianTransportOptions } from '../transport-options.mjs';\n\nimport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from '../context-provider.mjs';\nimport {\n  coreSetup,\n  coreTeardown\n} from '../global-setup-core.mjs';\nimport { TempVault } from '../temp-vault.mjs';\n\n/**\n * Shape of `globalThis.__obsidianIntegrationTesting`.\n *\n * Consumers may pre-populate `transportOptions` before the global setup runs\n * (e.g., via Jest config `globals`). The setup then adds `tempVaultPath`.\n */\ninterface ObsidianIntegrationTestingGlobal {\n  /** Temp vault path, set by the global setup for test workers. */\n  tempVaultPath?: string | undefined;\n\n  /** Transport options. Set by the consumer before setup, or by the setup itself. */\n  transportOptions?: ObsidianTransportOptions | undefined;\n}\n\n/* eslint-disable vars-on-top -- Required for `declare global` augmentation. */\ndeclare global {\n  /**\n   * Namespace for all `obsidian-integration-testing` global state.\n   * Consumers configure transport options here; the setup populates the rest.\n   */\n  var __obsidianIntegrationTesting: ObsidianIntegrationTestingGlobal | undefined;\n}\n/* eslint-enable vars-on-top -- End of `declare global` block. */\n\nsetTransportOptionsResolver(() => globalThis.__obsidianIntegrationTesting?.transportOptions);\nsetVaultPathResolver(() => globalThis.__obsidianIntegrationTesting?.tempVaultPath);\n\n/**\n * Options for {@link createSetup}.\n */\nexport interface CreateSetupOptions {\n  /**\n   * Returns files/folders to write into the vault before Obsidian opens it (see\n   * {@link CoreSetupParams.populate}). A thunk so large fixtures are built lazily,\n   * once, in the setup process.\n   */\n  populate?(this: void): PopulateFilesParams;\n}\n\n/**\n * A Jest `globalSetup` / `globalTeardown` module's `setup` / `teardown` pair.\n */\nexport interface JestGlobalSetup {\n  setup(this: void): Promise<void>;\n  teardown(this: void): Promise<void>;\n}\n\n/**\n * Creates a Jest global setup/teardown pair, optionally pre-populating the vault\n * before Obsidian opens it \u2014 use this for a dedicated large-vault/performance\n * setup. The plain {@link setup} / {@link teardown} exports are the no-populate\n * case (`createSetup()`).\n *\n * @param options - Setup options.\n * @returns The `setup` and `teardown` functions to re-export from a `globalSetup` module.\n */\nexport function createSetup(options?: CreateSetupOptions): JestGlobalSetup {\n  let setupResult: CoreSetupResult | undefined;\n\n  return { setup, teardown };\n\n  async function setup(): Promise<void> {\n    const transportOptions = globalThis.__obsidianIntegrationTesting?.transportOptions;\n\n    setupResult = await coreSetup({ populate: options?.populate?.(), transportOptions });\n\n    globalThis.__obsidianIntegrationTesting = {\n      ...globalThis.__obsidianIntegrationTesting,\n      tempVaultPath: setupResult.tempVault.path,\n      transportOptions: setupResult.transportOptions\n    };\n  }\n\n  async function teardown(): Promise<void> {\n    await coreTeardown(setupResult);\n  }\n}\n\n/**\n * Returns the temporary vault provided by the global setup.\n *\n * Reads the vault path from `globalThis.__obsidianIntegrationTesting.tempVaultPath`,\n * which is set by the Jest global setup.\n *\n * @returns The temporary vault.\n */\nexport function getTempVault(): TempVault {\n  const tempVaultPath = globalThis.__obsidianIntegrationTesting?.tempVaultPath;\n  if (!tempVaultPath) {\n    throw new Error(\n      'globalThis.__obsidianIntegrationTesting.tempVaultPath is not set. Did you configure obsidian-integration-testing/jest-global-setup as a Jest globalSetup?'\n    );\n  }\n  return new TempVault(tempVaultPath);\n}\n\n/**\n * Returns the transport options provided by the global setup.\n *\n * @returns The transport options, or `undefined` if not configured.\n */\nexport function getTransportOptions(): ObsidianTransportOptions | undefined {\n  return globalThis.__obsidianIntegrationTesting?.transportOptions;\n}\n\nconst defaultGlobalSetup = createSetup();\n\n/**\n * Jest global setup function (no pre-population).\n *\n * Copies the built plugin into a temporary vault, enables it via the Obsidian CLI,\n * and populates `globalThis.__obsidianIntegrationTesting` for tests.\n *\n * Transport options are read from `globalThis.__obsidianIntegrationTesting.transportOptions`.\n * Set this in your Jest config via the `globals` option.\n *\n * @returns A promise that resolves when setup completes.\n */\nexport const setup = defaultGlobalSetup.setup;\n\n/**\n * Jest global teardown function.\n *\n * Removes the temporary vault created during setup.\n *\n * @returns A promise that resolves when teardown completes.\n */\nexport const teardown = defaultGlobalSetup.teardown;\n\n// Jest's `globalSetup` config can reference this module directly because its default export is the setup function.\n// eslint-disable-next-line import-x/no-default-export -- Jest's globalSetup loader requires a default-export function.\nexport default setup;\n"],
  "mappings": "AAeA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,iBAAiB;AA0B1B,4BAA4B,MAAM,WAAW,8BAA8B,gBAAgB;AAC3F,qBAAqB,MAAM,WAAW,8BAA8B,aAAa;AA+B1E,SAAS,YAAY,SAA+C;AACzE,MAAI;AAEJ,SAAO,EAAE,OAAAA,QAAO,UAAAC,UAAS;AAEzB,iBAAeD,SAAuB;AACpC,UAAM,mBAAmB,WAAW,8BAA8B;AAElE,kBAAc,MAAM,UAAU,EAAE,UAAU,SAAS,WAAW,GAAG,iBAAiB,CAAC;AAEnF,eAAW,+BAA+B;AAAA,MACxC,GAAG,WAAW;AAAA,MACd,eAAe,YAAY,UAAU;AAAA,MACrC,kBAAkB,YAAY;AAAA,IAChC;AAAA,EACF;AAEA,iBAAeC,YAA0B;AACvC,UAAM,aAAa,WAAW;AAAA,EAChC;AACF;AAUO,SAAS,eAA0B;AACxC,QAAM,gBAAgB,WAAW,8BAA8B;AAC/D,MAAI,CAAC,eAAe;AAClB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO,IAAI,UAAU,aAAa;AACpC;AAOO,SAAS,sBAA4D;AAC1E,SAAO,WAAW,8BAA8B;AAClD;AAEA,MAAM,qBAAqB,YAAY;AAahC,MAAM,QAAQ,mBAAmB;AASjC,MAAM,WAAW,mBAAmB;AAI3C,IAAO,uBAAQ;",
  "names": ["setup", "teardown"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/jest/global-setup.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Jest global setup and teardown adapter.\n *\n * Delegates to the framework-agnostic core and bridges context\n * to test workers via `globalThis.__obsidianIntegrationTesting`.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { CoreSetupResult } from '../global-setup-core.mjs';\nimport type { PopulateFilesParams } from '../temp-vault.mjs';\nimport type { ObsidianTransportOptions } from '../transport-options.mjs';\n\nimport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from '../context-provider.mjs';\nimport {\n  coreSetup,\n  coreTeardown\n} from '../global-setup-core.mjs';\nimport { TempVault } from '../temp-vault.mjs';\n\n/**\n * Shape of `globalThis.__obsidianIntegrationTesting`.\n *\n * Consumers may pre-populate `transportOptions` before the global setup runs\n * (e.g., via Jest config `globals`). The setup then adds `tempVaultPath`.\n */\ninterface ObsidianIntegrationTestingGlobal {\n  /** Temp vault path, set by the global setup for test workers. */\n  tempVaultPath?: string | undefined;\n\n  /** Transport options. Set by the consumer before setup, or by the setup itself. */\n  transportOptions?: ObsidianTransportOptions | undefined;\n}\n\n/* eslint-disable vars-on-top -- Required for `declare global` augmentation. */\ndeclare global {\n  /**\n   * Namespace for all `obsidian-integration-testing` global state.\n   * Consumers configure transport options here; the setup populates the rest.\n   */\n  var __obsidianIntegrationTesting: ObsidianIntegrationTestingGlobal | undefined;\n}\n/* eslint-enable vars-on-top -- End of `declare global` block. */\n\nsetTransportOptionsResolver(() => globalThis.__obsidianIntegrationTesting?.transportOptions);\nsetVaultPathResolver(() => globalThis.__obsidianIntegrationTesting?.tempVaultPath);\n\n/**\n * Options for {@link createSetup}.\n */\nexport interface CreateSetupOptions {\n  /**\n   * Whether to install and enable the built plugin in the temp vault. Defaults\n   * to `true`. Set to `false` for a **non-plugin** consumer that only needs a\n   * registered, empty vault to `evalInObsidian` against \u2014 the owned instance is\n   * still launched and its endpoint published to workers, so re-exporting\n   * `createSetup({ installPlugin: false })` reuses the same attach wiring with no\n   * plugin copy/enable. See {@link CoreSetupParams.installPlugin}.\n   */\n  readonly installPlugin?: boolean;\n\n  /**\n   * Returns files/folders to write into the vault before Obsidian opens it (see\n   * {@link CoreSetupParams.populate}). A thunk so large fixtures are built lazily,\n   * once, in the setup process.\n   */\n  populate?(this: void): PopulateFilesParams;\n}\n\n/**\n * A Jest `globalSetup` / `globalTeardown` module's `setup` / `teardown` pair.\n */\nexport interface JestGlobalSetup {\n  setup(this: void): Promise<void>;\n  teardown(this: void): Promise<void>;\n}\n\n/**\n * Creates a Jest global setup/teardown pair, optionally pre-populating the vault\n * before Obsidian opens it \u2014 use this for a dedicated large-vault/performance\n * setup. The plain {@link setup} / {@link teardown} exports are the no-populate\n * case (`createSetup()`). Pass `{ installPlugin: false }` for a non-plugin consumer\n * that only needs a registered, empty vault (see {@link CreateSetupOptions.installPlugin}).\n *\n * @param options - Setup options.\n * @returns The `setup` and `teardown` functions to re-export from a `globalSetup` module.\n */\nexport function createSetup(options?: CreateSetupOptions): JestGlobalSetup {\n  let setupResult: CoreSetupResult | undefined;\n\n  return { setup, teardown };\n\n  async function setup(): Promise<void> {\n    const transportOptions = globalThis.__obsidianIntegrationTesting?.transportOptions;\n\n    setupResult = await coreSetup({ installPlugin: options?.installPlugin, populate: options?.populate?.(), transportOptions });\n\n    globalThis.__obsidianIntegrationTesting = {\n      ...globalThis.__obsidianIntegrationTesting,\n      tempVaultPath: setupResult.tempVault.path,\n      transportOptions: setupResult.transportOptions\n    };\n  }\n\n  async function teardown(): Promise<void> {\n    await coreTeardown(setupResult);\n  }\n}\n\n/**\n * Returns the temporary vault provided by the global setup.\n *\n * Reads the vault path from `globalThis.__obsidianIntegrationTesting.tempVaultPath`,\n * which is set by the Jest global setup.\n *\n * @returns The temporary vault.\n */\nexport function getTempVault(): TempVault {\n  const tempVaultPath = globalThis.__obsidianIntegrationTesting?.tempVaultPath;\n  if (!tempVaultPath) {\n    throw new Error(\n      'globalThis.__obsidianIntegrationTesting.tempVaultPath is not set. Did you configure obsidian-integration-testing/jest-global-setup as a Jest globalSetup?'\n    );\n  }\n  return new TempVault(tempVaultPath);\n}\n\n/**\n * Returns the transport options provided by the global setup.\n *\n * @returns The transport options, or `undefined` if not configured.\n */\nexport function getTransportOptions(): ObsidianTransportOptions | undefined {\n  return globalThis.__obsidianIntegrationTesting?.transportOptions;\n}\n\nconst defaultGlobalSetup = createSetup();\n\n/**\n * Jest global setup function (no pre-population).\n *\n * Copies the built plugin into a temporary vault, enables it via the Obsidian CLI,\n * and populates `globalThis.__obsidianIntegrationTesting` for tests.\n *\n * Transport options are read from `globalThis.__obsidianIntegrationTesting.transportOptions`.\n * Set this in your Jest config via the `globals` option.\n *\n * @returns A promise that resolves when setup completes.\n */\nexport const setup = defaultGlobalSetup.setup;\n\n/**\n * Jest global teardown function.\n *\n * Removes the temporary vault created during setup.\n *\n * @returns A promise that resolves when teardown completes.\n */\nexport const teardown = defaultGlobalSetup.teardown;\n\n// Jest's `globalSetup` config can reference this module directly because its default export is the setup function.\n// eslint-disable-next-line import-x/no-default-export -- Jest's globalSetup loader requires a default-export function.\nexport default setup;\n"],
  "mappings": "AAeA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,iBAAiB;AA0B1B,4BAA4B,MAAM,WAAW,8BAA8B,gBAAgB;AAC3F,qBAAqB,MAAM,WAAW,8BAA8B,aAAa;AA0C1E,SAAS,YAAY,SAA+C;AACzE,MAAI;AAEJ,SAAO,EAAE,OAAAA,QAAO,UAAAC,UAAS;AAEzB,iBAAeD,SAAuB;AACpC,UAAM,mBAAmB,WAAW,8BAA8B;AAElE,kBAAc,MAAM,UAAU,EAAE,eAAe,SAAS,eAAe,UAAU,SAAS,WAAW,GAAG,iBAAiB,CAAC;AAE1H,eAAW,+BAA+B;AAAA,MACxC,GAAG,WAAW;AAAA,MACd,eAAe,YAAY,UAAU;AAAA,MACrC,kBAAkB,YAAY;AAAA,IAChC;AAAA,EACF;AAEA,iBAAeC,YAA0B;AACvC,UAAM,aAAa,WAAW;AAAA,EAChC;AACF;AAUO,SAAS,eAA0B;AACxC,QAAM,gBAAgB,WAAW,8BAA8B;AAC/D,MAAI,CAAC,eAAe;AAClB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO,IAAI,UAAU,aAAa;AACpC;AAOO,SAAS,sBAA4D;AAC1E,SAAO,WAAW,8BAA8B;AAClD;AAEA,MAAM,qBAAqB,YAAY;AAahC,MAAM,QAAQ,mBAAmB;AASjC,MAAM,WAAW,mBAAmB;AAI3C,IAAO,uBAAQ;",
  "names": ["setup", "teardown"]
}


package/dist/lib/esm/jest/global-teardown-no-plugin.d.mts

@@ -0,0 +1,11 @@
+/**
+ * @file
+ *
+ * Jest **plugin-less** global teardown entry point.
+ *
+ * Jest requires `globalTeardown` to be a separate module whose default export is
+ * the teardown function. It re-exports the teardown from the plugin-less setup
+ * module so both share the same setup state within the Jest parent process.
+ */
+import { teardown } from './global-setup-no-plugin.mjs';
+export default teardown;

package/dist/lib/esm/jest/global-teardown-no-plugin.mjs

@@ -0,0 +1,6 @@
+import { teardown } from "./global-setup-no-plugin.mjs";
+var global_teardown_no_plugin_default = teardown;
+export {
+  global_teardown_no_plugin_default as default
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2plc3QvZ2xvYmFsLXRlYXJkb3duLW5vLXBsdWdpbi50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEplc3QgKipwbHVnaW4tbGVzcyoqIGdsb2JhbCB0ZWFyZG93biBlbnRyeSBwb2ludC5cbiAqXG4gKiBKZXN0IHJlcXVpcmVzIGBnbG9iYWxUZWFyZG93bmAgdG8gYmUgYSBzZXBhcmF0ZSBtb2R1bGUgd2hvc2UgZGVmYXVsdCBleHBvcnQgaXNcbiAqIHRoZSB0ZWFyZG93biBmdW5jdGlvbi4gSXQgcmUtZXhwb3J0cyB0aGUgdGVhcmRvd24gZnJvbSB0aGUgcGx1Z2luLWxlc3Mgc2V0dXBcbiAqIG1vZHVsZSBzbyBib3RoIHNoYXJlIHRoZSBzYW1lIHNldHVwIHN0YXRlIHdpdGhpbiB0aGUgSmVzdCBwYXJlbnQgcHJvY2Vzcy5cbiAqL1xuXG4vKiB2OCBpZ25vcmUgc3RhcnQgLS0gSW50ZWdyYXRpb24tdGltZSB0ZWFyZG93biBjb3ZlcmVkIGJ5IGludGVncmF0aW9uIHRlc3RzLCBub3QgdW5pdCB0ZXN0cy4gKi9cblxuaW1wb3J0IHsgdGVhcmRvd24gfSBmcm9tICcuL2dsb2JhbC1zZXR1cC1uby1wbHVnaW4ubWpzJztcblxuLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIGltcG9ydC14L25vLWRlZmF1bHQtZXhwb3J0IC0tIEplc3QncyBnbG9iYWxUZWFyZG93biBsb2FkZXIgcmVxdWlyZXMgYSBkZWZhdWx0LWV4cG9ydCBmdW5jdGlvbi5cbmV4cG9ydCBkZWZhdWx0IHRlYXJkb3duO1xuXG4vKiB2OCBpZ25vcmUgc3RvcCAqL1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBWUEsU0FBUyxnQkFBZ0I7QUFHekIsSUFBTyxvQ0FBUTsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/library.mjs

@@ -1,4 +1,4 @@
-const LIBRARY_VERSION = false ? "dev" : "8.3.0";
+const LIBRARY_VERSION = false ? "dev" : "8.4.0";
 export {
   LIBRARY_VERSION
 };

package/dist/lib/esm/process-exit-message.d.mts

@@ -0,0 +1,48 @@
+/**
+ * @file
+ *
+ * Pure builder for the diagnostic message describing an auto-started child
+ * process (the Android emulator or the Appium server) that died during startup,
+ * appending the captured output tail when available.
+ *
+ * Kept separate from the integration-only `transport-factory` (excluded from
+ * unit tests) so the message formatting stays unit-testable — the launchers
+ * themselves spawn real processes.
+ */
+/**
+ * Parameters for {@link buildProcessExitMessage}.
+ */
+export interface BuildProcessExitMessageParams {
+    /** The process's exit / spawn-failure details. */
+    readonly exitInfo: ProcessExitInfo;
+    /** The captured stdout+stderr tail (empty when none was captured). */
+    readonly output: string;
+    /** Label for the captured output section (e.g. `"Emulator output"`). */
+    readonly outputLabel: string;
+    /** Human-readable subject of the process (e.g. `"Android emulator"`). */
+    readonly subject: string;
+}
+/**
+ * Details of a spawned child process that has exited or failed to spawn.
+ *
+ * A normal exit sets `code`/`signal` (exactly one is non-`null`); a spawn
+ * failure (e.g. `ENOENT` for a missing binary) leaves both `null` and sets
+ * `spawnError` to the failure message.
+ */
+export interface ProcessExitInfo {
+    /** Exit code, or `null` when terminated by a signal or when it failed to spawn. */
+    readonly code: null | number;
+    /** Terminating signal, or `null` when it exited normally or failed to spawn. */
+    readonly signal: NodeJS.Signals | null;
+    /** The spawn-failure message when the process never started (e.g. `ENOENT`), otherwise absent. */
+    readonly spawnError?: string;
+}
+/**
+ * Builds a descriptive error message for an auto-started child process that
+ * exited (or failed to spawn) during startup, appending the captured output
+ * tail when available.
+ *
+ * @param params - The subject, exit details, and captured output.
+ * @returns A human-readable error message.
+ */
+export declare function buildProcessExitMessage(params: BuildProcessExitMessageParams): string;

package/dist/lib/esm/process-exit-message.mjs

@@ -0,0 +1,23 @@
+function buildProcessExitMessage(params) {
+  const { exitInfo, output, outputLabel, subject } = params;
+  const reason = resolveReason(exitInfo);
+  const trimmedOutput = output.trim();
+  const details = trimmedOutput.length > 0 ? `
+
+${outputLabel} (tail):
+${trimmedOutput}` : "";
+  return `${subject} ${reason} during startup.${details}`;
+}
+function resolveReason(exitInfo) {
+  if (exitInfo.spawnError !== void 0) {
+    return `failed to start (${exitInfo.spawnError})`;
+  }
+  if (exitInfo.signal !== null) {
+    return `was terminated by signal ${exitInfo.signal}`;
+  }
+  return `exited prematurely with code ${exitInfo.code === null ? "(null)" : String(exitInfo.code)}`;
+}
+export {
+  buildProcessExitMessage
+};
+//# sourceMappingURL=data:application/json;base64,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