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

package/dist/apiContracts.mjs

@@ -0,0 +1,1989 @@
+import { Type } from "typebox";
+import { Check } from "typebox/value";
+import { PROTOCOL_VERSION } from "@earendil-works/pi-protocol";
+import { defineService } from "@earendil-works/chord";
+//#region src/schemas/apiContracts.ts
+const DOOM_API_CONTRACT_VERSION = 1;
+const DOOM_API_CONTRACT_FILE = "contracts.json";
+const Schema = Type.Unsafe(Type.Union([Type.Boolean(), Type.Record(Type.String(), Type.Unknown())]));
+const Scope = Type.Union([
+	Type.Literal("global"),
+	Type.Literal("workspace"),
+	Type.Literal("session")
+]);
+const Named = Type.String({ minLength: 1 });
+const ResponseSchema = Type.Object({
+	description: Named,
+	contentType: Type.Optional(Named),
+	schema: Type.Optional(Schema),
+	events: Type.Optional(Type.Record(Named, Schema))
+});
+/** Data-only package entry. Schemas use JSON Schema draft-07, including TypeBox output; OpenAPI export translates tuple keywords. */
+const DoomApiContractSchema = Type.Object({
+	version: Type.Literal(1),
+	protocols: Type.Optional(Type.Record(Named, Named)),
+	schemas: Type.Optional(Type.Record(Named, Schema)),
+	http: Type.Array(Type.Object({
+		id: Named,
+		scope: Scope,
+		/** Omit for host-owned absolute routes. */
+		basePath: Type.Optional(Type.String({ pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$" })),
+		path: Type.String({ pattern: "^/" }),
+		method: Type.Union([
+			Type.Literal("GET"),
+			Type.Literal("POST"),
+			Type.Literal("PUT"),
+			Type.Literal("PATCH"),
+			Type.Literal("DELETE"),
+			Type.Literal("HEAD"),
+			Type.Literal("OPTIONS")
+		]),
+		description: Named,
+		availability: Type.Optional(Named),
+		authentication: Type.Union([
+			Type.Literal("none"),
+			Type.Literal("owner"),
+			Type.Literal("device")
+		]),
+		parameters: Type.Optional(Type.Array(Type.Object({
+			name: Named,
+			in: Type.Union([
+				Type.Literal("path"),
+				Type.Literal("query"),
+				Type.Literal("header")
+			]),
+			required: Type.Boolean(),
+			schema: Schema
+		}))),
+		body: Type.Optional(Type.Object({
+			contentType: Named,
+			contentTypes: Type.Optional(Type.Array(Named, { minItems: 1 })),
+			required: Type.Boolean(),
+			schema: Schema
+		})),
+		responses: Type.Record(Type.String({ pattern: "^(?:[1-5][0-9]{2}|default)$" }), ResponseSchema, { minProperties: 1 })
+	})),
+	sockets: Type.Array(Type.Object({
+		id: Named,
+		scope: Scope,
+		description: Named,
+		availability: Type.Optional(Named),
+		service: Named,
+		member: Named,
+		direction: Type.Union([Type.Literal("client-to-server"), Type.Literal("server-to-client")]),
+		kind: Type.Union([
+			Type.Literal("method"),
+			Type.Literal("state"),
+			Type.Literal("channel")
+		]),
+		input: Schema,
+		output: Type.Optional(Schema),
+		errors: Type.Optional(Schema)
+	})),
+	/** Explicitly enumerate dynamic values whose shape is supplied at runtime. */
+	dynamic: Type.Array(Type.String({ minLength: 1 })),
+	gaps: Type.Optional(Type.Array(Named))
+});
+function defineApiContract(contract) {
+	return contract;
+}
+function parseApiContract(value) {
+	if (!Check(DoomApiContractSchema, value)) throw new Error("Invalid DoomPi API contract");
+	const contract = value;
+	const ids = /* @__PURE__ */ new Set();
+	for (const entry of [...contract.http, ...contract.sockets]) {
+		const key = `${entry.scope}:${entry.id}`;
+		if (ids.has(key)) throw new Error(`Duplicate API contract operation: ${key}`);
+		ids.add(key);
+	}
+	const visit = (item, ancestors) => {
+		if (item === null || typeof item === "string" || typeof item === "boolean") return;
+		if (typeof item === "number" && Number.isFinite(item)) return;
+		if (typeof item !== "object" || ancestors.has(item)) throw new Error("API contracts must contain finite JSON data");
+		ancestors.add(item);
+		for (const child of Object.values(item)) visit(child, ancestors);
+		ancestors.delete(item);
+	};
+	visit(contract, /* @__PURE__ */ new Set());
+	return contract;
+}
+function parseCompiledContracts(value) {
+	const PackageSchema = Type.Object({
+		packageName: Named,
+		packageVersion: Named,
+		scopes: Type.Array(Scope, { uniqueItems: true }),
+		owners: Type.Array(Type.Object({
+			majorMode: Named,
+			layer: Named
+		}), { minItems: 1 }),
+		contract: Type.Optional(DoomApiContractSchema),
+		problem: Type.Optional(Named),
+		module: Type.Optional(Type.String({ pattern: "^\\./[^\\\\%?#]+$" }))
+	});
+	const CompiledSchema = Type.Object({
+		version: Type.Literal(1),
+		generation: Named,
+		fingerprint: Type.String({ pattern: "^[a-f0-9]{64}$" }),
+		packages: Type.Array(PackageSchema)
+	});
+	if (!Check(CompiledSchema, value)) throw new Error("Invalid compiled API contracts");
+	const data = value;
+	const names = /* @__PURE__ */ new Set();
+	for (const entry of data.packages) {
+		if (names.has(entry.packageName) || entry.module?.split("/").includes("..")) throw new Error("Invalid compiled package contract");
+		names.add(entry.packageName);
+		if (entry.contract !== void 0) parseApiContract(entry.contract);
+	}
+	return data;
+}
+//#endregion
+//#region src/services/apiContracts/index.ts
+/** Stable bytes for diffs and hashes, independent of object insertion order. */
+function canonicalContractJson(value) {
+	const ordered = (item) => {
+		if (Array.isArray(item)) return item.map(ordered);
+		if (item !== null && typeof item === "object") return Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b, "en")).map(([key, child]) => [key, ordered(child)]));
+		return item;
+	};
+	return `${JSON.stringify(ordered(value), null, 2)}\n`;
+}
+const componentName = (value) => value.replace(/[^a-zA-Z0-9.-]/gu, (character) => `_${character.codePointAt(0).toString(16)}_`);
+const pluginPrefix = (scope) => scope === "global" ? "/api/plugins" : scope === "workspace" ? "/api/workspaces/{workspaceId}/plugins" : "/api/workspaces/{workspaceId}/sessions/{sessionId}/plugins";
+/** Compose declarations only. No handlers, lifecycle hooks, or platform resources are loaded. */
+function createApiDocuments(selections) {
+	const paths = {};
+	const schemas = {};
+	const messages = {};
+	const operations = {};
+	const channelMessages = {
+		global: {},
+		workspace: {},
+		session: {}
+	};
+	const manifest = {
+		version: 1,
+		complete: true,
+		protocols: {},
+		selections: [],
+		packages: [],
+		gaps: [],
+		dynamic: []
+	};
+	const socketAddresses = /* @__PURE__ */ new Set();
+	const schema = (id, value) => {
+		const name = componentName(id);
+		if (schemas[name] !== void 0) throw new Error(`Conflicting schema: ${id}`);
+		const relocate = (child) => {
+			if (Array.isArray(child)) return child.map(relocate);
+			if (child === null || typeof child !== "object") return child;
+			return Object.fromEntries(Object.entries(child).map(([key, entry]) => {
+				if (key === "$id") throw new Error(`Schema ${id} must use local references, not $id`);
+				if (key === "$ref" && typeof entry === "string") {
+					if (!entry.startsWith("#/")) throw new Error(`Unresolved schema reference in ${id}: ${entry}`);
+					return [key, `#/components/schemas/${name}${entry.slice(1)}`];
+				}
+				return [key, relocate(entry)];
+			}));
+		};
+		schemas[name] = relocate(value);
+		return { $ref: `#/components/schemas/${name}` };
+	};
+	for (const selected of [...selections].sort((a, b) => a.scope.localeCompare(b.scope))) {
+		manifest.selections.push({
+			scope: selected.scope,
+			majorMode: selected.majorMode,
+			activeLayers: [...selected.activeLayers].sort(),
+			generation: selected.compiled.generation,
+			fingerprint: selected.compiled.fingerprint
+		});
+		for (const entry of [...selected.compiled.packages].sort((a, b) => a.packageName.localeCompare(b.packageName))) {
+			if (!entry.scopes.includes(selected.scope) || !entry.owners.some((owner) => owner.majorMode === selected.majorMode && (owner.layer === "default" || selected.activeLayers.includes(owner.layer)))) continue;
+			manifest.packages.push({
+				name: entry.packageName,
+				version: entry.packageVersion,
+				scope: selected.scope
+			});
+			if (!entry.contract || entry.problem) {
+				manifest.gaps.push({
+					packageName: entry.packageName,
+					scope: selected.scope,
+					reason: entry.problem ?? "No contract declaration"
+				});
+				continue;
+			}
+			const contract = parseApiContract(entry.contract);
+			for (const [name, value] of Object.entries(contract.schemas ?? {})) schema(`${entry.packageName}.${selected.scope}.${name}`, value);
+			for (const [name, version] of Object.entries(contract.protocols ?? {})) {
+				if (manifest.protocols[name] !== void 0 && manifest.protocols[name] !== version) throw new Error(`Conflicting ${name} protocol versions`);
+				manifest.protocols[name] = version;
+			}
+			manifest.gaps.push(...(contract.gaps ?? []).map((reason) => ({
+				packageName: entry.packageName,
+				scope: selected.scope,
+				reason
+			})));
+			manifest.dynamic.push(...contract.dynamic.map((value) => `${entry.packageName}: ${value}`));
+			for (const route of contract.http.filter((route) => route.scope === selected.scope)) {
+				const id = `${entry.packageName}.${route.scope}.${route.id}`;
+				const pathname = `${route.basePath === void 0 ? "" : route.basePath === "settings" ? `${route.scope === "global" ? "/api" : "/api/workspaces/{workspaceId}"}/settings` : `${pluginPrefix(route.scope)}/${route.basePath}`}${route.path === "/" ? "" : route.path}`;
+				const method = route.method.toLowerCase();
+				const path = paths[pathname] ??= {};
+				if (path[method]) throw new Error(`Conflicting HTTP contract: ${route.method} ${pathname}`);
+				const parameters = (route.parameters ?? []).map((parameter) => ({
+					...parameter,
+					schema: schema(`${id}.${parameter.in}.${parameter.name}`, parameter.schema)
+				}));
+				for (const match of pathname.matchAll(/\{([^}]+)\}/gu)) if (!parameters.some((parameter) => parameter.in === "path" && parameter.name === match[1])) parameters.push({
+					name: match[1],
+					in: "path",
+					required: true,
+					schema: schema(`${id}.path.${match[1]}`, {
+						type: "string",
+						minLength: 1
+					})
+				});
+				path[method] = {
+					operationId: componentName(id),
+					description: route.description,
+					parameters,
+					security: route.authentication === "none" ? [] : [{ [route.authentication]: [] }],
+					"x-doompi": {
+						packageName: entry.packageName,
+						scope: route.scope,
+						...route.availability ? { availability: route.availability } : {}
+					},
+					...route.body ? { requestBody: {
+						required: route.body.required,
+						content: Object.fromEntries((route.body.contentTypes ?? [route.body.contentType]).map((mediaType) => [mediaType, { schema: schema(`${id}.body.${mediaType}`, route.body.schema) }]))
+					} } : {},
+					responses: Object.fromEntries(Object.entries(route.responses).map(([status, response]) => [status, {
+						description: response.description,
+						...response.events ? { "x-sse-events": Object.fromEntries(Object.entries(response.events).map(([name, payload]) => [name, schema(`${id}.event.${name}`, payload)])) } : {},
+						...response.schema === void 0 ? {} : { content: { [response.contentType ?? "application/json"]: { schema: schema(`${id}.response.${status}`, response.schema) } } }
+					}]))
+				};
+			}
+			for (const socket of contract.sockets.filter((socket) => socket.scope === selected.scope)) {
+				const address = `${socket.scope}:${socket.direction}:${socket.kind}:${socket.service}:${socket.member}`;
+				if (socketAddresses.has(address)) throw new Error(`Conflicting socket contract: ${address}`);
+				socketAddresses.add(address);
+				for (const channel of socket.scope === "global" ? ["global"] : [socket.scope, "global"]) {
+					const id = componentName(`${entry.packageName}.${socket.scope}.${socket.id}${channel === socket.scope ? "" : ".aggregate"}`);
+					const addMessage = (suffix, payload) => {
+						const name = `${id}.${suffix}`;
+						messages[name] = {
+							name,
+							payload: schema(name, payload)
+						};
+						channelMessages[channel][name] = { $ref: `#/components/messages/${name}` };
+						return `#/channels/${channel}/messages/${name}`;
+					};
+					const request = addMessage("input", socket.input);
+					const replies = socket.output === void 0 ? [] : [{ $ref: addMessage("output", socket.output) }];
+					if (socket.errors !== void 0) replies.push({ $ref: addMessage("error", socket.errors) });
+					operations[id] = {
+						action: socket.direction === "client-to-server" ? "receive" : "send",
+						channel: { $ref: `#/channels/${channel}` },
+						messages: [{ $ref: request }],
+						description: socket.description,
+						...replies.length ? { reply: {
+							channel: { $ref: `#/channels/${channel}` },
+							messages: replies
+						} } : {},
+						"x-doompi": {
+							service: socket.service,
+							member: socket.member,
+							scope: socket.scope,
+							kind: socket.kind,
+							transportScope: channel,
+							...socket.availability ? { availability: socket.availability } : {}
+						}
+					};
+				}
+			}
+		}
+	}
+	manifest.complete = manifest.gaps.length === 0;
+	manifest.dynamic = [...new Set(manifest.dynamic)].sort();
+	const info = {
+		title: "DoomPi compiled client API",
+		version: "1"
+	};
+	const openapi = {
+		openapi: "3.1.1",
+		info,
+		paths,
+		components: {
+			schemas: openApiSchemas(schemas),
+			securitySchemes: {
+				owner: {
+					type: "apiKey",
+					in: "header",
+					name: "x-doompi-token"
+				},
+				device: {
+					type: "apiKey",
+					in: "cookie",
+					name: "__Host-doompi_device",
+					description: "Admitted device credentials and purpose-bound sealed channel; see remote authentication operations."
+				}
+			}
+		}
+	};
+	const asyncapi = {
+		asyncapi: "3.0.0",
+		info,
+		channels: Object.fromEntries(Object.entries(channelMessages).map(([scope, messages]) => [scope, {
+			address: scope === "global" ? "/api/ws" : scope === "workspace" ? "/api/workspaces/{workspaceId}/ws" : "/api/workspaces/{workspaceId}/sessions/{sessionId}/ws",
+			...scope === "global" ? {} : { parameters: {
+				workspaceId: { description: "Admitted workspace identity." },
+				...scope === "session" ? { sessionId: { description: "Session owned by this workspace." } } : {}
+			} },
+			messages,
+			description: "Decoded Pi/Chord values over framed CBOR. The global hub socket aggregates all scopes; workspace and session sockets restrict session access and package calls to their addressed scope. Remote paired-device sockets seal the same bytes."
+		}])),
+		operations,
+		components: {
+			schemas: asyncApiSchemas(schemas),
+			messages
+		}
+	};
+	for (const document of [openapi, asyncapi]) {
+		const visit = (value) => {
+			if (value === null || typeof value !== "object") return;
+			for (const [key, child] of Object.entries(value)) if (key === "$ref" && typeof child === "string") {
+				let target = document;
+				for (const segment of child.slice(2).split("/")) {
+					if (target === null || typeof target !== "object") throw new Error(`Unresolved API reference: ${child}`);
+					target = Reflect.get(target, segment.replace(/~1/gu, "/").replace(/~0/gu, "~"));
+				}
+				if (target === void 0) throw new Error(`Unresolved API reference: ${child}`);
+			} else visit(child);
+		};
+		visit(document);
+	}
+	return {
+		openapi,
+		asyncapi,
+		manifest
+	};
+}
+/** TypeBox uses draft-07 tuple keywords; OpenAPI 3.1 evaluates the 2020-12 vocabulary. */
+function openApiSchemas(value) {
+	if (Array.isArray(value)) return value.map(openApiSchemas);
+	if (value === null || typeof value !== "object") return value;
+	const source = value;
+	const result = {};
+	for (const [key, child] of Object.entries(source)) if (key === "items" && Array.isArray(child)) {
+		if (child.length) result.prefixItems = child.map(openApiSchemas);
+		else {
+			result.items = false;
+			result.maxItems = 0;
+		}
+	} else if (key === "additionalItems" && Array.isArray(source.items)) result.items = openApiSchemas(child);
+	else if (key === "dependencies" && child !== null && typeof child === "object") {
+		const required = {};
+		const schemas = {};
+		for (const [name, dependency] of Object.entries(child)) if (Array.isArray(dependency)) required[name] = dependency;
+		else schemas[name] = openApiSchemas(dependency);
+		if (Object.keys(required).length) result.dependentRequired = required;
+		if (Object.keys(schemas).length) result.dependentSchemas = schemas;
+	} else if (key === "$schema") result.$schema = "https://json-schema.org/draft/2020-12/schema";
+	else result[key] = openApiSchemas(child);
+	return result;
+}
+function asyncApiSchemas(schemas) {
+	const convert = (value) => {
+		if (Array.isArray(value)) return value.map(convert);
+		if (value === null || typeof value !== "object") return value;
+		const result = {};
+		for (const [key, child] of Object.entries(value)) if (key === "$ref" && typeof child === "string") result[key] = child.replace(/^(#\/components\/schemas\/[^/]+)(.*)$/u, "$1/schema$2");
+		else if (key === "items" && Array.isArray(child) && child.length === 0) {
+			result.items = false;
+			result.maxItems = 0;
+		} else result[key] = convert(child);
+		return result;
+	};
+	return Object.fromEntries(Object.entries(schemas).map(([name, schema]) => [name, {
+		schemaFormat: "application/schema+json;version=draft-07",
+		schema: convert(schema)
+	}]));
+}
+//#endregion
+//#region src/constants/contextApi.ts
+/**
+* What one entry in the composition actually is, for a reader who clicked it.
+*
+* The projection prices the composition and stops there: names, owners, and
+* integer counts, small enough to republish whenever the composition changes.
+* The prose and the schema behind a figure are an order of magnitude larger and
+* are wanted one row at a time, so they travel on request instead. This module
+* is the contract both ends of that request share, and it is deliberately free
+* of Node imports so a browser can hold it too.
+*/
+/** Where a host mounts this package's API; the segment after /api/plugins/. */
+const API_BASE_PATH = "context";
+const ITEM_ROUTE = "/item";
+//#endregion
+//#region src/schemas/httpApiContracts.ts
+const Text$2 = Type.String();
+const Optional$2 = Type.Optional;
+const Strings$1 = Type.Array(Text$2);
+const Flag$2 = Type.Boolean();
+const NumberValue$2 = Type.Number();
+const ApiErrorSchema = Type.Object({
+	error: Text$2,
+	hash: Optional$2(Text$2)
+});
+const ApiOkSchema = Type.Object({ ok: Type.Literal(true) });
+const Json$2 = Type.Unknown({ description: "Value whose schema is supplied by the selected runtime contribution." });
+/** Common JSON response construction; status and payload remain explicit at the declaration. */
+function jsonApiResponses(schema, status = 200) {
+	return {
+		[status]: {
+			description: "Successful response",
+			contentType: "application/json",
+			schema
+		},
+		"400": {
+			description: "Invalid request",
+			schema: ApiErrorSchema
+		},
+		"401": {
+			description: "Authentication required",
+			schema: ApiErrorSchema
+		},
+		"403": {
+			description: "Request is not authorized",
+			schema: ApiErrorSchema
+		},
+		"404": {
+			description: "Resource or capability unavailable",
+			schema: ApiErrorSchema
+		},
+		"409": {
+			description: "Conflicting state",
+			schema: ApiErrorSchema
+		},
+		"422": {
+			description: "Invalid operation",
+			schema: ApiErrorSchema
+		},
+		"500": {
+			description: "Host operation failed",
+			schema: ApiErrorSchema
+		},
+		"502": {
+			description: "Provider failed",
+			schema: ApiErrorSchema
+		},
+		"503": {
+			description: "Service unavailable",
+			schema: ApiErrorSchema
+		}
+	};
+}
+const WebCompositionSchema = Type.Object({
+	id: Text$2,
+	scope: Type.Union([
+		Type.Literal("global"),
+		Type.Literal("workspace"),
+		Type.Literal("session")
+	]),
+	revision: NumberValue$2,
+	manifestUrl: Text$2,
+	rawAssetBaseUrl: Text$2,
+	verifiedAssetBaseUrl: Text$2,
+	entryPath: Text$2,
+	stylePaths: Strings$1,
+	channels: Strings$1
+});
+const SessionSummarySchema = Type.Object({
+	id: Text$2,
+	workspaceId: Optional$2(Text$2),
+	webComposition: Optional$2(WebCompositionSchema),
+	name: Text$2,
+	cwd: Text$2,
+	createdAt: Text$2,
+	updatedAt: Text$2,
+	phase: Type.Union([
+		Type.Literal("idle"),
+		Type.Literal("turn"),
+		Type.Literal("compaction"),
+		Type.Literal("retry")
+	]),
+	phaseSince: Text$2,
+	attach: Type.Literal("attached"),
+	pendingMessageCount: NumberValue$2,
+	everPrompted: Flag$2,
+	awaitingInput: Flag$2,
+	lastSettledAt: Optional$2(Text$2),
+	git: Optional$2(Type.Object({
+		branch: Text$2,
+		dirty: Flag$2
+	})),
+	profile: Optional$2(Type.Object({
+		name: Text$2,
+		displayName: Optional$2(Text$2),
+		iconVersion: Optional$2(Text$2)
+	})),
+	parentSessionId: Optional$2(Text$2),
+	sessionProvenance: Optional$2(Text$2),
+	pendingSetups: Optional$2(Type.Array(Type.Object({
+		id: Text$2,
+		name: Text$2,
+		createdAt: Text$2,
+		cwd: Optional$2(Text$2),
+		setupKind: Optional$2(Type.Union([Type.Literal("managed-worktree"), Type.Literal("existing-directory")])),
+		status: Optional$2(Type.Union([
+			Type.Literal("provisioning"),
+			Type.Literal("failed"),
+			Type.Literal("interrupted")
+		])),
+		errorCode: Optional$2(Type.Union([Type.Literal("SESSION_WORKTREE_PROVISION_FAILED"), Type.Literal("SESSION_UNAVAILABLE")]))
+	}))),
+	/** Present and true for a recorded session the server has not reopened yet. */
+	dormant: Optional$2(Flag$2)
+});
+const HubSnapshotFrameSchema = Type.Object({
+	type: Type.Literal("sessions_snapshot"),
+	sessions: Type.Array(SessionSummarySchema)
+});
+const HubUpsertFrameSchema = Type.Object({
+	type: Type.Literal("session_upsert"),
+	session: SessionSummarySchema
+});
+const HubRemovedFrameSchema = Type.Object({
+	type: Type.Literal("session_removed"),
+	sessionId: Text$2
+});
+const Workspace = Type.Object({
+	id: Text$2,
+	root: Text$2,
+	name: Optional$2(Text$2),
+	available: Optional$2(Flag$2)
+});
+const WorkspaceSnapshotFrameSchema = Type.Object({
+	type: Type.Literal("workspaces_snapshot"),
+	workspaces: Type.Array(Workspace)
+});
+const WorkspaceUpsertFrameSchema = Type.Object({
+	type: Type.Literal("workspace_upsert"),
+	workspace: Workspace
+});
+const WorkspaceRemovedFrameSchema = Type.Object({
+	type: Type.Literal("workspace_removed"),
+	workspaceId: Text$2
+});
+const SavedSession = Type.Object({
+	id: Text$2,
+	name: Optional$2(Text$2),
+	firstMessage: Text$2,
+	createdAt: Text$2,
+	updatedAt: Text$2,
+	messageCount: NumberValue$2
+});
+const query = (name, schema = Text$2, required = false) => ({
+	name,
+	in: "query",
+	required,
+	schema
+});
+const body = (schema) => ({
+	contentType: "application/json",
+	required: true,
+	schema
+});
+const host = (id, path, method, result, extra = {}) => ({
+	id,
+	path,
+	method,
+	scope: "global",
+	authentication: "owner",
+	description: id,
+	responses: jsonApiResponses(result),
+	...extra
+});
+const Binary = Type.String({ contentEncoding: "binary" });
+const headlessHttpContracts = [
+	host("health", "/api/health", "GET", Type.Object({
+		ok: Type.Literal(true),
+		role: Type.Literal("hub"),
+		protocol: Type.Literal(1),
+		sessions: NumberValue$2
+	}), { authentication: "none" }),
+	host("telemetry.browser", "/api/telemetry/browser", "POST", ApiOkSchema, { body: body(Type.Object({
+		v: Type.Literal(1),
+		events: Type.Array(Type.Object({
+			name: Type.String({ pattern: "^web\\.browser\\.[a-z_]{1,40}$" }),
+			duration_ms: Optional$2(NumberValue$2),
+			count: Optional$2(NumberValue$2)
+		}), { maxItems: 10 })
+	})) }),
+	host("compositions", "/api/compositions", "GET", Type.Object({
+		global: Optional$2(WebCompositionSchema),
+		publicKey: Optional$2(Text$2),
+		shell: Optional$2(Type.Object({
+			publicKey: Text$2,
+			revision: NumberValue$2
+		})),
+		workspaces: Type.Array(Type.Object({
+			id: Text$2,
+			root: Text$2,
+			webComposition: Optional$2(WebCompositionSchema)
+		}))
+	})),
+	host("directories", "/api/directories", "GET", Type.Object({ directories: Strings$1 }), { parameters: [query("q")] }),
+	host("directories.children", "/api/directories/children", "GET", Type.Object({
+		path: Text$2,
+		parent: Optional$2(Text$2),
+		directories: Strings$1
+	}), { parameters: [query("path")] }),
+	host("sessions.list", "/api/workspaces/{workspaceId}/sessions", "GET", Type.Object({ sessions: Type.Array(SessionSummarySchema) })),
+	host("sessions.create", "/api/workspaces/{workspaceId}/sessions", "POST", Type.Object({ sessionId: Text$2 }), {
+		body: body(Type.Object({ name: Optional$2(Text$2) })),
+		responses: jsonApiResponses(Type.Object({ sessionId: Text$2 }), 201)
+	}),
+	host("sessions.get", "/api/workspaces/{workspaceId}/sessions/{sessionId}", "GET", SessionSummarySchema),
+	host("sessions.delete", "/api/workspaces/{workspaceId}/sessions/{sessionId}", "DELETE", ApiOkSchema),
+	host("sessions.history", "/api/workspaces/{workspaceId}/sessions/{sessionId}/history", "GET", Type.Object({ sessions: Type.Array(SavedSession) }), { availability: "Host provides sessionHistory" }),
+	host("sessions.restart", "/api/workspaces/{workspaceId}/sessions/{sessionId}/restart", "POST", ApiOkSchema, { availability: "Host provides restartSession" }),
+	host("sessions.revive", "/api/workspaces/{workspaceId}/sessions/{sessionId}/revive", "POST", ApiOkSchema, { availability: "Host provides reviveSession" }),
+	host("sessions.resume", "/api/workspaces/{workspaceId}/sessions/{sessionId}/resume", "POST", Type.Object({ sessionId: Text$2 }), {
+		availability: "Host provides resumeSession",
+		body: body(Type.Object({ targetSessionId: Type.String({ pattern: "^[A-Za-z0-9_-]+$" }) }))
+	}),
+	host("sessions.file", "/api/workspaces/{workspaceId}/sessions/{sessionId}/file", "GET", Binary, {
+		parameters: [query("path", Text$2, true)],
+		responses: {
+			...jsonApiResponses(Binary),
+			"200": {
+				description: "File bytes, MIME type follows the file extension",
+				contentType: "*/*",
+				schema: Binary
+			}
+		}
+	}),
+	host("sessions.channels", "/api/workspaces/{workspaceId}/sessions/{sessionId}/channels", "GET", Type.Object({ channels: Type.Array(Type.Object({
+		type: Text$2,
+		sessionId: Text$2,
+		payload: Json$2
+	})) })),
+	host("sessions.channel.send", "/api/workspaces/{workspaceId}/sessions/{sessionId}/channel/{frameType}", "POST", ApiOkSchema, {
+		body: body(Json$2),
+		responses: jsonApiResponses(ApiOkSchema, 202),
+		description: "Deliver a payload to the selected channel contract identified by frameType."
+	}),
+	host("workspaces.list", "/api/workspaces", "GET", Type.Object({ workspaces: Type.Array(Workspace) })),
+	host("workspaces.admit", "/api/workspaces", "POST", Type.Object({ workspace: Workspace }), {
+		body: body(Type.Object({
+			root: Optional$2(Text$2),
+			name: Optional$2(Text$2)
+		})),
+		responses: jsonApiResponses(Type.Object({ workspace: Workspace }), 201)
+	}),
+	host("workspaces.get", "/api/workspaces/{workspaceId}", "GET", Type.Object({ workspace: Workspace })),
+	host("workspaces.history", "/api/workspaces/{workspaceId}/history", "GET", Type.Object({ sessions: Type.Array(SavedSession) }), { availability: "Host provides workspaceHistory" }),
+	host("workspaces.resume", "/api/workspaces/{workspaceId}/resume", "POST", Type.Object({ sessionId: Text$2 }), {
+		availability: "Host provides resumeWorkspaceSession",
+		body: body(Type.Object({ targetSessionId: Type.String({ pattern: "^[A-Za-z0-9_-]+$" }) }))
+	}),
+	host("workspaces.remove", "/api/workspaces/{workspaceId}", "DELETE", ApiOkSchema),
+	host("events", "/api/events", "GET", Text$2, { responses: {
+		"200": {
+			description: "SSE session and workspace snapshots, membership changes, and selected channel frames. Selected extension channel payloads are defined by the corresponding AsyncAPI channel operations.",
+			events: {
+				sessions_snapshot: HubSnapshotFrameSchema,
+				session_upsert: HubUpsertFrameSchema,
+				session_removed: HubRemovedFrameSchema,
+				workspaces_snapshot: WorkspaceSnapshotFrameSchema,
+				workspace_upsert: WorkspaceUpsertFrameSchema,
+				workspace_removed: WorkspaceRemovedFrameSchema
+			},
+			contentType: "text/event-stream",
+			schema: Text$2
+		},
+		"401": {
+			description: "Authentication required",
+			schema: ApiErrorSchema
+		}
+	} })
+];
+const AuthType = Type.Union([Type.Literal("api_key"), Type.Literal("oauth")]);
+const Provider = Type.Object({
+	id: Text$2,
+	name: Text$2,
+	methods: Type.Array(Type.Object({
+		type: AuthType,
+		label: Text$2
+	})),
+	authenticated: Optional$2(Type.Object({
+		type: AuthType,
+		source: Optional$2(Text$2)
+	}))
+});
+const LoginEvent = Type.Union([
+	Type.Object({
+		type: Type.Literal("info"),
+		message: Text$2,
+		links: Optional$2(Type.Array(Type.Object({
+			url: Text$2,
+			label: Optional$2(Text$2)
+		})))
+	}),
+	Type.Object({
+		type: Type.Literal("auth_url"),
+		url: Text$2,
+		instructions: Optional$2(Text$2)
+	}),
+	Type.Object({
+		type: Type.Literal("device_code"),
+		userCode: Text$2,
+		verificationUri: Text$2,
+		intervalSeconds: Optional$2(NumberValue$2),
+		expiresInSeconds: Optional$2(NumberValue$2)
+	}),
+	Type.Object({
+		type: Type.Literal("progress"),
+		message: Text$2
+	})
+]);
+const LoginFlowSchema = Type.Object({
+	id: Text$2,
+	providerId: Text$2,
+	providerName: Text$2,
+	type: AuthType,
+	status: Type.Union([
+		Type.Literal("running"),
+		Type.Literal("succeeded"),
+		Type.Literal("failed"),
+		Type.Literal("cancelled")
+	]),
+	events: Type.Array(LoginEvent),
+	prompt: Optional$2(Type.Object({
+		id: Text$2,
+		type: Type.Union([
+			Type.Literal("text"),
+			Type.Literal("secret"),
+			Type.Literal("select"),
+			Type.Literal("manual_code")
+		]),
+		message: Text$2,
+		placeholder: Optional$2(Text$2),
+		options: Optional$2(Type.Array(Type.Object({
+			id: Text$2,
+			label: Text$2,
+			description: Optional$2(Text$2)
+		})))
+	})),
+	remote: Optional$2(Flag$2),
+	error: Optional$2(Text$2)
+});
+const Flow = Type.Object({ flow: LoginFlowSchema });
+const machineHttpContracts = [
+	host("providers.list", "/providers", "GET", Type.Object({ providers: Type.Array(Provider) })),
+	host("models.list", "/models", "GET", Type.Object({ models: Type.Array(Type.Object({
+		value: Text$2,
+		label: Text$2,
+		group: Text$2
+	})) })),
+	host("providers.logout", "/providers/{providerId}", "DELETE", ApiOkSchema),
+	host("logins.create", "/logins", "POST", Flow, {
+		body: body(Type.Object({
+			providerId: Text$2,
+			type: AuthType
+		})),
+		responses: jsonApiResponses(Flow, 201)
+	}),
+	host("logins.get", "/logins/{flowId}", "GET", Flow),
+	host("logins.cancel", "/logins/{flowId}", "DELETE", Flow),
+	host("logins.answer", "/logins/{flowId}/answer", "POST", Flow, { body: body(Type.Object({
+		promptId: Text$2,
+		value: Text$2
+	})) })
+].map((route) => ({
+	...route,
+	basePath: "doompi"
+}));
+const Source = Type.Union([
+	Type.Literal("extension"),
+	Type.Literal("mcp"),
+	Type.Literal("plugin"),
+	Type.Literal("core")
+]);
+const Detail = Type.Union([
+	Type.Object({
+		itemKind: Type.Literal("tool"),
+		name: Text$2,
+		owner: Text$2,
+		source: Source,
+		active: Flag$2,
+		tokens: Type.Object({
+			schemaTokens: NumberValue$2,
+			promptTokens: NumberValue$2,
+			totalTokens: NumberValue$2
+		}),
+		description: Optional$2(Text$2),
+		promptSnippet: Optional$2(Text$2),
+		promptGuidelines: Optional$2(Strings$1),
+		parameters: Optional$2(Json$2)
+	}),
+	Type.Object({
+		itemKind: Type.Literal("skill"),
+		name: Text$2,
+		owner: Text$2,
+		source: Source,
+		active: Type.Literal(true),
+		tokens: NumberValue$2,
+		description: Text$2,
+		filePath: Optional$2(Text$2),
+		modelInvocable: Flag$2
+	}),
+	Type.Object({
+		itemKind: Type.Literal("prompt"),
+		name: Type.Literal("system"),
+		tokens: NumberValue$2,
+		stage: Type.Union([Type.Literal("base"), Type.Literal("effective")]),
+		text: Text$2
+	})
+]);
+const sessionHttpContracts = [{
+	...host("context.item", ITEM_ROUTE, "GET", Type.Object({
+		revision: NumberValue$2,
+		item: Detail
+	}), { parameters: [query("kind", Type.Union([
+		Type.Literal("tool"),
+		Type.Literal("skill"),
+		Type.Literal("prompt")
+	]), true), query("name", Text$2, true)] }),
+	scope: "session",
+	basePath: API_BASE_PATH
+}, {
+	...host("files.complete", "/", "GET", Type.Object({ files: Strings$1 }), { parameters: [query("q", Type.String({ maxLength: 256 }))] }),
+	scope: "session",
+	basePath: "files"
+}];
+//#endregion
+//#region src/schemas/remoteApiContracts.ts
+const Text$1 = Type.String();
+const NumberValue$1 = Type.Number();
+const Optional$1 = Type.Optional;
+const Flag$1 = Type.Boolean();
+const JsonObject = Type.Record(Text$1, Type.Unknown({ description: "WebAuthn ceremony fields supplied and verified by the installed WebAuthn implementation." }));
+const Tunnel = Type.Union([Type.Object({ kind: Type.Literal("quick") }), Type.Object({
+	kind: Type.Literal("named"),
+	hostname: Text$1,
+	name: Optional$1(Text$1),
+	tokenFile: Optional$1(Text$1),
+	configFile: Optional$1(Text$1)
+})]);
+const Settings = Type.Object({
+	autoCloseEnabled: Flag$1,
+	autoCloseMinutes: NumberValue$1,
+	sessionExpiryEnabled: Flag$1,
+	idleMinutes: NumberValue$1,
+	absoluteHours: NumberValue$1,
+	tunnel: Tunnel,
+	sandbox: Type.Object({
+		enabled: Flag$1,
+		workspaces: Type.Array(Text$1)
+	})
+});
+const State = Type.Object({
+	status: Type.Union([
+		Type.Literal("off"),
+		Type.Literal("starting"),
+		Type.Literal("on"),
+		Type.Literal("failed")
+	]),
+	publicUrl: Optional$1(Text$1),
+	startedAt: Optional$1(Text$1),
+	closesAt: Optional$1(Text$1),
+	error: Optional$1(Text$1),
+	devices: Type.Array(Type.Object({
+		id: Text$1,
+		label: Text$1,
+		userAgent: Text$1,
+		createdAt: Text$1,
+		lastSeenAt: Text$1,
+		self: Flag$1
+	})),
+	pending: Type.Array(Type.Object({
+		id: Text$1,
+		userAgent: Text$1,
+		edgeIp: Text$1,
+		createdAt: Text$1,
+		expiresAt: Text$1
+	})),
+	settings: Settings
+});
+const StateResponse = Type.Object({
+	state: State,
+	handingOver: Optional$1(Flag$1)
+});
+const Trust = Type.Object({
+	publicKey: Text$1,
+	fingerprint: Text$1,
+	revision: NumberValue$1
+});
+const Begun = Type.Object({
+	ceremonyId: Text$1,
+	options: JsonObject
+});
+const Finish = Type.Object({
+	ceremonyId: Text$1,
+	response: JsonObject
+});
+const SealedEnvelopeSchema = Type.Object({
+	v: Type.Literal(1),
+	n: Text$1,
+	c: Text$1
+});
+const SealedHttpRequestSchema = Type.Object({
+	v: Type.Literal(1),
+	method: Text$1,
+	target: Text$1,
+	headers: Type.Array(Type.Tuple([Text$1, Text$1])),
+	body: Optional$1(Text$1)
+});
+const SealedHttpResponseSchema = Type.Object({
+	v: Type.Literal(1),
+	status: NumberValue$1,
+	headers: Type.Array(Type.Tuple([Text$1, Text$1])),
+	body: Text$1
+});
+const route = (id, path, method, result, input, extra = {}) => ({
+	id: `remote.${id}`,
+	path: `/api/remote${path}`,
+	method,
+	scope: "global",
+	authentication: "owner",
+	description: `Remote Control ${id}.`,
+	availability: "Global host provides Remote Control. Tunnel routes additionally enforce device, origin and step-up policy.",
+	responses: {
+		...jsonApiResponses(result),
+		"429": {
+			description: "Rate limit exceeded",
+			schema: ApiErrorSchema
+		}
+	},
+	...input ? { body: {
+		contentType: "application/json",
+		required: true,
+		schema: input
+	} } : {},
+	...extra
+});
+const direct = [
+	route("state", "", "GET", StateResponse),
+	route("enable", "/enable", "POST", StateResponse, void 0, { responses: {
+		...jsonApiResponses(StateResponse),
+		"202": {
+			description: "Container handover started",
+			schema: StateResponse
+		}
+	} }),
+	route("disable", "/disable", "POST", StateResponse, void 0, { responses: {
+		...jsonApiResponses(StateResponse),
+		"202": {
+			description: "Tunnel closing",
+			schema: Type.Object({ status: Type.Literal("closing") })
+		}
+	} }),
+	route("codes", "/codes", "POST", Type.Object({
+		...Trust.properties,
+		code: Text$1,
+		manualCode: Text$1,
+		pairUrl: Text$1,
+		expiresAt: Text$1
+	}), void 0, { responses: jsonApiResponses(Type.Object({
+		...Trust.properties,
+		code: Text$1,
+		manualCode: Text$1,
+		pairUrl: Text$1,
+		expiresAt: Text$1
+	}), 201) }),
+	route("approve", "/pairing/{id}/approve", "POST", StateResponse),
+	route("deny", "/pairing/{id}/deny", "POST", StateResponse),
+	route("revoke", "/devices/{id}", "DELETE", StateResponse),
+	route("settings", "/settings", "PUT", Type.Object({ settings: Settings }), Type.Partial(Settings)),
+	route("passkeys", "/passkeys", "GET", Type.Object({
+		support: Type.Union([Type.Object({
+			supported: Type.Literal(true),
+			rpId: Text$1
+		}), Type.Object({
+			supported: Type.Literal(false),
+			reason: Text$1
+		})]),
+		credentials: Type.Array(Type.Object({
+			id: Text$1,
+			label: Text$1,
+			createdAt: Text$1,
+			lastUsedAt: Text$1
+		}))
+	})),
+	route("passkeys.remove", "/passkeys/{id}", "DELETE", ApiOkSchema),
+	route("register.begin", "/passkeys/register/begin", "POST", Begun, void 0, { authentication: "device" }),
+	route("register.finish", "/passkeys/register/finish", "POST", Type.Object({ id: Text$1 }), Finish, { authentication: "device" }),
+	route("authenticate.begin", "/passkeys/authenticate/begin", "POST", Begun, void 0, { authentication: "none" }),
+	route("authenticate.finish", "/passkeys/authenticate/finish", "POST", Type.Object({
+		ok: Type.Literal(true),
+		hostPublicKey: Text$1
+	}), Finish, { authentication: "none" }),
+	route("challenge", "/challenge", "POST", Begun, Type.Object({ action: Text$1 }), { authentication: "device" }),
+	route("channel", "/channel", "POST", ApiOkSchema, Type.Object({
+		clientPublicKey: Text$1,
+		scope: Type.Union([
+			Type.Literal("session"),
+			Type.Literal("protocol"),
+			Type.Literal("http")
+		])
+	}), { authentication: "device" }),
+	route("request", "/request", "POST", SealedEnvelopeSchema, SealedEnvelopeSchema, {
+		authentication: "device",
+		description: "Sealed HTTP gateway. Decrypted requests/responses use the SealedHttpRequest and SealedHttpResponse envelopes."
+	}),
+	route("pair", "/pair", "POST", Type.Object({
+		requestId: Text$1,
+		status: Type.Literal("pending")
+	}), Type.Object({ code: Type.String({ minLength: 1 }) }), {
+		authentication: "none",
+		responses: {
+			...jsonApiResponses(Type.Object({
+				requestId: Text$1,
+				status: Type.Literal("pending")
+			}), 202),
+			"410": {
+				description: "Pairing code is no longer valid",
+				schema: ApiErrorSchema
+			}
+		}
+	}),
+	route("pair.status", "/pair/status", "GET", Type.Object({
+		status: Type.Union([
+			Type.Literal("pending"),
+			Type.Literal("approved"),
+			Type.Literal("denied"),
+			Type.Literal("expired"),
+			Type.Literal("consumed")
+		]),
+		bundleTrust: Optional$1(Trust),
+		hostPublicKey: Optional$1(Text$1)
+	}), void 0, {
+		authentication: "none",
+		parameters: [{
+			name: "request",
+			in: "query",
+			required: true,
+			schema: Text$1
+		}]
+	})
+];
+const remoteHttpContracts = [
+	route("frontend", "/frontend", "POST", ApiOkSchema, Type.Object({ origin: Text$1 }), {
+		authentication: "owner",
+		availability: "Internal loopback frontend registration; blocked by the browser proxy.",
+		parameters: [{
+			name: "x-doompi-web-registration",
+			in: "header",
+			required: true,
+			schema: Text$1
+		}]
+	}),
+	...direct,
+	...direct.map((operation) => ({
+		...operation,
+		id: `${operation.id}.plugin`,
+		basePath: "remote",
+		path: operation.path.slice(11) || "/",
+		authentication: "owner",
+		availability: "Global Remote Control plugin mount, reached through the authenticated headless listener."
+	})),
+	{
+		id: "remote.pair.page",
+		scope: "global",
+		path: "/pair",
+		method: "GET",
+		authentication: "none",
+		availability: "Remote listener only",
+		description: "Pairing and passkey bootstrap page.",
+		responses: { "200": {
+			description: "Pairing page",
+			contentType: "text/html",
+			schema: Text$1
+		} }
+	}
+];
+const Asset = Type.Object({
+	path: Text$1,
+	sha256: Type.String({ pattern: "^[a-f0-9]{64}$" }),
+	byteLength: Type.Integer({ minimum: 0 }),
+	contentType: Text$1
+});
+const Signed = Type.Object({
+	manifest: Type.Object({
+		version: Type.Literal(2),
+		revision: Type.Integer({ minimum: 1 }),
+		builtAt: NumberValue$1,
+		assets: Type.Array(Asset)
+	}),
+	signature: Text$1,
+	publicKey: Text$1
+});
+const bundleHttpContracts = [...["/bundle-manifest.json", "/api/web-plugins/{id}/{revision}/manifest"].flatMap((path) => ["GET", "HEAD"].map((method) => ({
+	id: `bundle.${path}.${method}`,
+	scope: "global",
+	path,
+	method,
+	authentication: "owner",
+	availability: "Host publishes a web bundle",
+	description: "Read an immutable signed browser bundle manifest.",
+	responses: method === "HEAD" ? {
+		"200": { description: "Manifest response headers" },
+		"404": { description: "Bundle not published" }
+	} : jsonApiResponses(Signed)
+}))), ...["/bundle-assets/{revision}/{assetPath}", "/api/web-plugins/{id}/{revision}/assets/{assetPath}"].flatMap((path) => ["GET", "HEAD"].map((method) => ({
+	id: `asset.${path}.${method}`,
+	scope: "global",
+	path,
+	method,
+	authentication: "owner",
+	availability: "Host publishes a web bundle",
+	description: "Read an asset from the signed manifest. assetPath may contain multiple path segments.",
+	responses: {
+		"200": {
+			description: "Manifest-listed asset, original MIME type",
+			...method === "GET" ? {
+				contentType: "*/*",
+				schema: Type.String({ contentEncoding: "binary" })
+			} : {}
+		},
+		"404": { description: "Asset not published" }
+	}
+})))];
+//#endregion
+//#region src/schemas/sessionProtocol.ts
+const DOOM_SESSION_SERVICE_ID = "doompi.session.v2";
+const DOOM_SESSION_MANAGEMENT_SERVICE_ID = "doompi.session-management.v1";
+defineService("doompi.hub.v1");
+defineService(DOOM_SESSION_SERVICE_ID);
+defineService(DOOM_SESSION_MANAGEMENT_SERVICE_ID);
+//#endregion
+//#region src/schemas/sessionApiContracts.ts
+const Text = Type.String();
+const NumberValue = Type.Number();
+const Flag = Type.Boolean();
+const Json$1 = Type.Unsafe(Type.Unknown({ description: "Strict JSON application value supplied by the active tool, journal entry, or extension; validated by the Pi codec." }));
+const Optional = Type.Optional;
+const Strings = Type.Array(Text);
+const Model = Type.Object({
+	provider: Text,
+	id: Text
+});
+const Thinking = Type.Union([
+	Type.Literal("off"),
+	Type.Literal("minimal"),
+	Type.Literal("low"),
+	Type.Literal("medium"),
+	Type.Literal("high"),
+	Type.Literal("max"),
+	Type.Literal("xhigh")
+]);
+const Phase = Type.Union([
+	Type.Literal("idle"),
+	Type.Literal("turn"),
+	Type.Literal("compaction"),
+	Type.Literal("retry")
+]);
+const Image = Type.Object({
+	type: Type.Literal("image"),
+	data: Text,
+	mimeType: Text
+});
+const TextPart = Type.Object({
+	type: Type.Literal("text"),
+	text: Text
+});
+const Content = Type.Union([Image, TextPart]);
+const User = Type.Object({
+	id: Text,
+	role: Type.Literal("user"),
+	content: Type.Array(Content),
+	timestamp: NumberValue
+});
+const Transcript = Type.Union([
+	User,
+	Type.Object({
+		id: Text,
+		role: Type.Literal("assistant"),
+		content: Type.Array(Type.Union([
+			TextPart,
+			Type.Object({
+				type: Type.Literal("thinking"),
+				thinking: Text,
+				redacted: Optional(Type.Literal(true))
+			}),
+			Type.Object({
+				type: Type.Literal("toolCall"),
+				toolCallId: Text,
+				toolName: Text,
+				input: Json$1
+			})
+		])),
+		model: Model,
+		status: Type.Union([
+			Type.Literal("streaming"),
+			Type.Literal("complete"),
+			Type.Literal("aborted"),
+			Type.Literal("error")
+		]),
+		stopReason: Optional(Type.Union([
+			Type.Literal("stop"),
+			Type.Literal("length"),
+			Type.Literal("toolUse"),
+			Type.Literal("aborted"),
+			Type.Literal("error")
+		])),
+		errorMessage: Optional(Text),
+		timestamp: NumberValue
+	}),
+	Type.Object({
+		id: Text,
+		role: Type.Literal("tool"),
+		toolCallId: Text,
+		toolName: Text,
+		input: Json$1,
+		content: Type.Array(Content),
+		details: Optional(Json$1),
+		status: Type.Union([
+			Type.Literal("running"),
+			Type.Literal("complete"),
+			Type.Literal("error")
+		]),
+		isError: Flag,
+		timestamp: NumberValue
+	})
+]);
+const Usage = Type.Object({
+	input: NumberValue,
+	output: NumberValue,
+	cacheRead: NumberValue,
+	cacheWrite: NumberValue,
+	total: NumberValue
+});
+const Message = Type.Object({
+	text: Text,
+	images: Optional(Type.Array(Image))
+});
+const Lifecycle = Type.Object({
+	revision: NumberValue,
+	operation: Type.Union([Type.Null(), Type.Object({
+		id: Text,
+		kind: Type.Union([
+			Type.Literal("run"),
+			Type.Literal("compaction"),
+			Type.Literal("navigation")
+		]),
+		status: Type.Union([Type.Literal("open"), Type.Literal("aborting")])
+	})]),
+	paused: Flag,
+	queue: Type.Array(Type.Object({
+		id: Text,
+		text: Text,
+		images: Optional(Type.Array(Image)),
+		delivery: Type.Union([
+			Type.Literal("steer"),
+			Type.Literal("followUp"),
+			Type.Literal("nextRun")
+		]),
+		scheduling: Type.Union([Type.Literal("automatic"), Type.Literal("held")]),
+		disposition: Type.Union([
+			Type.Literal("pending"),
+			Type.Literal("handoff"),
+			Type.Literal("uncertain")
+		])
+	}))
+});
+const Frame = Type.Intersect([Type.Object({ type: Text }), Type.Record(Text, Json$1)], { description: "Discriminated extension presentation frame; selected channel schemas describe package payloads." });
+const HubClientFrame = Type.Union([
+	Type.Object({
+		type: Type.Union([Type.Literal("subscribe"), Type.Literal("unsubscribe")]),
+		sessionId: Text
+	}),
+	Type.Object({
+		type: Type.Union([Type.Literal("subscribe_thread"), Type.Literal("unsubscribe_thread")]),
+		sessionId: Text,
+		threadId: Text
+	}),
+	Type.Object({
+		type: Type.String({ not: { enum: [
+			"subscribe",
+			"unsubscribe",
+			"subscribe_thread",
+			"unsubscribe_thread"
+		] } }),
+		sessionId: Text,
+		payload: Json$1
+	})
+]);
+const HubServerFrame = Type.Union([
+	HubSnapshotFrameSchema,
+	HubUpsertFrameSchema,
+	HubRemovedFrameSchema,
+	Type.Object({
+		type: Type.Literal("thread_frame"),
+		sessionId: Text,
+		threadId: Text,
+		frame: Frame
+	}),
+	Type.Object({
+		type: Type.Literal("thread_backlog"),
+		sessionId: Text,
+		threadId: Text,
+		frames: Type.Array(Frame)
+	}),
+	Type.Object({
+		type: Type.String({ not: { enum: [
+			"sessions_snapshot",
+			"session_upsert",
+			"session_removed",
+			"workspaces_snapshot",
+			"workspace_upsert",
+			"workspace_removed",
+			"thread_frame",
+			"thread_backlog"
+		] } }),
+		sessionId: Text,
+		payload: Json$1
+	})
+]);
+const ProtocolEvent = Type.Object({
+	sequence: NumberValue,
+	frame: Frame
+});
+const Update = Type.Union([
+	Type.Object({
+		sessionUpdate: Type.Union([
+			Type.Literal("user_message"),
+			Type.Literal("agent_message"),
+			Type.Literal("agent_thought")
+		]),
+		messageId: Text,
+		content: Type.Array(Content)
+	}),
+	Type.Object({
+		sessionUpdate: Type.Literal("tool_call_update"),
+		toolCallId: Text,
+		title: Optional(Text),
+		kind: Optional(Text),
+		status: Optional(Type.Union([
+			Type.Literal("pending"),
+			Type.Literal("in_progress"),
+			Type.Literal("completed"),
+			Type.Literal("failed"),
+			Type.Literal("cancelled")
+		])),
+		content: Optional(Type.Array(Type.Object({
+			type: Type.Literal("content"),
+			content: Content
+		}))),
+		rawInput: Optional(Json$1),
+		rawOutput: Optional(Json$1)
+	}),
+	Type.Object({
+		sessionUpdate: Type.Literal("state_update"),
+		state: Type.Union([
+			Type.Literal("running"),
+			Type.Literal("idle"),
+			Type.Literal("requires_action")
+		]),
+		stopReason: Optional(Type.Union([
+			Type.Literal("end_turn"),
+			Type.Literal("max_tokens"),
+			Type.Literal("max_turn_requests"),
+			Type.Literal("refusal"),
+			Type.Literal("cancelled"),
+			Type.Unsafe(Type.String({ pattern: "^_" }))
+		]))
+	})
+]);
+const SessionServiceStateSchema = Type.Object({
+	snapshot: Type.Object({
+		id: Text,
+		cwd: Text,
+		name: Optional(Text),
+		createdAt: NumberValue,
+		updatedAt: NumberValue,
+		phase: Phase,
+		model: Model,
+		thinkingLevel: Thinking,
+		attached: Flag,
+		locked: Flag,
+		revision: NumberValue,
+		queuedSteer: Type.Array(User),
+		queuedSteerCount: NumberValue,
+		lifecycle: Optional(Lifecycle)
+	}),
+	progress: Type.Union([Type.Null(), Type.Union([
+		Type.Object({
+			type: Type.Literal("item_started"),
+			item: Transcript
+		}),
+		Type.Object({
+			type: Type.Literal("item_updated"),
+			item: Transcript
+		}),
+		Type.Object({
+			type: Type.Literal("item_finished"),
+			item: Transcript
+		})
+	])]),
+	updates: Optional(Type.Array(Type.Object({
+		sequence: NumberValue,
+		update: Update
+	}))),
+	presentation: Optional(Type.Object({
+		revision: NumberValue,
+		dropped: NumberValue,
+		resetRevision: Optional(NumberValue),
+		events: Type.Array(ProtocolEvent),
+		projections: Type.Array(ProtocolEvent)
+	})),
+	inFlight: Optional(Type.Array(Transcript))
+});
+const SessionMethodSchemas = {
+	readTranscriptPage: {
+		input: Type.Tuple([Type.Object({
+			cursor: Optional(Text),
+			direction: Optional(Type.Union([Type.Literal("older"), Type.Literal("newer")])),
+			limit: Optional(NumberValue),
+			threadId: Optional(Text)
+		})]),
+		output: Type.Object({
+			entries: Type.Array(Json$1),
+			startCursor: Type.Union([Text, Type.Null()]),
+			endCursor: Type.Union([Text, Type.Null()]),
+			olderCursor: Type.Union([Text, Type.Null()]),
+			newerCursor: Type.Union([Text, Type.Null()]),
+			generation: NumberValue,
+			revision: NumberValue,
+			context: Type.Array(Json$1),
+			drafts: Type.Array(Transcript)
+		})
+	},
+	prompt: { input: Type.Tuple([Type.Union([Text, Type.Object({
+		...Message.properties,
+		waitFor: Optional(Type.Union([Type.Literal("accepted"), Type.Literal("settled")]))
+	})])]) },
+	steer: { input: Type.Tuple([Type.Union([Text, Message])]) },
+	abort: { input: Type.Tuple([]) },
+	abortOperation: { input: Type.Tuple([Type.Object({ operationId: Text })]) },
+	setModel: { input: Type.Tuple([Model]) },
+	setThinking: { input: Type.Tuple([Thinking]) },
+	followUp: { input: Type.Tuple([Message]) },
+	enqueueAutomatic: {
+		input: Type.Tuple([Message]),
+		output: Type.Object({ id: Text })
+	},
+	removeQueued: {
+		input: Type.Tuple([Type.Object({ id: Text })]),
+		output: Type.Union([
+			Type.Literal("removed"),
+			Type.Literal("in_flight"),
+			Type.Literal("already_consumed"),
+			Type.Literal("not_found")
+		])
+	},
+	promoteQueued: {
+		input: Type.Tuple([Type.Object({
+			id: Text,
+			operationId: Text
+		})]),
+		output: Type.Union([
+			Type.Literal("promoted"),
+			Type.Literal("in_flight"),
+			Type.Literal("target_changed"),
+			Type.Literal("not_found")
+		])
+	},
+	resumeQueue: { input: Type.Tuple([]) },
+	clearQueue: {
+		input: Type.Tuple([]),
+		output: Type.Object({
+			steering: Strings,
+			followUp: Strings
+		})
+	},
+	rewind: {
+		input: Type.Tuple([Type.Object({
+			itemId: Text,
+			summarize: Optional(Flag),
+			customInstructions: Optional(Text),
+			replaceInstructions: Optional(Flag),
+			label: Optional(Text)
+		})]),
+		output: Type.Object({
+			editorText: Optional(Text),
+			cancelled: Flag,
+			aborted: Optional(Flag),
+			summaryEntry: Optional(Type.Object({
+				id: Text,
+				parentId: Type.Union([Text, Type.Null()]),
+				timestamp: Text,
+				fromId: Text,
+				summary: Text,
+				details: Optional(Json$1),
+				usage: Optional(Usage),
+				fromHook: Optional(Flag)
+			}))
+		})
+	},
+	extensionUiResponse: { input: Type.Tuple([Type.Union([
+		Type.Object({
+			id: Text,
+			value: Text
+		}),
+		Type.Object({
+			id: Text,
+			confirmed: Flag
+		}),
+		Type.Object({
+			id: Text,
+			cancelled: Type.Literal(true)
+		})
+	])]) },
+	getState: {
+		input: Type.Tuple([]),
+		output: Type.Object({
+			model: Optional(Model),
+			thinkingLevel: Thinking,
+			isStreaming: Flag,
+			isCompacting: Flag,
+			steeringMode: Type.Union([Type.Literal("all"), Type.Literal("one-at-a-time")]),
+			followUpMode: Type.Union([Type.Literal("all"), Type.Literal("one-at-a-time")]),
+			sessionFile: Optional(Text),
+			sessionId: Text,
+			sessionName: Optional(Text),
+			autoCompactionEnabled: Flag,
+			messageCount: NumberValue,
+			pendingMessageCount: NumberValue,
+			operationId: Optional(Text),
+			executionStatus: Optional(Type.Union([Type.Literal("open"), Type.Literal("aborting")])),
+			queuePaused: Optional(Flag),
+			queueRevision: Optional(NumberValue)
+		})
+	},
+	getSessionStats: {
+		input: Type.Tuple([]),
+		output: Type.Object({
+			sessionFile: Optional(Text),
+			sessionId: Text,
+			totalMessages: NumberValue,
+			tokens: Usage,
+			cost: NumberValue,
+			contextUsage: Optional(Type.Object({
+				tokens: Type.Union([NumberValue, Type.Null()]),
+				contextWindow: NumberValue,
+				percent: Type.Union([NumberValue, Type.Null()])
+			}))
+		})
+	},
+	getCommands: {
+		input: Type.Tuple([]),
+		output: Type.Array(Type.Object({
+			name: Text,
+			description: Optional(Text),
+			source: Type.Union([
+				Type.Literal("extension"),
+				Type.Literal("prompt"),
+				Type.Literal("skill")
+			]),
+			sourceInfo: Optional(Type.Object({
+				path: Text,
+				source: Text,
+				scope: Type.Union([
+					Type.Literal("user"),
+					Type.Literal("project"),
+					Type.Literal("temporary")
+				]),
+				origin: Type.Union([Type.Literal("package"), Type.Literal("top-level")]),
+				baseDir: Optional(Text)
+			}))
+		}))
+	},
+	getAvailableModels: {
+		input: Type.Tuple([]),
+		output: Type.Array(Model)
+	},
+	getAvailableThinkingLevels: {
+		input: Type.Tuple([]),
+		output: Type.Array(Thinking)
+	},
+	compact: {
+		input: Type.Tuple([Type.Object({ customInstructions: Optional(Text) })]),
+		output: Json$1
+	},
+	setName: { input: Type.Tuple([Text]) }
+};
+const ErrorSchema = Type.Object({
+	code: Text,
+	message: Text
+});
+const sessionSocketContracts = [
+	...Object.entries(SessionMethodSchemas).map(([member, definition]) => ({
+		id: `session.${member}`,
+		scope: "session",
+		service: DOOM_SESSION_SERVICE_ID,
+		member,
+		direction: "client-to-server",
+		kind: "method",
+		description: `Session ${member}. Arguments exclude the process-local Chord Context. A void result is omitted from the successful Pi response.`,
+		...definition,
+		errors: ErrorSchema
+	})),
+	{
+		id: "session.state",
+		scope: "session",
+		service: DOOM_SESSION_SERVICE_ID,
+		member: "state",
+		direction: "server-to-client",
+		kind: "state",
+		input: SessionServiceStateSchema,
+		description: "Reconstructed session state after Chord snapshot/delta decoding."
+	},
+	{
+		id: "management.attach",
+		scope: "global",
+		service: DOOM_SESSION_MANAGEMENT_SERVICE_ID,
+		member: "attach",
+		direction: "client-to-server",
+		kind: "method",
+		input: Type.Tuple([Text]),
+		errors: ErrorSchema,
+		description: "Attach this presentation to a session. Pi publishes an out-of-band attachment update."
+	},
+	{
+		id: "management.detach",
+		scope: "global",
+		service: DOOM_SESSION_MANAGEMENT_SERVICE_ID,
+		member: "detach",
+		direction: "client-to-server",
+		kind: "method",
+		input: Type.Tuple([]),
+		errors: ErrorSchema,
+		description: "Detach this presentation from its selected session."
+	},
+	{
+		id: "hub.send",
+		scope: "global",
+		service: "doompi.hub.v1",
+		member: "send",
+		direction: "client-to-server",
+		kind: "method",
+		input: Type.Tuple([HubClientFrame]),
+		errors: ErrorSchema,
+		description: "Send a hub subscription, thread, history, or selected extension channel frame."
+	},
+	{
+		id: "hub.state",
+		scope: "global",
+		service: "doompi.hub.v1",
+		member: "state",
+		direction: "server-to-client",
+		kind: "state",
+		input: Type.Object({ events: Type.Array(Type.Object({
+			sequence: NumberValue,
+			frame: HubServerFrame
+		})) }),
+		description: "Reconstructed hub event replay window. Frame discriminators identify session and selected extension updates."
+	}
+];
+//#endregion
+//#region src/schemas/pluginProtocol.ts
+/** The address is always exact. A workspace call never resolves to a global service. */
+const DoomPluginMountSchema = Type.Union([
+	Type.Object({ scope: Type.Literal("global") }, { additionalProperties: false }),
+	Type.Object({
+		scope: Type.Literal("workspace"),
+		workspaceId: Type.String({ minLength: 1 })
+	}, { additionalProperties: false }),
+	Type.Object({
+		scope: Type.Literal("session"),
+		sessionId: Type.String({ minLength: 1 })
+	}, { additionalProperties: false })
+]);
+const DoomPluginCallSchema = Type.Object({
+	mount: DoomPluginMountSchema,
+	service: Type.String({ minLength: 1 }),
+	method: Type.String({ minLength: 1 }),
+	input: Type.Unknown()
+}, { additionalProperties: false });
+defineService("doompi.plugin.v1");
+//#endregion
+//#region src/schemas/transportApiContracts.ts
+const S = Type.String({ minLength: 1 });
+const Json = Type.Unknown({ description: "JSON value; its application shape is defined by the addressed service member." });
+const E = Type.Object({
+	code: S,
+	message: Type.String()
+}, { additionalProperties: false });
+const ServerId = Type.String({ pattern: "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" });
+const Address = Type.Object({
+	key: S,
+	generation: Type.Integer({ minimum: 1 })
+}, { additionalProperties: false });
+const Mode = Type.Union([Type.Literal("singleton"), Type.Literal("keyed")]);
+const SessionTarget = Type.Object({
+	serverId: ServerId,
+	sessionId: S,
+	attachmentId: S
+}, { additionalProperties: false });
+const Target = Type.Union([Type.Object({ serverId: ServerId }, { additionalProperties: false }), SessionTarget]);
+const ChordCallSchema = Type.Object({
+	serviceId: S,
+	member: S,
+	args: Type.Array(Json),
+	instance: Type.Optional(Address)
+}, { additionalProperties: false });
+const Segment = Type.Union([Type.String(), Type.Integer({ minimum: 0 })]);
+const Path = Type.Array(Segment);
+const PathRef = Type.Union([Path, Type.Integer({ minimum: 0 })]);
+const NonemptyPathRef = Type.Union([Type.Array(Segment, { minItems: 1 }), Type.Integer({ minimum: 0 })]);
+const Index = Type.Integer({ minimum: 0 });
+const ChordWireOpSchema = Type.Union([
+	Type.Tuple([Type.Literal("r"), Json]),
+	Type.Tuple([
+		Type.Literal("s"),
+		NonemptyPathRef,
+		Json
+	]),
+	Type.Tuple([Type.Literal("s"), Json]),
+	Type.Tuple([Type.Literal("d"), NonemptyPathRef]),
+	Type.Tuple([Type.Literal("d")]),
+	Type.Tuple([
+		Type.Literal("a"),
+		NonemptyPathRef,
+		Type.String()
+	]),
+	Type.Tuple([Type.Literal("a"), Type.String()]),
+	Type.Tuple([
+		Type.Literal("t"),
+		NonemptyPathRef,
+		Index
+	]),
+	Type.Tuple([Type.Literal("t"), Index]),
+	Type.Tuple([
+		Type.Literal("p"),
+		PathRef,
+		Index,
+		Index,
+		Type.Array(Json)
+	]),
+	Type.Tuple([
+		Type.Literal("p"),
+		Index,
+		Index,
+		Type.Array(Json)
+	]),
+	Type.Tuple([
+		Type.Literal("#"),
+		Index,
+		Path
+	])
+], { description: "Chord delta tuples. Path dictionary references and omitted paths depend on earlier operations in this subscription; decode with the Chord delta decoder." });
+const Instance = Type.Object({
+	instance: Type.Optional(Address),
+	members: Type.Array(Type.Union([Type.Object({
+		name: S,
+		kind: Type.Literal("method")
+	}), Type.Object({
+		name: S,
+		kind: Type.Literal("state"),
+		sequence: Type.Integer({ minimum: 0 }),
+		ops: Type.Array(ChordWireOpSchema)
+	})]))
+});
+const ChordSnapshotSchema = Type.Object({
+	serviceId: S,
+	mode: Mode,
+	instances: Type.Array(Instance)
+});
+const ChordUpdateSchema = Type.Union([
+	Type.Object({
+		type: Type.Literal("state"),
+		instance: Type.Optional(Address),
+		member: S,
+		sequence: Type.Integer({ minimum: 1 }),
+		ops: Type.Array(ChordWireOpSchema)
+	}),
+	Type.Object({ type: Type.Literal("unavailable") }),
+	Type.Object({
+		type: Type.Literal("replaced"),
+		snapshot: Instance
+	}),
+	Type.Object({
+		type: Type.Literal("spawned"),
+		instance: Instance
+	}),
+	Type.Object({
+		type: Type.Literal("closed"),
+		instance: Address
+	})
+]);
+const PiClientMessageSchema = Type.Union([
+	Type.Object({
+		type: Type.Literal("hello"),
+		version: Type.Integer({ minimum: 0 })
+	}),
+	Type.Object({
+		type: Type.Literal("request"),
+		id: S,
+		target: Target,
+		call: ChordCallSchema
+	}),
+	Type.Object({
+		type: Type.Literal("cancel"),
+		id: S,
+		target: Target
+	})
+]);
+const PiServerMessageSchema = Type.Union([
+	Type.Object({
+		type: Type.Literal("hello"),
+		version: Type.Literal(PROTOCOL_VERSION),
+		serverId: ServerId
+	}),
+	Type.Object({
+		type: Type.Literal("hello_error"),
+		error: E
+	}),
+	Type.Object({
+		type: Type.Literal("response"),
+		id: S,
+		ok: Type.Literal(true),
+		result: Type.Optional(Json)
+	}),
+	Type.Object({
+		type: Type.Literal("response"),
+		id: S,
+		ok: Type.Literal(false),
+		error: E
+	}),
+	Type.Object({
+		type: Type.Literal("service_update"),
+		subscriptionId: S,
+		update: ChordUpdateSchema
+	}),
+	Type.Object({
+		type: Type.Literal("attachment"),
+		attachment: Type.Union([SessionTarget, Type.Null()])
+	})
+]);
+const transportSocketContracts = [
+	{
+		id: "pi.client",
+		scope: "global",
+		service: "$pi",
+		member: "client",
+		direction: "client-to-server",
+		kind: "channel",
+		input: PiClientMessageSchema,
+		description: `Pi protocol ${PROTOCOL_VERSION} decoded client envelope. Encode with the public Pi codec and framing functions, then seal for WebSocket delivery.`
+	},
+	{
+		id: "pi.server",
+		scope: "global",
+		service: "$pi",
+		member: "server",
+		direction: "server-to-client",
+		kind: "channel",
+		input: PiServerMessageSchema,
+		description: "Pi decoded server envelope. Responses correlate by id; service updates correlate by subscriptionId."
+	},
+	{
+		id: "chord.catalogue",
+		scope: "global",
+		service: "$chord.service",
+		member: "catalogue",
+		direction: "client-to-server",
+		kind: "method",
+		input: Type.Tuple([]),
+		output: Type.Array(Type.Object({
+			serviceId: S,
+			mode: Mode
+		})),
+		errors: E,
+		description: "Discover services at the selected Pi target."
+	},
+	{
+		id: "chord.subscribe",
+		scope: "global",
+		service: "$chord.service",
+		member: "subscribe",
+		direction: "client-to-server",
+		kind: "method",
+		input: Type.Tuple([
+			S,
+			S,
+			Mode
+		]),
+		output: ChordSnapshotSchema,
+		errors: E,
+		description: "Subscribe with [subscriptionId, serviceId, mode]; subsequent Pi service_update messages contain Chord deltas."
+	},
+	{
+		id: "chord.unsubscribe",
+		scope: "global",
+		service: "$chord.service",
+		member: "unsubscribe",
+		direction: "client-to-server",
+		kind: "method",
+		input: Type.Tuple([S]),
+		errors: E,
+		description: "Unsubscribe by subscriptionId."
+	},
+	{
+		id: "plugin.invoke",
+		scope: "global",
+		service: "doompi.plugin.v1",
+		member: "invoke",
+		direction: "client-to-server",
+		kind: "method",
+		input: Type.Tuple([DoomPluginCallSchema]),
+		output: Json,
+		errors: E,
+		description: "Invoke the selected scoped plugin method. Its declaration supplies input and output shapes."
+	}
+];
+//#endregion
+//#region src/schemas/builtinApiContracts.ts
+const builtinApiContract = defineApiContract({
+	version: 1,
+	schemas: {
+		SealedEnvelope: SealedEnvelopeSchema,
+		SealedHttpRequest: SealedHttpRequestSchema,
+		SealedHttpResponse: SealedHttpResponseSchema
+	},
+	protocols: {
+		pi: String(PROTOCOL_VERSION),
+		chord: "0.99.1",
+		sealed: "1"
+	},
+	http: [
+		...headlessHttpContracts,
+		...machineHttpContracts,
+		...sessionHttpContracts,
+		...remoteHttpContracts,
+		...bundleHttpContracts
+	],
+	sockets: [...sessionSocketContracts, ...transportSocketContracts],
+	dynamic: [
+		"WebAuthn options and credential responses follow the installed WebAuthn implementation.",
+		"Tool inputs/results and journal entries contain runtime-defined JSON.",
+		"Selected channel and presentation payload schemas are contributed by their owning package."
+	]
+});
+//#endregion
+export { ApiErrorSchema, ApiOkSchema, ChordCallSchema, ChordSnapshotSchema, ChordUpdateSchema, ChordWireOpSchema, DOOM_API_CONTRACT_FILE, DOOM_API_CONTRACT_VERSION, DoomApiContractSchema, PiClientMessageSchema, PiServerMessageSchema, SessionMethodSchemas, SessionServiceStateSchema, builtinApiContract, canonicalContractJson, createApiDocuments, defineApiContract, jsonApiResponses, parseApiContract, parseCompiledContracts };
+
+//# sourceMappingURL=apiContracts.mjs.map