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

package/dist/runtimeConfig.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeConfig.d.mts","names":[],"sources":["../src/schemas/config.ts"],"mappings":";;;qBAqBa;;qBAGA,oBAAkB,KAAA;;;;;;qBAalB,oBAAkB,KAAA,QAAA,KAAA,mBAAA,KAAA,uBAAA,KAAA;YAKnB,eAAe,cAAc;qBAE5B,uBAAqB,KAAA,QAAA,KAAA,kBAAA,KAAA,kBAAA,KAAA,oBAAA,KAAA;YAUtB,kBAAkB,cAAc;;;;;;qBAO/B,oBAAkB,KAAA;;;;;YAQnB,eAAe,cAAc;qBAE5B,oBAAkB,KAAA;;;;;;;;;;;;;;;;YAmBnB,eAAe,cAAc;;;;;;;;;qBAU5B,kBAAgB,KAAA;;;;;YAejB,aAAa,cAAc;qBAE1B,sBAAoB,KAAA;;;;;YAQrB,iBAAiB,cAAc;qBAE9B,mBAAiB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqClB,cAAc,cAAc;qBAE3B,qBAAmB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAapB,gBAAgB,cAAc;cAEpC,uBAAqB,KAAA;;;;cAKrB,sBAAoB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAId,iBAAiB,cAAc;YAC/B,kBAAkB,cAAc;qBAE/B;WACX;WACA;;iBAGe;EACf;IAAkB;;;iBAGH,8BAA8B;EAC7C;;iBAGe;EACf;EACA;EACA;EACA;EACA;;iBAGe,sBAAsB,gBAAgB,uBAAuB;EAC5E,KAAK;EACL;EACA;EACA;;iBAGe,8BAA8B,gBAAgB,uBAAuB;EACpF;EACA,6BAA6B;EAC7B,UAAU,SAAS,gBAAgB,OAAO,sBAAsB,oBAAoB;EACpF,UAAU,gBAAgB,oBAAoB,KAAK;;iBAGpC;EACf;EACA"}

package/dist/runtimeConfig.mjs

@@ -0,0 +1,221 @@
+import { Type } from "typebox";
+//#region src/schemas/config.ts
+/**
+* Configuration surfaces, contributed by every extension that owns settings.
+*
+* Doom settings live in one YAML file but are owned by many extensions, and for
+* a long time the only way to change any of them was to edit that file by hand.
+* The one exception, an editor-command prompt, asked for a value with no way to
+* see what a valid one looked like.
+*
+* So configuration is published rather than centralised: an extension describes
+* its own fields, one renderer draws them all, and the extension still performs
+* every write. Nothing here knows what a voice model or an editor command is.
+*
+* Deliberately the same shape as the mode and footer contracts next door, since
+* the problem is the same one: several extensions sharing one surface. The UI
+* hub invokes an owner's registered action directly, because unlike a status
+* strip this surface is written to as well as read.
+*/
+/** Canonical Cordis key for the session-owned Doom configuration service. */
+const DOOM_CONFIG_SERVICE = "doom/config";
+/** Matches the leader contract's source rule: package names, addressable and spoof-checkable. */
+const ConfigSourceSchema = Type.String({
+	minLength: 1,
+	maxLength: 128,
+	pattern: "^[A-Za-z0-9@][A-Za-z0-9@/._:-]*$"
+});
+const ConfigIdSchema = Type.String({
+	minLength: 1,
+	maxLength: 128,
+	pattern: "^[a-z0-9][a-z0-9._:-]*$"
+});
+/**
+* How ready a value is to be used, as opposed to whether it is merely set.
+* `blocked` covers a choice that needs something else first, such as a model
+* whose engine is not installed.
+*/
+const ConfigStatusSchema = Type.Union([
+	Type.Literal("ready"),
+	Type.Literal("available"),
+	Type.Literal("blocked")
+]);
+const ConfigFieldKindSchema = Type.Union([
+	Type.Literal("text"),
+	Type.Literal("enum"),
+	Type.Literal("choice"),
+	Type.Literal("info")
+]);
+/**
+* A key the renderer offers on the focused field, sent back verbatim as an
+* action. Owners use this for confirmations, so the pending question survives a
+* panel that is closed and reopened.
+*/
+const ConfigActionSchema = Type.Object({
+	key: Type.String({
+		minLength: 1,
+		maxLength: 1
+	}),
+	label: Type.String({
+		minLength: 1,
+		maxLength: 24
+	}),
+	action: ConfigIdSchema
+}, { additionalProperties: false });
+const ConfigChoiceSchema = Type.Object({
+	id: Type.String({
+		minLength: 1,
+		maxLength: 256
+	}),
+	label: Type.String({
+		minLength: 1,
+		maxLength: 96
+	}),
+	/** Right-aligned by the renderer. Sizes, ids, anything narrow. */
+	detail: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 96
+	})),
+	/** Groups entries under a heading the cursor skips over. */
+	group: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 48
+	})),
+	status: Type.Optional(ConfigStatusSchema),
+	statusText: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 96
+	})),
+	/**
+	* What enter does on this entry. Carrying it per-entry is what lets one list
+	* hold both an installed model that only needs selecting and an absent one
+	* that needs fetching, without the renderer knowing the difference.
+	*/
+	action: Type.Optional(ConfigIdSchema)
+}, { additionalProperties: false });
+/**
+* One line of a multi-step operation.
+*
+* Published as a list rather than a single "current step" string so the panel can
+* show what already ran alongside what is left. During an install that is the
+* difference between "something is happening" and knowing a package manager
+* already finished and a download is now underway.
+*/
+const ConfigStepSchema = Type.Object({
+	label: Type.String({
+		minLength: 1,
+		maxLength: 96
+	}),
+	state: Type.Union([
+		Type.Literal("pending"),
+		Type.Literal("satisfied"),
+		Type.Literal("running"),
+		Type.Literal("done"),
+		Type.Literal("failed")
+	]),
+	detail: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 160
+	}))
+}, { additionalProperties: false });
+const ConfigProgressSchema = Type.Object({
+	label: Type.String({
+		minLength: 1,
+		maxLength: 96
+	}),
+	/** 0 to 1. Omitted when the work has no measurable total. */
+	ratio: Type.Optional(Type.Number({
+		minimum: 0,
+		maximum: 1
+	}))
+}, { additionalProperties: false });
+const ConfigFieldSchema = Type.Object({
+	id: ConfigIdSchema,
+	label: Type.String({
+		minLength: 1,
+		maxLength: 48
+	}),
+	kind: ConfigFieldKindSchema,
+	/** Absent means unset; the renderer shows `placeholder` instead. */
+	value: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 4096
+	})),
+	placeholder: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 96
+	})),
+	/** One line of help for the focused field. */
+	detail: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 240
+	})),
+	/** The config key this writes, shown under the focused field so the file stays legible. */
+	keyPath: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 128
+	})),
+	status: Type.Optional(ConfigStatusSchema),
+	/** Doubles as the error line: a rejected edit comes back as the old value plus this. */
+	statusText: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 240
+	})),
+	choices: Type.Optional(Type.Array(ConfigChoiceSchema, { maxItems: 128 })),
+	actions: Type.Optional(Type.Array(ConfigActionSchema, { maxItems: 4 })),
+	/** Work is running; the renderer dims the field and offers abort. */
+	busy: Type.Optional(Type.Boolean()),
+	progress: Type.Optional(ConfigProgressSchema),
+	steps: Type.Optional(Type.Array(ConfigStepSchema, { maxItems: 24 })),
+	/**
+	* The tail of a running command's terminal output.
+	*
+	* A tail rather than the whole scrollback: the field is a few rows of a
+	* shared pane, and what matters is the question a package manager just
+	* asked, not what it printed a minute ago.
+	*/
+	output: Type.Optional(Type.Array(Type.String({ maxLength: 512 }), { maxItems: 64 })),
+	/**
+	* The command is waiting on the user. The renderer offers a line to type
+	* into, which comes back as an owner-defined action carrying the text.
+	*/
+	awaitingInput: Type.Optional(Type.Boolean())
+}, { additionalProperties: false });
+const ConfigSectionSchema = Type.Object({
+	id: ConfigIdSchema,
+	title: Type.String({
+		minLength: 1,
+		maxLength: 32
+	}),
+	detail: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 96
+	})),
+	order: Type.Integer({
+		minimum: 0,
+		maximum: 1e3
+	}),
+	/** Section-wide state: readiness, or why a write failed. */
+	notice: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 240
+	})),
+	noticeLevel: Type.Optional(Type.Union([Type.Literal("info"), Type.Literal("error")])),
+	fields: Type.Array(ConfigFieldSchema, { maxItems: 64 })
+}, { additionalProperties: false });
+const ConfigSourceRefSchema = Type.Object({
+	source: ConfigSourceSchema,
+	generation: Type.String({ minLength: 1 })
+}, { additionalProperties: false });
+Type.Object({
+	...ConfigSourceRefSchema.properties,
+	sections: Type.Array(ConfigSectionSchema, { maxItems: 32 })
+}, { additionalProperties: false });
+const CONFIG_ACTION = {
+	set: "set",
+	clear: "clear"
+};
+//#endregion
+export { CONFIG_ACTION, ConfigActionSchema, ConfigChoiceSchema, ConfigFieldKindSchema, ConfigFieldSchema, ConfigProgressSchema, ConfigSectionSchema, ConfigSourceSchema, ConfigStatusSchema, ConfigStepSchema, DOOM_CONFIG_SERVICE };
+
+//# sourceMappingURL=runtimeConfig.mjs.map

package/dist/runtimeConfig.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeConfig.mjs","names":[],"sources":["../src/schemas/config.ts"],"sourcesContent":["/**\n * Configuration surfaces, contributed by every extension that owns settings.\n *\n * Doom settings live in one YAML file but are owned by many extensions, and for\n * a long time the only way to change any of them was to edit that file by hand.\n * The one exception, an editor-command prompt, asked for a value with no way to\n * see what a valid one looked like.\n *\n * So configuration is published rather than centralised: an extension describes\n * its own fields, one renderer draws them all, and the extension still performs\n * every write. Nothing here knows what a voice model or an editor command is.\n *\n * Deliberately the same shape as the mode and footer contracts next door, since\n * the problem is the same one: several extensions sharing one surface. The UI\n * hub invokes an owner's registered action directly, because unlike a status\n * strip this surface is written to as well as read.\n */\n\nimport { type Static, Type } from 'typebox';\n\n/** Canonical Cordis key for the session-owned Doom configuration service. */\nexport const DOOM_CONFIG_SERVICE = 'doom/config';\n\n/** Matches the leader contract's source rule: package names, addressable and spoof-checkable. */\nexport const ConfigSourceSchema = Type.String({\n  minLength: 1,\n  maxLength: 128,\n  pattern: '^[A-Za-z0-9@][A-Za-z0-9@/._:-]*$',\n});\n\nconst ConfigIdSchema = Type.String({ minLength: 1, maxLength: 128, pattern: '^[a-z0-9][a-z0-9._:-]*$' });\n\n/**\n * How ready a value is to be used, as opposed to whether it is merely set.\n * `blocked` covers a choice that needs something else first, such as a model\n * whose engine is not installed.\n */\nexport const ConfigStatusSchema = Type.Union([\n  Type.Literal('ready'),\n  Type.Literal('available'),\n  Type.Literal('blocked'),\n]);\nexport type ConfigStatus = Static<typeof ConfigStatusSchema>;\n\nexport const ConfigFieldKindSchema = Type.Union([\n  /** Free text, edited in place. */\n  Type.Literal('text'),\n  /** A short closed set, cycled in place. */\n  Type.Literal('enum'),\n  /** A long set worth its own screen, with per-entry status and actions. */\n  Type.Literal('choice'),\n  /** Read-only. Resolution results, derived values, preflight checks. */\n  Type.Literal('info'),\n]);\nexport type ConfigFieldKind = Static<typeof ConfigFieldKindSchema>;\n\n/**\n * A key the renderer offers on the focused field, sent back verbatim as an\n * action. Owners use this for confirmations, so the pending question survives a\n * panel that is closed and reopened.\n */\nexport const ConfigActionSchema = Type.Object(\n  {\n    key: Type.String({ minLength: 1, maxLength: 1 }),\n    label: Type.String({ minLength: 1, maxLength: 24 }),\n    action: ConfigIdSchema,\n  },\n  { additionalProperties: false },\n);\nexport type ConfigAction = Static<typeof ConfigActionSchema>;\n\nexport const ConfigChoiceSchema = Type.Object(\n  {\n    id: Type.String({ minLength: 1, maxLength: 256 }),\n    label: Type.String({ minLength: 1, maxLength: 96 }),\n    /** Right-aligned by the renderer. Sizes, ids, anything narrow. */\n    detail: Type.Optional(Type.String({ minLength: 1, maxLength: 96 })),\n    /** Groups entries under a heading the cursor skips over. */\n    group: Type.Optional(Type.String({ minLength: 1, maxLength: 48 })),\n    status: Type.Optional(ConfigStatusSchema),\n    statusText: Type.Optional(Type.String({ minLength: 1, maxLength: 96 })),\n    /**\n     * What enter does on this entry. Carrying it per-entry is what lets one list\n     * hold both an installed model that only needs selecting and an absent one\n     * that needs fetching, without the renderer knowing the difference.\n     */\n    action: Type.Optional(ConfigIdSchema),\n  },\n  { additionalProperties: false },\n);\nexport type ConfigChoice = Static<typeof ConfigChoiceSchema>;\n\n/**\n * One line of a multi-step operation.\n *\n * Published as a list rather than a single \"current step\" string so the panel can\n * show what already ran alongside what is left. During an install that is the\n * difference between \"something is happening\" and knowing a package manager\n * already finished and a download is now underway.\n */\nexport const ConfigStepSchema = Type.Object(\n  {\n    label: Type.String({ minLength: 1, maxLength: 96 }),\n    state: Type.Union([\n      Type.Literal('pending'),\n      /** Already true of this machine, so nothing will run for it. */\n      Type.Literal('satisfied'),\n      Type.Literal('running'),\n      Type.Literal('done'),\n      Type.Literal('failed'),\n    ]),\n    detail: Type.Optional(Type.String({ minLength: 1, maxLength: 160 })),\n  },\n  { additionalProperties: false },\n);\nexport type ConfigStep = Static<typeof ConfigStepSchema>;\n\nexport const ConfigProgressSchema = Type.Object(\n  {\n    label: Type.String({ minLength: 1, maxLength: 96 }),\n    /** 0 to 1. Omitted when the work has no measurable total. */\n    ratio: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),\n  },\n  { additionalProperties: false },\n);\nexport type ConfigProgress = Static<typeof ConfigProgressSchema>;\n\nexport const ConfigFieldSchema = Type.Object(\n  {\n    id: ConfigIdSchema,\n    label: Type.String({ minLength: 1, maxLength: 48 }),\n    kind: ConfigFieldKindSchema,\n    /** Absent means unset; the renderer shows `placeholder` instead. */\n    value: Type.Optional(Type.String({ minLength: 1, maxLength: 4096 })),\n    placeholder: Type.Optional(Type.String({ minLength: 1, maxLength: 96 })),\n    /** One line of help for the focused field. */\n    detail: Type.Optional(Type.String({ minLength: 1, maxLength: 240 })),\n    /** The config key this writes, shown under the focused field so the file stays legible. */\n    keyPath: Type.Optional(Type.String({ minLength: 1, maxLength: 128 })),\n    status: Type.Optional(ConfigStatusSchema),\n    /** Doubles as the error line: a rejected edit comes back as the old value plus this. */\n    statusText: Type.Optional(Type.String({ minLength: 1, maxLength: 240 })),\n    choices: Type.Optional(Type.Array(ConfigChoiceSchema, { maxItems: 128 })),\n    actions: Type.Optional(Type.Array(ConfigActionSchema, { maxItems: 4 })),\n    /** Work is running; the renderer dims the field and offers abort. */\n    busy: Type.Optional(Type.Boolean()),\n    progress: Type.Optional(ConfigProgressSchema),\n    steps: Type.Optional(Type.Array(ConfigStepSchema, { maxItems: 24 })),\n    /**\n     * The tail of a running command's terminal output.\n     *\n     * A tail rather than the whole scrollback: the field is a few rows of a\n     * shared pane, and what matters is the question a package manager just\n     * asked, not what it printed a minute ago.\n     */\n    output: Type.Optional(Type.Array(Type.String({ maxLength: 512 }), { maxItems: 64 })),\n    /**\n     * The command is waiting on the user. The renderer offers a line to type\n     * into, which comes back as an owner-defined action carrying the text.\n     */\n    awaitingInput: Type.Optional(Type.Boolean()),\n  },\n  { additionalProperties: false },\n);\nexport type ConfigField = Static<typeof ConfigFieldSchema>;\n\nexport const ConfigSectionSchema = Type.Object(\n  {\n    id: ConfigIdSchema,\n    title: Type.String({ minLength: 1, maxLength: 32 }),\n    detail: Type.Optional(Type.String({ minLength: 1, maxLength: 96 })),\n    order: Type.Integer({ minimum: 0, maximum: 1000 }),\n    /** Section-wide state: readiness, or why a write failed. */\n    notice: Type.Optional(Type.String({ minLength: 1, maxLength: 240 })),\n    noticeLevel: Type.Optional(Type.Union([Type.Literal('info'), Type.Literal('error')])),\n    fields: Type.Array(ConfigFieldSchema, { maxItems: 64 }),\n  },\n  { additionalProperties: false },\n);\nexport type ConfigSection = Static<typeof ConfigSectionSchema>;\n\nconst ConfigSourceRefSchema = Type.Object(\n  { source: ConfigSourceSchema, generation: Type.String({ minLength: 1 }) },\n  { additionalProperties: false },\n);\n\nconst ConfigSnapshotSchema = Type.Object(\n  { ...ConfigSourceRefSchema.properties, sections: Type.Array(ConfigSectionSchema, { maxItems: 32 }) },\n  { additionalProperties: false },\n);\nexport type ConfigSnapshot = Static<typeof ConfigSnapshotSchema>;\nexport type ConfigSourceRef = Static<typeof ConfigSourceRefSchema>;\n\nexport const CONFIG_ACTION = {\n  set: 'set',\n  clear: 'clear',\n} as const;\n\nexport interface DoomExtensionContext {\n  sessionManager: { getSessionId(): string };\n}\n\nexport interface DoomConfigSectionView extends ConfigSection {\n  source: string;\n}\n\nexport interface DoomConfigInvocation {\n  source: string;\n  sectionId: string;\n  fieldId: string;\n  action: string;\n  value?: string;\n}\n\nexport interface DoomConfigActionInput<Context extends DoomExtensionContext = DoomExtensionContext> {\n  ctx: Context;\n  sectionId: string;\n  fieldId: string;\n  value?: string;\n}\n\nexport interface DoomConfigContributionOptions<Context extends DoomExtensionContext = DoomExtensionContext> {\n  source: string;\n  listSections: () => readonly ConfigSection[];\n  handlers: Readonly<Record<string, (input: DoomConfigActionInput<Context>) => void | Promise<void>>>;\n  onError: (error: unknown, actionName: string, ctx: Context) => void;\n}\n\nexport interface DoomConfigContributionHandle {\n  update(): void;\n  dispose(): void;\n}\n"],"mappings":"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"}

package/dist/runtimeContextApi.cjs

@@ -0,0 +1,64 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_contextApi = require("./src/constants/contextApi.cjs");
+const require_contextDetailStore = require("./contextDetailStore.cjs");
+//#region src/server/contextApi.ts
+/**
+* What one row of the composition actually is, on request.
+*
+* The context panel prices every tool and skill the session carries, and the
+* figure is only half an answer: the reader deciding whether a package earns
+* its thousand tokens wants the prose and the schema behind it. Those are too
+* large to push, and they are wanted one row at a time, so they are served
+* here instead and fetched on the click.
+*
+* The agent writes the store; this reads it. The two are separate processes
+* and the inventory only exists inside the agent, which is the same split
+* every other package-owned API in the repository lives with.
+*/
+function json(body, status) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json; charset=utf-8" }
+	});
+}
+function isItemKind(value) {
+	return value === "tool" || value === "skill" || value === "prompt";
+}
+function createContextApi(options = {}) {
+	const readDetail = options.readDetail ?? require_contextDetailStore.readContextDetail;
+	return {
+		fetch(request) {
+			const url = new URL(request.url);
+			if (url.pathname !== "/item") return json({ error: "No such route." }, 404);
+			if (request.method !== "GET") return json({ error: "Only GET is served here." }, 405);
+			if (options.sessionId === void 0) return json({ error: "This host serves no session." }, 404);
+			const itemKind = url.searchParams.get(require_contextApi.KIND_QUERY_PARAM);
+			const name = url.searchParams.get(require_contextApi.NAME_QUERY_PARAM);
+			if (!isItemKind(itemKind)) return json({ error: "Ask for a tool, a skill, or the prompt." }, 400);
+			if (name === null || name === "") return json({ error: "Name the item to describe." }, 400);
+			const file = options.readDetail ? options.readDetail(options.sessionId, options.environment) : options.environment === void 0 ? void 0 : readDetail(options.sessionId, options.environment);
+			if (file === void 0) return json({ error: "This session has not reported its composition yet." }, 404);
+			const item = require_contextDetailStore.findContextItem(file, itemKind, name);
+			if (item === void 0) return json({ error: `The session carries no ${itemKind} called ${name}.` }, 404);
+			return json({
+				revision: file.revision,
+				item
+			}, 200);
+		},
+		close: () => {}
+	};
+}
+const api = {
+	basePath: require_contextApi.API_BASE_PATH,
+	start(context) {
+		return createContextApi({
+			...context.sessionId === void 0 ? {} : { sessionId: context.sessionId },
+			...context.environment === void 0 ? {} : { environment: context.environment }
+		});
+	}
+};
+//#endregion
+exports.api = api;
+exports.createContextApi = createContextApi;
+
+//# sourceMappingURL=runtimeContextApi.cjs.map

package/dist/runtimeContextApi.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeContextApi.cjs","names":["readContextDetail","KIND_QUERY_PARAM","NAME_QUERY_PARAM","findContextItem","API_BASE_PATH"],"sources":["../src/server/contextApi.ts"],"sourcesContent":["import { API_BASE_PATH, ITEM_ROUTE, KIND_QUERY_PARAM, NAME_QUERY_PARAM } from '../constants/contextApi';\nimport type { DoomApi, DoomApiContext, DoomApiHandler } from '../exports/packageApi';\nimport { findContextItem, readContextDetail } from '../services/contextDetailStore';\n\n/**\n * What one row of the composition actually is, on request.\n *\n * The context panel prices every tool and skill the session carries, and the\n * figure is only half an answer: the reader deciding whether a package earns\n * its thousand tokens wants the prose and the schema behind it. Those are too\n * large to push, and they are wanted one row at a time, so they are served\n * here instead and fetched on the click.\n *\n * The agent writes the store; this reads it. The two are separate processes\n * and the inventory only exists inside the agent, which is the same split\n * every other package-owned API in the repository lives with.\n */\n\nfunction json(body: unknown, status: number): Response {\n  return new Response(JSON.stringify(body), {\n    status,\n    headers: { 'content-type': 'application/json; charset=utf-8' },\n  });\n}\n\nfunction isItemKind(value: string | null): value is 'tool' | 'skill' | 'prompt' {\n  return value === 'tool' || value === 'skill' || value === 'prompt';\n}\n\nexport interface ContextApiOptions {\n  /** The session these routes answer for; absent when the host is the hub. */\n  sessionId?: string;\n  /** Session environment admitted by the host. */\n  environment?: Readonly<Record<string, string | undefined>>;\n  /** Injectable for tests; defaults to the file the agent writes. */\n  readDetail?: typeof readContextDetail;\n}\n\nexport function createContextApi(options: ContextApiOptions = {}): DoomApiHandler {\n  const readDetail = options.readDetail ?? readContextDetail;\n  return {\n    fetch(request: Request): Response {\n      const url = new URL(request.url);\n      if (url.pathname !== ITEM_ROUTE) return json({ error: 'No such route.' }, 404);\n      if (request.method !== 'GET') return json({ error: 'Only GET is served here.' }, 405);\n      if (options.sessionId === undefined) return json({ error: 'This host serves no session.' }, 404);\n\n      const itemKind = url.searchParams.get(KIND_QUERY_PARAM);\n      const name = url.searchParams.get(NAME_QUERY_PARAM);\n      if (!isItemKind(itemKind)) return json({ error: 'Ask for a tool, a skill, or the prompt.' }, 400);\n      if (name === null || name === '') return json({ error: 'Name the item to describe.' }, 400);\n\n      const file = options.readDetail\n        ? options.readDetail(options.sessionId, options.environment)\n        : options.environment === undefined\n          ? undefined\n          : readDetail(options.sessionId, options.environment);\n      // A session that has not published yet is the ordinary state for the\n      // first half-second of its life, and says so rather than looking broken.\n      if (file === undefined) {\n        return json({ error: 'This session has not reported its composition yet.' }, 404);\n      }\n      const item = findContextItem(file, itemKind, name);\n      if (item === undefined) return json({ error: `The session carries no ${itemKind} called ${name}.` }, 404);\n      return json({ revision: file.revision, item }, 200);\n    },\n    close: () => {},\n  };\n}\n\nexport const api: DoomApi = {\n  basePath: API_BASE_PATH,\n  start(context: DoomApiContext): DoomApiHandler {\n    return createContextApi({\n      ...(context.sessionId === undefined ? {} : { sessionId: context.sessionId }),\n      ...(context.environment === undefined ? {} : { environment: context.environment }),\n    });\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAkBA,SAAS,KAAK,MAAe,QAA0B;CACrD,OAAO,IAAI,SAAS,KAAK,UAAU,IAAI,GAAG;EACxC;EACA,SAAS,EAAE,gBAAgB,kCAAkC;CAC/D,CAAC;AACH;AAEA,SAAS,WAAW,OAA4D;CAC9E,OAAO,UAAU,UAAU,UAAU,WAAW,UAAU;AAC5D;AAWA,SAAgB,iBAAiB,UAA6B,CAAC,GAAmB;CAChF,MAAM,aAAa,QAAQ,cAAcA,2BAAAA;CACzC,OAAO;EACL,MAAM,SAA4B;GAChC,MAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;GAC/B,IAAI,IAAI,aAAA,SAAyB,OAAO,KAAK,EAAE,OAAO,iBAAiB,GAAG,GAAG;GAC7E,IAAI,QAAQ,WAAW,OAAO,OAAO,KAAK,EAAE,OAAO,2BAA2B,GAAG,GAAG;GACpF,IAAI,QAAQ,cAAc,KAAA,GAAW,OAAO,KAAK,EAAE,OAAO,+BAA+B,GAAG,GAAG;GAE/F,MAAM,WAAW,IAAI,aAAa,IAAIC,mBAAAA,gBAAgB;GACtD,MAAM,OAAO,IAAI,aAAa,IAAIC,mBAAAA,gBAAgB;GAClD,IAAI,CAAC,WAAW,QAAQ,GAAG,OAAO,KAAK,EAAE,OAAO,0CAA0C,GAAG,GAAG;GAChG,IAAI,SAAS,QAAQ,SAAS,IAAI,OAAO,KAAK,EAAE,OAAO,6BAA6B,GAAG,GAAG;GAE1F,MAAM,OAAO,QAAQ,aACjB,QAAQ,WAAW,QAAQ,WAAW,QAAQ,WAAW,IACzD,QAAQ,gBAAgB,KAAA,IACtB,KAAA,IACA,WAAW,QAAQ,WAAW,QAAQ,WAAW;GAGvD,IAAI,SAAS,KAAA,GACX,OAAO,KAAK,EAAE,OAAO,qDAAqD,GAAG,GAAG;GAElF,MAAM,OAAOC,2BAAAA,gBAAgB,MAAM,UAAU,IAAI;GACjD,IAAI,SAAS,KAAA,GAAW,OAAO,KAAK,EAAE,OAAO,0BAA0B,SAAS,UAAU,KAAK,GAAG,GAAG,GAAG;GACxG,OAAO,KAAK;IAAE,UAAU,KAAK;IAAU;GAAK,GAAG,GAAG;EACpD;EACA,aAAa,CAAC;CAChB;AACF;AAEA,MAAa,MAAe;CAC1B,UAAUC,mBAAAA;CACV,MAAM,SAAyC;EAC7C,OAAO,iBAAiB;GACtB,GAAI,QAAQ,cAAc,KAAA,IAAY,CAAC,IAAI,EAAE,WAAW,QAAQ,UAAU;GAC1E,GAAI,QAAQ,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,aAAa,QAAQ,YAAY;EAClF,CAAC;CACH;AACF"}

package/dist/runtimeContextApi.d.mts

@@ -0,0 +1,16 @@
+import { DoomApi, DoomApiHandler } from "./src/schemas/packageApi.mjs";
+import "./packageApi.mjs";
+import { readContextDetail } from "./contextDetailStore.mjs";
+//#region src/server/contextApi.d.ts
+export interface ContextApiOptions {
+  /** The session these routes answer for; absent when the host is the hub. */
+  sessionId?: string;
+  /** Session environment admitted by the host. */
+  environment?: Readonly<Record<string, string | undefined>>;
+  /** Injectable for tests; defaults to the file the agent writes. */
+  readDetail?: typeof readContextDetail;
+}
+export declare function createContextApi(options?: ContextApiOptions): DoomApiHandler;
+export declare const api: DoomApi;
+//#endregion
+//# sourceMappingURL=runtimeContextApi.d.mts.map

package/dist/runtimeContextApi.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeContextApi.d.mts","names":[],"sources":["../src/server/contextApi.ts"],"mappings":";;;;iBA6BiB;;EAEf;;EAEA,cAAc,SAAS;;EAEvB,oBAAoB;;wBAGN,iBAAiB,UAAS,oBAAyB;qBAgCtD,KAAK"}

package/dist/runtimeContextApi.mjs

@@ -0,0 +1,62 @@
+import { API_BASE_PATH, KIND_QUERY_PARAM, NAME_QUERY_PARAM } from "./src/constants/contextApi.mjs";
+import { findContextItem, readContextDetail } from "./contextDetailStore.mjs";
+//#region src/server/contextApi.ts
+/**
+* What one row of the composition actually is, on request.
+*
+* The context panel prices every tool and skill the session carries, and the
+* figure is only half an answer: the reader deciding whether a package earns
+* its thousand tokens wants the prose and the schema behind it. Those are too
+* large to push, and they are wanted one row at a time, so they are served
+* here instead and fetched on the click.
+*
+* The agent writes the store; this reads it. The two are separate processes
+* and the inventory only exists inside the agent, which is the same split
+* every other package-owned API in the repository lives with.
+*/
+function json(body, status) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json; charset=utf-8" }
+	});
+}
+function isItemKind(value) {
+	return value === "tool" || value === "skill" || value === "prompt";
+}
+function createContextApi(options = {}) {
+	const readDetail = options.readDetail ?? readContextDetail;
+	return {
+		fetch(request) {
+			const url = new URL(request.url);
+			if (url.pathname !== "/item") return json({ error: "No such route." }, 404);
+			if (request.method !== "GET") return json({ error: "Only GET is served here." }, 405);
+			if (options.sessionId === void 0) return json({ error: "This host serves no session." }, 404);
+			const itemKind = url.searchParams.get(KIND_QUERY_PARAM);
+			const name = url.searchParams.get(NAME_QUERY_PARAM);
+			if (!isItemKind(itemKind)) return json({ error: "Ask for a tool, a skill, or the prompt." }, 400);
+			if (name === null || name === "") return json({ error: "Name the item to describe." }, 400);
+			const file = options.readDetail ? options.readDetail(options.sessionId, options.environment) : options.environment === void 0 ? void 0 : readDetail(options.sessionId, options.environment);
+			if (file === void 0) return json({ error: "This session has not reported its composition yet." }, 404);
+			const item = findContextItem(file, itemKind, name);
+			if (item === void 0) return json({ error: `The session carries no ${itemKind} called ${name}.` }, 404);
+			return json({
+				revision: file.revision,
+				item
+			}, 200);
+		},
+		close: () => {}
+	};
+}
+const api = {
+	basePath: API_BASE_PATH,
+	start(context) {
+		return createContextApi({
+			...context.sessionId === void 0 ? {} : { sessionId: context.sessionId },
+			...context.environment === void 0 ? {} : { environment: context.environment }
+		});
+	}
+};
+//#endregion
+export { api, createContextApi };
+
+//# sourceMappingURL=runtimeContextApi.mjs.map

package/dist/runtimeContextApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeContextApi.mjs","names":[],"sources":["../src/server/contextApi.ts"],"sourcesContent":["import { API_BASE_PATH, ITEM_ROUTE, KIND_QUERY_PARAM, NAME_QUERY_PARAM } from '../constants/contextApi';\nimport type { DoomApi, DoomApiContext, DoomApiHandler } from '../exports/packageApi';\nimport { findContextItem, readContextDetail } from '../services/contextDetailStore';\n\n/**\n * What one row of the composition actually is, on request.\n *\n * The context panel prices every tool and skill the session carries, and the\n * figure is only half an answer: the reader deciding whether a package earns\n * its thousand tokens wants the prose and the schema behind it. Those are too\n * large to push, and they are wanted one row at a time, so they are served\n * here instead and fetched on the click.\n *\n * The agent writes the store; this reads it. The two are separate processes\n * and the inventory only exists inside the agent, which is the same split\n * every other package-owned API in the repository lives with.\n */\n\nfunction json(body: unknown, status: number): Response {\n  return new Response(JSON.stringify(body), {\n    status,\n    headers: { 'content-type': 'application/json; charset=utf-8' },\n  });\n}\n\nfunction isItemKind(value: string | null): value is 'tool' | 'skill' | 'prompt' {\n  return value === 'tool' || value === 'skill' || value === 'prompt';\n}\n\nexport interface ContextApiOptions {\n  /** The session these routes answer for; absent when the host is the hub. */\n  sessionId?: string;\n  /** Session environment admitted by the host. */\n  environment?: Readonly<Record<string, string | undefined>>;\n  /** Injectable for tests; defaults to the file the agent writes. */\n  readDetail?: typeof readContextDetail;\n}\n\nexport function createContextApi(options: ContextApiOptions = {}): DoomApiHandler {\n  const readDetail = options.readDetail ?? readContextDetail;\n  return {\n    fetch(request: Request): Response {\n      const url = new URL(request.url);\n      if (url.pathname !== ITEM_ROUTE) return json({ error: 'No such route.' }, 404);\n      if (request.method !== 'GET') return json({ error: 'Only GET is served here.' }, 405);\n      if (options.sessionId === undefined) return json({ error: 'This host serves no session.' }, 404);\n\n      const itemKind = url.searchParams.get(KIND_QUERY_PARAM);\n      const name = url.searchParams.get(NAME_QUERY_PARAM);\n      if (!isItemKind(itemKind)) return json({ error: 'Ask for a tool, a skill, or the prompt.' }, 400);\n      if (name === null || name === '') return json({ error: 'Name the item to describe.' }, 400);\n\n      const file = options.readDetail\n        ? options.readDetail(options.sessionId, options.environment)\n        : options.environment === undefined\n          ? undefined\n          : readDetail(options.sessionId, options.environment);\n      // A session that has not published yet is the ordinary state for the\n      // first half-second of its life, and says so rather than looking broken.\n      if (file === undefined) {\n        return json({ error: 'This session has not reported its composition yet.' }, 404);\n      }\n      const item = findContextItem(file, itemKind, name);\n      if (item === undefined) return json({ error: `The session carries no ${itemKind} called ${name}.` }, 404);\n      return json({ revision: file.revision, item }, 200);\n    },\n    close: () => {},\n  };\n}\n\nexport const api: DoomApi = {\n  basePath: API_BASE_PATH,\n  start(context: DoomApiContext): DoomApiHandler {\n    return createContextApi({\n      ...(context.sessionId === undefined ? {} : { sessionId: context.sessionId }),\n      ...(context.environment === undefined ? {} : { environment: context.environment }),\n    });\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,SAAS,KAAK,MAAe,QAA0B;CACrD,OAAO,IAAI,SAAS,KAAK,UAAU,IAAI,GAAG;EACxC;EACA,SAAS,EAAE,gBAAgB,kCAAkC;CAC/D,CAAC;AACH;AAEA,SAAS,WAAW,OAA4D;CAC9E,OAAO,UAAU,UAAU,UAAU,WAAW,UAAU;AAC5D;AAWA,SAAgB,iBAAiB,UAA6B,CAAC,GAAmB;CAChF,MAAM,aAAa,QAAQ,cAAc;CACzC,OAAO;EACL,MAAM,SAA4B;GAChC,MAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;GAC/B,IAAI,IAAI,aAAA,SAAyB,OAAO,KAAK,EAAE,OAAO,iBAAiB,GAAG,GAAG;GAC7E,IAAI,QAAQ,WAAW,OAAO,OAAO,KAAK,EAAE,OAAO,2BAA2B,GAAG,GAAG;GACpF,IAAI,QAAQ,cAAc,KAAA,GAAW,OAAO,KAAK,EAAE,OAAO,+BAA+B,GAAG,GAAG;GAE/F,MAAM,WAAW,IAAI,aAAa,IAAI,gBAAgB;GACtD,MAAM,OAAO,IAAI,aAAa,IAAI,gBAAgB;GAClD,IAAI,CAAC,WAAW,QAAQ,GAAG,OAAO,KAAK,EAAE,OAAO,0CAA0C,GAAG,GAAG;GAChG,IAAI,SAAS,QAAQ,SAAS,IAAI,OAAO,KAAK,EAAE,OAAO,6BAA6B,GAAG,GAAG;GAE1F,MAAM,OAAO,QAAQ,aACjB,QAAQ,WAAW,QAAQ,WAAW,QAAQ,WAAW,IACzD,QAAQ,gBAAgB,KAAA,IACtB,KAAA,IACA,WAAW,QAAQ,WAAW,QAAQ,WAAW;GAGvD,IAAI,SAAS,KAAA,GACX,OAAO,KAAK,EAAE,OAAO,qDAAqD,GAAG,GAAG;GAElF,MAAM,OAAO,gBAAgB,MAAM,UAAU,IAAI;GACjD,IAAI,SAAS,KAAA,GAAW,OAAO,KAAK,EAAE,OAAO,0BAA0B,SAAS,UAAU,KAAK,GAAG,GAAG,GAAG;GACxG,OAAO,KAAK;IAAE,UAAU,KAAK;IAAU;GAAK,GAAG,GAAG;EACpD;EACA,aAAa,CAAC;CAChB;AACF;AAEA,MAAa,MAAe;CAC1B,UAAU;CACV,MAAM,SAAyC;EAC7C,OAAO,iBAAiB;GACtB,GAAI,QAAQ,cAAc,KAAA,IAAY,CAAC,IAAI,EAAE,WAAW,QAAQ,UAAU;GAC1E,GAAI,QAAQ,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,aAAa,QAAQ,YAAY;EAClF,CAAC;CACH;AACF"}

package/dist/runtimeCordisHost.cjs

@@ -0,0 +1,193 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_contextContributions = require("./src/schemas/contextContributions.cjs");
+const require_index = require("./src/services/contextContributions/index.cjs");
+const require_toolOverrides = require("./src/schemas/toolOverrides.cjs");
+const require_toolSurface = require("./src/schemas/toolSurface.cjs");
+const require_index$1 = require("./src/services/toolOverrides/index.cjs");
+const require_index$2 = require("./src/services/toolSurface/index.cjs");
+let _deepseek_ai_cordis = require("@deepseek-ai/cordis");
+//#region src/pi/cordisHost.ts
+const DOOM_CORDIS_HOST_ABI_VERSION = 1;
+const DOOM_CORDIS_HOST_QUERY_CHANNEL = "doom:cordis:host:v1:query";
+const DOOM_CORDIS_RUNTIME_SERVICE = "doom/runtime";
+const DOOM_CORDIS_SESSION_SERVICE = "doom/session";
+const DOOM_CORDIS_SERVER_SERVICES = "doom/server-session-services";
+const HOST_PROTOCOL = "doom.cordis.host";
+const DEFAULT_HOST_SOURCE = "@agimon-ai/doompi/cordis-host";
+function requireDoomCordisSession(context) {
+	const session = context.get(DOOM_CORDIS_SESSION_SERVICE);
+	if (!session) throw new Error("Doom Cordis session service is unavailable.");
+	return session;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function asHostQuery(value) {
+	if (!isRecord(value)) return void 0;
+	if (value.protocol !== HOST_PROTOCOL || value.abiVersion !== 1 || value.kind !== "query" || typeof value.requestId !== "string" || value.requestId.length === 0 || typeof value.source !== "string" || value.source.length === 0 || typeof value.accept !== "function") return;
+	return value;
+}
+function asHostResponder(value) {
+	if (!isRecord(value)) throw new Error("The Doom Cordis host returned an invalid discovery response.");
+	if (value.protocol !== HOST_PROTOCOL) throw new Error("The Doom Cordis host returned an invalid protocol identifier.");
+	if (value.abiVersion !== 1) throw new Error(`The Doom Cordis host ABI is incompatible: expected ${String(1)}, received ${String(value.abiVersion)}.`);
+	if (typeof value.hostId !== "string" || value.hostId.length === 0) throw new Error("The Doom Cordis host returned an invalid host identifier.");
+	if (!_deepseek_ai_cordis.Context.is(value.root)) throw new Error("The Doom Cordis host returned a value that is not a Cordis Context.");
+	if (!isRecord(value.runtime) || value.runtime.abiVersion !== 1 || value.runtime.hostId !== value.hostId || typeof value.acquire !== "function" || typeof value.shutdown !== "function" || !isRecord(value.ready) || typeof value.ready.then !== "function") throw new Error("The Doom Cordis host returned incomplete runtime metadata.");
+	return value;
+}
+function discoverHosts(pi, source) {
+	const responses = [];
+	const request = {
+		protocol: HOST_PROTOCOL,
+		abiVersion: 1,
+		kind: "query",
+		requestId: `${source}:${crypto.randomUUID()}`,
+		source,
+		accept(response) {
+			responses.push(asHostResponder(response));
+		}
+	};
+	pi.events.emit(DOOM_CORDIS_HOST_QUERY_CHANNEL, request);
+	return responses;
+}
+function exactlyOneHost(responses, source) {
+	if (responses.length <= 1) return responses[0];
+	const hostIds = responses.map(({ hostId }) => hostId).join(", ");
+	throw new Error(`Multiple Doom Cordis hosts answered ${source}: ${hostIds}.`);
+}
+function runtimeProvider(ctx, service) {
+	ctx.provide(DOOM_CORDIS_RUNTIME_SERVICE, service);
+	ctx.provide(require_toolOverrides.DOOM_TOOL_OVERRIDES_SERVICE, require_index$1.createDoomToolOverridesService(service.generation));
+}
+function sessionProvider(ctx, service, pi) {
+	ctx.provide(DOOM_CORDIS_SESSION_SERVICE, service);
+	ctx.provide(require_contextContributions.DOOM_CONTEXT_CONTRIBUTIONS_SERVICE, require_index.createDoomContextContributionsService(service.generation));
+	ctx.provide(require_toolSurface.DOOM_TOOL_SURFACE_SERVICE, require_index$2.createDoomToolSurface({
+		generation: service.generation,
+		allTools: () => pi.getAllTools().map((tool) => tool.name),
+		activeTools: () => pi.getActiveTools(),
+		setActiveTools: (names) => pi.setActiveTools(names)
+	}));
+}
+/**
+* Installs the sole Cordis application root for one Pi extension runner.
+*
+* The versioned EventBus query is intentional: Pi may hand independently
+* loaded factories different ExtensionAPI wrapper objects, while their event
+* buses still address the same runner.
+*/
+async function installDoomCordisHost(pi, options) {
+	const source = options.source ?? DEFAULT_HOST_SOURCE;
+	const existing = exactlyOneHost(discoverHosts(pi, source), source);
+	if (existing) throw new Error(`A Doom Cordis host is already installed: ${existing.hostId}.`);
+	const root = new _deepseek_ai_cordis.Context();
+	const runtime = Object.freeze({
+		abiVersion: 1,
+		hostId: `doom-cordis:${crypto.randomUUID()}`,
+		generation: `doom-runtime:${crypto.randomUUID()}`,
+		mode: options.mode
+	});
+	const ready = root.plugin(runtimeProvider, runtime).await().then(() => void 0);
+	let sessionFiber;
+	let sessionGeneration = 0;
+	let sessionQueue = Promise.resolve();
+	let leaseCount = 0;
+	let shutdownPromise;
+	let responder;
+	let disposeQuerySubscription = () => void 0;
+	const controller = {
+		root,
+		runtime,
+		shutdown() {
+			shutdownPromise ??= (async () => {
+				disposeQuerySubscription();
+				await ready.catch(() => void 0);
+				await sessionQueue.catch(() => void 0);
+				await sessionFiber?.dispose();
+				sessionFiber = void 0;
+				await root.fiber.dispose();
+			})();
+			return shutdownPromise;
+		}
+	};
+	responder = {
+		protocol: HOST_PROTOCOL,
+		abiVersion: 1,
+		hostId: runtime.hostId,
+		root,
+		runtime,
+		ready,
+		acquire() {
+			if (shutdownPromise) throw new Error(`The Doom Cordis host is shutting down: ${runtime.hostId}.`);
+			leaseCount += 1;
+			let released = false;
+			return {
+				root,
+				runtime,
+				async dispose() {
+					if (released) return;
+					released = true;
+					leaseCount -= 1;
+					if (options.mode === "standalone" && leaseCount === 0) await controller.shutdown();
+				}
+			};
+		},
+		shutdown: () => controller.shutdown()
+	};
+	try {
+		disposeQuerySubscription = pi.events.on(DOOM_CORDIS_HOST_QUERY_CHANNEL, (value) => {
+			const query = asHostQuery(value);
+			if (query) query.accept(responder);
+		});
+		pi.on("session_start", (event, context) => {
+			sessionQueue = sessionQueue.catch(() => void 0).then(async () => {
+				if (shutdownPromise) return;
+				await sessionFiber?.dispose();
+				sessionGeneration += 1;
+				const service = Object.freeze({
+					sessionId: context.sessionManager.getSessionId(),
+					generation: `${runtime.generation}:${String(sessionGeneration)}`,
+					reason: event.reason,
+					context
+				});
+				sessionFiber = root.plugin((ctx, value) => {
+					sessionProvider(ctx, value, pi);
+				}, service);
+				await sessionFiber.await();
+			});
+			return sessionQueue;
+		});
+		if (options.mode === "standalone") pi.on("session_shutdown", () => {
+			disposeQuerySubscription();
+		});
+		await ready;
+	} catch (error) {
+		await controller.shutdown();
+		throw error;
+	}
+	return controller;
+}
+/** Resolves the composed host installed by the canonical runtime. */
+async function connectDoomCordisHost(pi, source) {
+	const responder = exactlyOneHost(discoverHosts(pi, source), source);
+	if (!responder) throw new Error("The composed Doom Cordis host is unavailable. Ensure cordisHost is the first extension.");
+	await responder.ready;
+	return responder.acquire();
+}
+/** Ends the host discovered on this runner. Repeated finalization is a no-op. */
+async function finalizeDoomCordisHost(pi, source) {
+	await exactlyOneHost(discoverHosts(pi, source), source)?.shutdown();
+}
+//#endregion
+exports.DOOM_CORDIS_HOST_ABI_VERSION = DOOM_CORDIS_HOST_ABI_VERSION;
+exports.DOOM_CORDIS_HOST_QUERY_CHANNEL = DOOM_CORDIS_HOST_QUERY_CHANNEL;
+exports.DOOM_CORDIS_RUNTIME_SERVICE = DOOM_CORDIS_RUNTIME_SERVICE;
+exports.DOOM_CORDIS_SERVER_SERVICES = DOOM_CORDIS_SERVER_SERVICES;
+exports.DOOM_CORDIS_SESSION_SERVICE = DOOM_CORDIS_SESSION_SERVICE;
+exports.connectDoomCordisHost = connectDoomCordisHost;
+exports.finalizeDoomCordisHost = finalizeDoomCordisHost;
+exports.installDoomCordisHost = installDoomCordisHost;
+exports.requireDoomCordisSession = requireDoomCordisSession;
+
+//# sourceMappingURL=runtimeCordisHost.cjs.map