@agimon-ai/doompi-core 0.0.1-alpha.70

package/dist/schemas/readiness.mjs

@@ -0,0 +1,246 @@
+//#region src/schemas/readiness.ts
+/** Cordis service name for session-scoped package initialization. */
+const DOOM_READINESS_SERVICE = "doom/readiness";
+/** Stable machine-readable failures produced by the readiness contract. */
+const DOOM_READINESS_ERROR_CODE = {
+	cancelled: "DOOM_READINESS_CANCELLED",
+	disposed: "DOOM_READINESS_DISPOSED",
+	duplicate: "DOOM_READINESS_DUPLICATE",
+	failed: "DOOM_READINESS_FAILED",
+	invalidArgument: "DOOM_READINESS_INVALID_ARGUMENT",
+	unavailable: "DOOM_READINESS_UNAVAILABLE",
+	waitAborted: "DOOM_READINESS_WAIT_ABORTED"
+};
+/** Error returned to package callers without exposing task-specific rejection shapes. */
+var DoomReadinessError = class extends Error {
+	code;
+	packageId;
+	generation;
+	constructor(code, message, input = {}) {
+		super(message, input.cause === void 0 ? void 0 : { cause: input.cause });
+		this.name = "DoomReadinessError";
+		this.code = code;
+		this.packageId = input.packageId;
+		this.generation = input.generation;
+	}
+};
+function createTerminal() {
+	let resolve = () => void 0;
+	return {
+		promise: new Promise((settle) => {
+			resolve = settle;
+		}),
+		resolve
+	};
+}
+function frozenDiagnostics(diagnostics) {
+	if (diagnostics === void 0) return Object.freeze([]);
+	if (!Array.isArray(diagnostics) || diagnostics.some((diagnostic) => typeof diagnostic !== "string")) throw new TypeError("Doom readiness task diagnostics must be an array of strings.");
+	return Object.freeze([...diagnostics]);
+}
+function errorDetail(error) {
+	return error === void 0 ? void 0 : Object.freeze({
+		code: error.code,
+		message: error.message
+	});
+}
+function recordSnapshot(record) {
+	return Object.freeze({
+		packageId: record.packageId,
+		generation: record.generation,
+		state: record.state,
+		diagnostics: record.diagnostics,
+		...record.error === void 0 ? {} : { error: errorDetail(record.error) }
+	});
+}
+function rethrowAsync(error) {
+	queueMicrotask(() => {
+		throw error instanceof Error ? error : new Error(String(error));
+	});
+}
+function waitAbortedError(record, signal) {
+	return new DoomReadinessError(DOOM_READINESS_ERROR_CODE.waitAborted, `Waiting for Doom package '${record.packageId}' readiness was aborted.`, {
+		packageId: record.packageId,
+		generation: record.generation,
+		cause: signal.reason
+	});
+}
+function waitForTerminal(record, signal) {
+	if (signal === void 0) return record.terminal;
+	if (signal.aborted) return Promise.reject(waitAbortedError(record, signal));
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			reject(waitAbortedError(record, signal));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		record.terminal.then(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		});
+	});
+}
+/** Creates the session-scoped coordinator value published through Cordis. */
+function createDoomReadinessCoordinator(options = {}) {
+	const records = /* @__PURE__ */ new Map();
+	let disposed = false;
+	let disposal;
+	const current = (record) => !disposed && records.get(record.packageId)?.token === record.token && record.state === "pending";
+	const notify = (record) => {
+		if (record.notified || record.state !== "degraded" && record.state !== "failed") return;
+		record.notified = true;
+		const notification = Object.freeze({
+			packageId: record.packageId,
+			generation: record.generation,
+			state: record.state,
+			diagnostics: record.diagnostics,
+			...record.error === void 0 ? {} : { error: errorDetail(record.error) }
+		});
+		if (options.notify) Promise.resolve(options.notify(notification)).catch(rethrowAsync);
+	};
+	const finish = (record, state, input = {}) => {
+		if (!current(record)) return;
+		record.state = state;
+		record.value = input.value;
+		record.hasValue = input.hasValue ?? false;
+		record.diagnostics = input.diagnostics ?? Object.freeze([]);
+		record.error = input.error;
+		record.resolveTerminal();
+		notify(record);
+	};
+	const handleFor = (record) => Object.freeze({
+		packageId: record.packageId,
+		generation: record.generation,
+		snapshot: () => recordSnapshot(record),
+		wait: async (waitOptions = {}) => {
+			await waitForTerminal(record, waitOptions.signal);
+			if (record.state === "ready" || record.state === "degraded") {
+				if (!record.hasValue) throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.failed, `Doom package '${record.packageId}' readiness completed without a value.`, {
+					packageId: record.packageId,
+					generation: record.generation
+				});
+				return record.value;
+			}
+			if (record.error) throw record.error;
+			throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.failed, `Doom package '${record.packageId}' readiness did not complete.`, {
+				packageId: record.packageId,
+				generation: record.generation
+			});
+		}
+	});
+	return Object.freeze({
+		start(packageId, generation, task) {
+			if (disposed) throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.disposed, "The Doom readiness coordinator has been disposed.", {
+				packageId,
+				generation
+			});
+			if (typeof packageId !== "string" || packageId.trim().length === 0) throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.invalidArgument, "Doom readiness requires a non-empty package id.", {
+				packageId,
+				generation
+			});
+			if (typeof generation !== "string" || generation.trim().length === 0) throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.invalidArgument, "Doom readiness requires a non-empty generation.", {
+				packageId,
+				generation
+			});
+			if (typeof task !== "function") throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.invalidArgument, "Doom readiness requires an initialization task.", {
+				packageId,
+				generation
+			});
+			if (records.get(packageId)?.state === "pending") throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.duplicate, `Doom package '${packageId}' already has live readiness work.`, {
+				packageId,
+				generation
+			});
+			const terminal = createTerminal();
+			const controller = new AbortController();
+			const record = {
+				token: Symbol(packageId),
+				packageId,
+				generation,
+				controller,
+				terminal: terminal.promise,
+				resolveTerminal: terminal.resolve,
+				operation: Promise.resolve(),
+				state: "pending",
+				diagnostics: Object.freeze([]),
+				hasValue: false,
+				notified: false
+			};
+			records.set(packageId, record);
+			const operation = Promise.resolve().then(() => {
+				if (controller.signal.aborted) throw controller.signal.reason;
+				return task(controller.signal);
+			});
+			record.operation = operation;
+			operation.then((result) => {
+				if (!current(record)) return;
+				if (result === null || typeof result !== "object" || !Object.hasOwn(result, "value")) {
+					finish(record, "failed", { error: new DoomReadinessError(DOOM_READINESS_ERROR_CODE.failed, `Doom package '${packageId}' returned an invalid readiness result.`, {
+						packageId,
+						generation
+					}) });
+					return;
+				}
+				try {
+					const diagnostics = frozenDiagnostics(result.diagnostics);
+					finish(record, diagnostics.length === 0 ? "ready" : "degraded", {
+						value: result.value,
+						hasValue: true,
+						diagnostics
+					});
+				} catch (error) {
+					finish(record, "failed", { error: new DoomReadinessError(DOOM_READINESS_ERROR_CODE.failed, `Doom package '${packageId}' returned an invalid readiness result.`, {
+						packageId,
+						generation,
+						cause: error
+					}) });
+				}
+			}, (error) => {
+				finish(record, "failed", { error: new DoomReadinessError(DOOM_READINESS_ERROR_CODE.failed, `Doom package '${packageId}' readiness failed: ${error instanceof Error ? error.message : String(error)}`, {
+					packageId,
+					generation,
+					cause: error
+				}) });
+			}).catch(rethrowAsync);
+			return handleFor(record);
+		},
+		read(packageId) {
+			const record = records.get(packageId);
+			return record === void 0 ? void 0 : recordSnapshot(record);
+		},
+		snapshots() {
+			return Object.freeze([...records.values()].map(recordSnapshot));
+		},
+		dispose() {
+			if (disposal) return disposal;
+			disposed = true;
+			const operations = [...records.values()].map((record) => {
+				if (record.state === "pending") {
+					const error = new DoomReadinessError(DOOM_READINESS_ERROR_CODE.cancelled, `Doom package '${record.packageId}' readiness was cancelled.`, {
+						packageId: record.packageId,
+						generation: record.generation
+					});
+					record.state = "cancelled";
+					record.error = error;
+					record.resolveTerminal();
+					record.controller.abort(error);
+				}
+				return record.operation;
+			});
+			disposal = Promise.allSettled(operations).then(() => void 0);
+			return disposal;
+		}
+	});
+}
+/** Reads the coordinator visible to the current Cordis plugin context. */
+function readDoomReadinessCoordinator(ctx) {
+	return ctx.get(DOOM_READINESS_SERVICE);
+}
+/** Reads the coordinator or reports that Config has not published session readiness. */
+function requireDoomReadinessCoordinator(ctx) {
+	const coordinator = readDoomReadinessCoordinator(ctx);
+	if (coordinator) return coordinator;
+	throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.unavailable, "Doom readiness is unavailable. Load the DoomPi Config core.");
+}
+//#endregion
+export { DOOM_READINESS_ERROR_CODE, DOOM_READINESS_SERVICE, DoomReadinessError, createDoomReadinessCoordinator, readDoomReadinessCoordinator, requireDoomReadinessCoordinator };
+
+//# sourceMappingURL=readiness.mjs.map

package/dist/schemas/readiness.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.mjs","names":[],"sources":["../../src/schemas/readiness.ts"],"sourcesContent":["import type { Context } from '@deepseek-ai/cordis';\n\n/** Cordis service name for session-scoped package initialization. */\nexport const DOOM_READINESS_SERVICE = 'doom/readiness';\n\n/** Stable machine-readable failures produced by the readiness contract. */\nexport const DOOM_READINESS_ERROR_CODE = {\n  cancelled: 'DOOM_READINESS_CANCELLED',\n  disposed: 'DOOM_READINESS_DISPOSED',\n  duplicate: 'DOOM_READINESS_DUPLICATE',\n  failed: 'DOOM_READINESS_FAILED',\n  invalidArgument: 'DOOM_READINESS_INVALID_ARGUMENT',\n  unavailable: 'DOOM_READINESS_UNAVAILABLE',\n  waitAborted: 'DOOM_READINESS_WAIT_ABORTED',\n} as const;\n\nexport type DoomReadinessErrorCode = (typeof DOOM_READINESS_ERROR_CODE)[keyof typeof DOOM_READINESS_ERROR_CODE];\nexport type DoomReadinessState = 'pending' | 'ready' | 'degraded' | 'failed' | 'cancelled';\n\nexport interface DoomReadinessErrorDetail {\n  readonly code: DoomReadinessErrorCode;\n  readonly message: string;\n}\n\n/** Immutable public state for the latest generation of one package. */\nexport interface DoomReadinessSnapshot {\n  readonly packageId: string;\n  readonly generation: string;\n  readonly state: DoomReadinessState;\n  readonly diagnostics: readonly string[];\n  readonly error?: DoomReadinessErrorDetail;\n}\n\nexport interface DoomReadinessTaskResult<TValue> {\n  readonly value: TValue;\n  readonly diagnostics?: readonly string[];\n}\n\nexport type DoomReadinessTask<TValue> = (signal: AbortSignal) => Promise<DoomReadinessTaskResult<TValue>>;\n\nexport interface DoomReadinessWaitOptions {\n  readonly signal?: AbortSignal;\n}\n\nexport interface DoomReadinessHandle<TValue> {\n  readonly packageId: string;\n  readonly generation: string;\n  /** Waits for this package only. Degraded initialization still returns its value. */\n  wait(options?: DoomReadinessWaitOptions): Promise<TValue>;\n  /** Reads this handle's generation, even after a newer generation replaces it. */\n  snapshot(): DoomReadinessSnapshot;\n}\n\nexport interface DoomReadinessNotification {\n  readonly packageId: string;\n  readonly generation: string;\n  readonly state: 'degraded' | 'failed';\n  readonly diagnostics: readonly string[];\n  readonly error?: DoomReadinessErrorDetail;\n}\n\nexport interface DoomReadinessCoordinatorOptions {\n  /** Called once when a task becomes degraded or failed. */\n  readonly notify?: (notification: DoomReadinessNotification) => void | Promise<void>;\n}\n\nexport interface DoomReadinessCoordinator {\n  start<TValue>(packageId: string, generation: string, task: DoomReadinessTask<TValue>): DoomReadinessHandle<TValue>;\n  /** Reads the latest generation registered for a package. */\n  read(packageId: string): DoomReadinessSnapshot | undefined;\n  /** Reads the latest generation of every registered package. */\n  snapshots(): readonly DoomReadinessSnapshot[];\n  /** Aborts pending work and waits for every started task to settle. */\n  dispose(): Promise<void>;\n}\n\ninterface ReadinessRecord {\n  readonly token: symbol;\n  readonly packageId: string;\n  readonly generation: string;\n  readonly controller: AbortController;\n  readonly terminal: Promise<void>;\n  readonly resolveTerminal: () => void;\n  operation: Promise<unknown>;\n  state: DoomReadinessState;\n  diagnostics: readonly string[];\n  error?: DoomReadinessError;\n  value?: unknown;\n  hasValue: boolean;\n  notified: boolean;\n}\n\nexport interface DoomReadinessErrorOptions {\n  readonly packageId?: string;\n  readonly generation?: string;\n  readonly cause?: unknown;\n}\n\n/** Error returned to package callers without exposing task-specific rejection shapes. */\nexport class DoomReadinessError extends Error {\n  readonly code: DoomReadinessErrorCode;\n  readonly packageId?: string;\n  readonly generation?: string;\n\n  constructor(code: DoomReadinessErrorCode, message: string, input: DoomReadinessErrorOptions = {}) {\n    super(message, input.cause === undefined ? undefined : { cause: input.cause });\n    this.name = 'DoomReadinessError';\n    this.code = code;\n    this.packageId = input.packageId;\n    this.generation = input.generation;\n  }\n}\n\nfunction createTerminal(): { readonly promise: Promise<void>; readonly resolve: () => void } {\n  let resolve = (): void => undefined;\n  const promise = new Promise<void>((settle) => {\n    resolve = settle;\n  });\n  return { promise, resolve };\n}\n\nfunction frozenDiagnostics(diagnostics: readonly string[] | undefined): readonly string[] {\n  if (diagnostics === undefined) return Object.freeze([]);\n  if (!Array.isArray(diagnostics) || diagnostics.some((diagnostic) => typeof diagnostic !== 'string')) {\n    throw new TypeError('Doom readiness task diagnostics must be an array of strings.');\n  }\n  return Object.freeze([...diagnostics]);\n}\n\nfunction errorDetail(error: DoomReadinessError | undefined): DoomReadinessErrorDetail | undefined {\n  return error === undefined ? undefined : Object.freeze({ code: error.code, message: error.message });\n}\n\nfunction recordSnapshot(record: ReadinessRecord): DoomReadinessSnapshot {\n  return Object.freeze({\n    packageId: record.packageId,\n    generation: record.generation,\n    state: record.state,\n    diagnostics: record.diagnostics,\n    ...(record.error === undefined ? {} : { error: errorDetail(record.error) }),\n  });\n}\n\nfunction rethrowAsync(error: unknown): void {\n  queueMicrotask(() => {\n    throw error instanceof Error ? error : new Error(String(error));\n  });\n}\n\nfunction waitAbortedError(record: ReadinessRecord, signal: AbortSignal): DoomReadinessError {\n  return new DoomReadinessError(\n    DOOM_READINESS_ERROR_CODE.waitAborted,\n    `Waiting for Doom package '${record.packageId}' readiness was aborted.`,\n    { packageId: record.packageId, generation: record.generation, cause: signal.reason },\n  );\n}\n\nfunction waitForTerminal(record: ReadinessRecord, signal: AbortSignal | undefined): Promise<void> {\n  if (signal === undefined) return record.terminal;\n  if (signal.aborted) return Promise.reject(waitAbortedError(record, signal));\n\n  return new Promise<void>((resolve, reject) => {\n    const onAbort = (): void => {\n      reject(waitAbortedError(record, signal));\n    };\n    signal.addEventListener('abort', onAbort, { once: true });\n    void record.terminal.then(() => {\n      signal.removeEventListener('abort', onAbort);\n      resolve();\n    });\n  });\n}\n\n/** Creates the session-scoped coordinator value published through Cordis. */\nexport function createDoomReadinessCoordinator(\n  options: DoomReadinessCoordinatorOptions = {},\n): DoomReadinessCoordinator {\n  const records = new Map<string, ReadinessRecord>();\n  let disposed = false;\n  let disposal: Promise<void> | undefined;\n\n  const current = (record: ReadinessRecord): boolean =>\n    !disposed && records.get(record.packageId)?.token === record.token && record.state === 'pending';\n\n  const notify = (record: ReadinessRecord): void => {\n    if (record.notified || (record.state !== 'degraded' && record.state !== 'failed')) return;\n    record.notified = true;\n    const notification = Object.freeze({\n      packageId: record.packageId,\n      generation: record.generation,\n      state: record.state,\n      diagnostics: record.diagnostics,\n      ...(record.error === undefined ? {} : { error: errorDetail(record.error) }),\n    });\n    if (options.notify) void Promise.resolve(options.notify(notification)).catch(rethrowAsync);\n  };\n\n  const finish = (\n    record: ReadinessRecord,\n    state: Exclude<DoomReadinessState, 'pending'>,\n    input: {\n      readonly value?: unknown;\n      readonly hasValue?: boolean;\n      readonly diagnostics?: readonly string[];\n      readonly error?: DoomReadinessError;\n    } = {},\n  ): void => {\n    if (!current(record)) return;\n    record.state = state;\n    record.value = input.value;\n    record.hasValue = input.hasValue ?? false;\n    record.diagnostics = input.diagnostics ?? Object.freeze([]);\n    record.error = input.error;\n    record.resolveTerminal();\n    notify(record);\n  };\n\n  const handleFor = <TValue>(record: ReadinessRecord): DoomReadinessHandle<TValue> =>\n    Object.freeze({\n      packageId: record.packageId,\n      generation: record.generation,\n      snapshot: () => recordSnapshot(record),\n      wait: async (waitOptions: DoomReadinessWaitOptions = {}): Promise<TValue> => {\n        await waitForTerminal(record, waitOptions.signal);\n        if (record.state === 'ready' || record.state === 'degraded') {\n          if (!record.hasValue) {\n            throw new DoomReadinessError(\n              DOOM_READINESS_ERROR_CODE.failed,\n              `Doom package '${record.packageId}' readiness completed without a value.`,\n              { packageId: record.packageId, generation: record.generation },\n            );\n          }\n          return record.value as TValue;\n        }\n        if (record.error) throw record.error;\n        throw new DoomReadinessError(\n          DOOM_READINESS_ERROR_CODE.failed,\n          `Doom package '${record.packageId}' readiness did not complete.`,\n          { packageId: record.packageId, generation: record.generation },\n        );\n      },\n    });\n\n  return Object.freeze({\n    start<TValue>(packageId: string, generation: string, task: DoomReadinessTask<TValue>): DoomReadinessHandle<TValue> {\n      if (disposed) {\n        throw new DoomReadinessError(\n          DOOM_READINESS_ERROR_CODE.disposed,\n          'The Doom readiness coordinator has been disposed.',\n          { packageId, generation },\n        );\n      }\n      if (typeof packageId !== 'string' || packageId.trim().length === 0) {\n        throw new DoomReadinessError(\n          DOOM_READINESS_ERROR_CODE.invalidArgument,\n          'Doom readiness requires a non-empty package id.',\n          { packageId, generation },\n        );\n      }\n      if (typeof generation !== 'string' || generation.trim().length === 0) {\n        throw new DoomReadinessError(\n          DOOM_READINESS_ERROR_CODE.invalidArgument,\n          'Doom readiness requires a non-empty generation.',\n          { packageId, generation },\n        );\n      }\n      if (typeof task !== 'function') {\n        throw new DoomReadinessError(\n          DOOM_READINESS_ERROR_CODE.invalidArgument,\n          'Doom readiness requires an initialization task.',\n          { packageId, generation },\n        );\n      }\n\n      const previous = records.get(packageId);\n      if (previous?.state === 'pending') {\n        throw new DoomReadinessError(\n          DOOM_READINESS_ERROR_CODE.duplicate,\n          `Doom package '${packageId}' already has live readiness work.`,\n          { packageId, generation },\n        );\n      }\n\n      const terminal = createTerminal();\n      const controller = new AbortController();\n      const record: ReadinessRecord = {\n        token: Symbol(packageId),\n        packageId,\n        generation,\n        controller,\n        terminal: terminal.promise,\n        resolveTerminal: terminal.resolve,\n        operation: Promise.resolve(),\n        state: 'pending',\n        diagnostics: Object.freeze([]),\n        hasValue: false,\n        notified: false,\n      };\n      records.set(packageId, record);\n\n      const operation = Promise.resolve().then(() => {\n        if (controller.signal.aborted) throw controller.signal.reason;\n        return task(controller.signal);\n      });\n      record.operation = operation;\n      void operation\n        .then(\n          (result) => {\n            if (!current(record)) return;\n            if (result === null || typeof result !== 'object' || !Object.hasOwn(result, 'value')) {\n              finish(record, 'failed', {\n                error: new DoomReadinessError(\n                  DOOM_READINESS_ERROR_CODE.failed,\n                  `Doom package '${packageId}' returned an invalid readiness result.`,\n                  { packageId, generation },\n                ),\n              });\n              return;\n            }\n            try {\n              const diagnostics = frozenDiagnostics(result.diagnostics);\n              finish(record, diagnostics.length === 0 ? 'ready' : 'degraded', {\n                value: result.value,\n                hasValue: true,\n                diagnostics,\n              });\n            } catch (error) {\n              finish(record, 'failed', {\n                error: new DoomReadinessError(\n                  DOOM_READINESS_ERROR_CODE.failed,\n                  `Doom package '${packageId}' returned an invalid readiness result.`,\n                  { packageId, generation, cause: error },\n                ),\n              });\n            }\n          },\n          (error: unknown) => {\n            finish(record, 'failed', {\n              error: new DoomReadinessError(\n                DOOM_READINESS_ERROR_CODE.failed,\n                `Doom package '${packageId}' readiness failed: ${error instanceof Error ? error.message : String(error)}`,\n                { packageId, generation, cause: error },\n              ),\n            });\n          },\n        )\n        .catch(rethrowAsync);\n\n      return handleFor<TValue>(record);\n    },\n\n    read(packageId: string): DoomReadinessSnapshot | undefined {\n      const record = records.get(packageId);\n      return record === undefined ? undefined : recordSnapshot(record);\n    },\n\n    snapshots(): readonly DoomReadinessSnapshot[] {\n      return Object.freeze([...records.values()].map(recordSnapshot));\n    },\n\n    dispose(): Promise<void> {\n      if (disposal) return disposal;\n      disposed = true;\n      const operations = [...records.values()].map((record) => {\n        if (record.state === 'pending') {\n          const error = new DoomReadinessError(\n            DOOM_READINESS_ERROR_CODE.cancelled,\n            `Doom package '${record.packageId}' readiness was cancelled.`,\n            { packageId: record.packageId, generation: record.generation },\n          );\n          record.state = 'cancelled';\n          record.error = error;\n          record.resolveTerminal();\n          record.controller.abort(error);\n        }\n        return record.operation;\n      });\n      disposal = Promise.allSettled(operations).then(() => undefined);\n      return disposal;\n    },\n  });\n}\n\n/** Reads the coordinator visible to the current Cordis plugin context. */\nexport function readDoomReadinessCoordinator(ctx: Context): DoomReadinessCoordinator | undefined {\n  return ctx.get(DOOM_READINESS_SERVICE) as DoomReadinessCoordinator | undefined;\n}\n\n/** Reads the coordinator or reports that Config has not published session readiness. */\nexport function requireDoomReadinessCoordinator(ctx: Context): DoomReadinessCoordinator {\n  const coordinator = readDoomReadinessCoordinator(ctx);\n  if (coordinator) return coordinator;\n  throw new DoomReadinessError(\n    DOOM_READINESS_ERROR_CODE.unavailable,\n    'Doom readiness is unavailable. Load the DoomPi Config core.',\n  );\n}\n"],"mappings":"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"}

package/dist/schemas/relaunchHandoff.cjs

@@ -0,0 +1,47 @@
+let typebox = require("typebox");
+let typebox_value = require("typebox/value");
+//#region src/schemas/relaunchHandoff.ts
+/**
+* The relaunch handoff between a DoomPi runtime and its process supervisor.
+*
+* A launcher-class session cannot recompose its extension closure in place, so
+* a relaunch-class transition normally stays pending until a human reruns the
+* launcher with the new selection. A supervisor that owns the agent process
+* (doompi-server) opts into performing that relaunch itself: it points this
+* environment variable at a file path, the runtime writes the target selection
+* there and exits, and the supervisor respawns the agent with the recorded
+* major mode under the same session id.
+*/
+const DOOM_RELAUNCH_FILE_ENV = "DOOMPI_RELAUNCH_FILE";
+const MAX_IDENTIFIER_LENGTH = 256;
+const RelaunchHandoffSchema = typebox.Type.Object({
+	version: typebox.Type.Literal(1),
+	majorMode: typebox.Type.String({
+		minLength: 1,
+		maxLength: MAX_IDENTIFIER_LENGTH
+	}),
+	operationId: typebox.Type.String({
+		minLength: 1,
+		maxLength: MAX_IDENTIFIER_LENGTH
+	})
+}, { additionalProperties: false });
+function serializeRelaunchHandoff(handoff) {
+	return JSON.stringify(handoff);
+}
+/** The handoff a supervisor read back, or undefined for anything malformed. */
+function parseRelaunchHandoff(text) {
+	let candidate;
+	try {
+		candidate = JSON.parse(text);
+	} catch {
+		return;
+	}
+	return (0, typebox_value.Check)(RelaunchHandoffSchema, candidate) ? candidate : void 0;
+}
+//#endregion
+exports.DOOM_RELAUNCH_FILE_ENV = DOOM_RELAUNCH_FILE_ENV;
+exports.RelaunchHandoffSchema = RelaunchHandoffSchema;
+exports.parseRelaunchHandoff = parseRelaunchHandoff;
+exports.serializeRelaunchHandoff = serializeRelaunchHandoff;
+
+//# sourceMappingURL=relaunchHandoff.cjs.map

package/dist/schemas/relaunchHandoff.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"relaunchHandoff.cjs","names":["Type","Check"],"sources":["../../src/schemas/relaunchHandoff.ts"],"sourcesContent":["import { type Static, Type } from 'typebox';\nimport { Check } from 'typebox/value';\n\n/**\n * The relaunch handoff between a DoomPi runtime and its process supervisor.\n *\n * A launcher-class session cannot recompose its extension closure in place, so\n * a relaunch-class transition normally stays pending until a human reruns the\n * launcher with the new selection. A supervisor that owns the agent process\n * (doompi-server) opts into performing that relaunch itself: it points this\n * environment variable at a file path, the runtime writes the target selection\n * there and exits, and the supervisor respawns the agent with the recorded\n * major mode under the same session id.\n */\nexport const DOOM_RELAUNCH_FILE_ENV = 'DOOMPI_RELAUNCH_FILE';\n\nconst MAX_IDENTIFIER_LENGTH = 256;\n\nexport const RelaunchHandoffSchema = Type.Object(\n  {\n    version: Type.Literal(1),\n    majorMode: Type.String({ minLength: 1, maxLength: MAX_IDENTIFIER_LENGTH }),\n    operationId: Type.String({ minLength: 1, maxLength: MAX_IDENTIFIER_LENGTH }),\n  },\n  { additionalProperties: false },\n);\nexport type RelaunchHandoff = Static<typeof RelaunchHandoffSchema>;\n\nexport function serializeRelaunchHandoff(handoff: RelaunchHandoff): string {\n  return JSON.stringify(handoff);\n}\n\n/** The handoff a supervisor read back, or undefined for anything malformed. */\nexport function parseRelaunchHandoff(text: string): RelaunchHandoff | undefined {\n  let candidate: unknown;\n  try {\n    candidate = JSON.parse(text);\n  } catch {\n    return undefined;\n  }\n  return Check(RelaunchHandoffSchema, candidate) ? candidate : undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,MAAa,yBAAyB;AAEtC,MAAM,wBAAwB;AAE9B,MAAa,wBAAwBA,QAAAA,KAAK,OACxC;CACE,SAASA,QAAAA,KAAK,QAAQ,CAAC;CACvB,WAAWA,QAAAA,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAsB,CAAC;CACzE,aAAaA,QAAAA,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAsB,CAAC;AAC7E,GACA,EAAE,sBAAsB,MAAM,CAChC;AAGA,SAAgB,yBAAyB,SAAkC;CACzE,OAAO,KAAK,UAAU,OAAO;AAC/B;;AAGA,SAAgB,qBAAqB,MAA2C;CAC9E,IAAI;CACJ,IAAI;EACF,YAAY,KAAK,MAAM,IAAI;CAC7B,QAAQ;EACN;CACF;CACA,QAAA,GAAOC,cAAAA,MAAAA,CAAM,uBAAuB,SAAS,IAAI,YAAY,KAAA;AAC/D"}

package/dist/schemas/relaunchHandoff.d.cts

@@ -0,0 +1,25 @@
+import { Static, Type } from "typebox";
+//#region src/schemas/relaunchHandoff.d.ts
+/**
+ * The relaunch handoff between a DoomPi runtime and its process supervisor.
+ *
+ * A launcher-class session cannot recompose its extension closure in place, so
+ * a relaunch-class transition normally stays pending until a human reruns the
+ * launcher with the new selection. A supervisor that owns the agent process
+ * (doompi-server) opts into performing that relaunch itself: it points this
+ * environment variable at a file path, the runtime writes the target selection
+ * there and exits, and the supervisor respawns the agent with the recorded
+ * major mode under the same session id.
+ */
+export declare const DOOM_RELAUNCH_FILE_ENV = "DOOMPI_RELAUNCH_FILE";
+export declare const RelaunchHandoffSchema: Type.TObject<{
+  version: Type.TLiteral<1>;
+  majorMode: Type.TString;
+  operationId: Type.TString;
+}>;
+export type RelaunchHandoff = Static<typeof RelaunchHandoffSchema>;
+export declare function serializeRelaunchHandoff(handoff: RelaunchHandoff): string;
+/** The handoff a supervisor read back, or undefined for anything malformed. */
+export declare function parseRelaunchHandoff(text: string): RelaunchHandoff | undefined;
+//#endregion
+//# sourceMappingURL=relaunchHandoff.d.cts.map

package/dist/schemas/relaunchHandoff.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relaunchHandoff.d.cts","names":[],"sources":["../../src/schemas/relaunchHandoff.ts"],"mappings":";;;;;;;;;;;;;qBAca;qBAIA,uBAAqB,KAAA;;;;;YAQtB,kBAAkB,cAAc;wBAE5B,yBAAyB,SAAS;;wBAKlC,qBAAqB,eAAe"}

package/dist/schemas/relaunchHandoff.d.mts

@@ -0,0 +1,25 @@
+import { Static, Type } from "typebox";
+//#region src/schemas/relaunchHandoff.d.ts
+/**
+ * The relaunch handoff between a DoomPi runtime and its process supervisor.
+ *
+ * A launcher-class session cannot recompose its extension closure in place, so
+ * a relaunch-class transition normally stays pending until a human reruns the
+ * launcher with the new selection. A supervisor that owns the agent process
+ * (doompi-server) opts into performing that relaunch itself: it points this
+ * environment variable at a file path, the runtime writes the target selection
+ * there and exits, and the supervisor respawns the agent with the recorded
+ * major mode under the same session id.
+ */
+export declare const DOOM_RELAUNCH_FILE_ENV = "DOOMPI_RELAUNCH_FILE";
+export declare const RelaunchHandoffSchema: Type.TObject<{
+  version: Type.TLiteral<1>;
+  majorMode: Type.TString;
+  operationId: Type.TString;
+}>;
+export type RelaunchHandoff = Static<typeof RelaunchHandoffSchema>;
+export declare function serializeRelaunchHandoff(handoff: RelaunchHandoff): string;
+/** The handoff a supervisor read back, or undefined for anything malformed. */
+export declare function parseRelaunchHandoff(text: string): RelaunchHandoff | undefined;
+//#endregion
+//# sourceMappingURL=relaunchHandoff.d.mts.map

package/dist/schemas/relaunchHandoff.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relaunchHandoff.d.mts","names":[],"sources":["../../src/schemas/relaunchHandoff.ts"],"mappings":";;;;;;;;;;;;;qBAca;qBAIA,uBAAqB,KAAA;;;;;YAQtB,kBAAkB,cAAc;wBAE5B,yBAAyB,SAAS;;wBAKlC,qBAAqB,eAAe"}

package/dist/schemas/relaunchHandoff.mjs

@@ -0,0 +1,44 @@
+import { Type } from "typebox";
+import { Check } from "typebox/value";
+//#region src/schemas/relaunchHandoff.ts
+/**
+* The relaunch handoff between a DoomPi runtime and its process supervisor.
+*
+* A launcher-class session cannot recompose its extension closure in place, so
+* a relaunch-class transition normally stays pending until a human reruns the
+* launcher with the new selection. A supervisor that owns the agent process
+* (doompi-server) opts into performing that relaunch itself: it points this
+* environment variable at a file path, the runtime writes the target selection
+* there and exits, and the supervisor respawns the agent with the recorded
+* major mode under the same session id.
+*/
+const DOOM_RELAUNCH_FILE_ENV = "DOOMPI_RELAUNCH_FILE";
+const MAX_IDENTIFIER_LENGTH = 256;
+const RelaunchHandoffSchema = Type.Object({
+	version: Type.Literal(1),
+	majorMode: Type.String({
+		minLength: 1,
+		maxLength: MAX_IDENTIFIER_LENGTH
+	}),
+	operationId: Type.String({
+		minLength: 1,
+		maxLength: MAX_IDENTIFIER_LENGTH
+	})
+}, { additionalProperties: false });
+function serializeRelaunchHandoff(handoff) {
+	return JSON.stringify(handoff);
+}
+/** The handoff a supervisor read back, or undefined for anything malformed. */
+function parseRelaunchHandoff(text) {
+	let candidate;
+	try {
+		candidate = JSON.parse(text);
+	} catch {
+		return;
+	}
+	return Check(RelaunchHandoffSchema, candidate) ? candidate : void 0;
+}
+//#endregion
+export { DOOM_RELAUNCH_FILE_ENV, RelaunchHandoffSchema, parseRelaunchHandoff, serializeRelaunchHandoff };
+
+//# sourceMappingURL=relaunchHandoff.mjs.map

package/dist/schemas/relaunchHandoff.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"relaunchHandoff.mjs","names":[],"sources":["../../src/schemas/relaunchHandoff.ts"],"sourcesContent":["import { type Static, Type } from 'typebox';\nimport { Check } from 'typebox/value';\n\n/**\n * The relaunch handoff between a DoomPi runtime and its process supervisor.\n *\n * A launcher-class session cannot recompose its extension closure in place, so\n * a relaunch-class transition normally stays pending until a human reruns the\n * launcher with the new selection. A supervisor that owns the agent process\n * (doompi-server) opts into performing that relaunch itself: it points this\n * environment variable at a file path, the runtime writes the target selection\n * there and exits, and the supervisor respawns the agent with the recorded\n * major mode under the same session id.\n */\nexport const DOOM_RELAUNCH_FILE_ENV = 'DOOMPI_RELAUNCH_FILE';\n\nconst MAX_IDENTIFIER_LENGTH = 256;\n\nexport const RelaunchHandoffSchema = Type.Object(\n  {\n    version: Type.Literal(1),\n    majorMode: Type.String({ minLength: 1, maxLength: MAX_IDENTIFIER_LENGTH }),\n    operationId: Type.String({ minLength: 1, maxLength: MAX_IDENTIFIER_LENGTH }),\n  },\n  { additionalProperties: false },\n);\nexport type RelaunchHandoff = Static<typeof RelaunchHandoffSchema>;\n\nexport function serializeRelaunchHandoff(handoff: RelaunchHandoff): string {\n  return JSON.stringify(handoff);\n}\n\n/** The handoff a supervisor read back, or undefined for anything malformed. */\nexport function parseRelaunchHandoff(text: string): RelaunchHandoff | undefined {\n  let candidate: unknown;\n  try {\n    candidate = JSON.parse(text);\n  } catch {\n    return undefined;\n  }\n  return Check(RelaunchHandoffSchema, candidate) ? candidate : undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,MAAa,yBAAyB;AAEtC,MAAM,wBAAwB;AAE9B,MAAa,wBAAwB,KAAK,OACxC;CACE,SAAS,KAAK,QAAQ,CAAC;CACvB,WAAW,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAsB,CAAC;CACzE,aAAa,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAsB,CAAC;AAC7E,GACA,EAAE,sBAAsB,MAAM,CAChC;AAGA,SAAgB,yBAAyB,SAAkC;CACzE,OAAO,KAAK,UAAU,OAAO;AAC/B;;AAGA,SAAgB,qBAAqB,MAA2C;CAC9E,IAAI;CACJ,IAAI;EACF,YAAY,KAAK,MAAM,IAAI;CAC7B,QAAQ;EACN;CACF;CACA,OAAO,MAAM,uBAAuB,SAAS,IAAI,YAAY,KAAA;AAC/D"}