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

package/dist/schemas/help.mjs

@@ -0,0 +1,231 @@
+import { Type } from "typebox";
+import { Check, Errors } from "typebox/value";
+//#region src/schemas/help.ts
+/** Provider-owned Cordis service for the live Help catalog. */
+const DOOM_HELP_SERVICE = "doom/help";
+const DOOM_HELP_MAX_CONTRIBUTORS = 32;
+const DOOM_HELP_MAX_SKILLS = 64;
+const DOOM_HELP_MAX_DIAGNOSTICS = 64;
+const DOOM_HELP_MAX_DESCRIPTION_LENGTH = 512;
+const DOOM_HELP_MAX_DIAGNOSTIC_LENGTH = 512;
+const MAX_SOURCE_LENGTH = 128;
+const MAX_SKILL_NAME_LENGTH = 64;
+const MAX_MODULE_URL_LENGTH = 4096;
+const MAX_IDENTIFIER_LENGTH = 256;
+const DOOM_HELP_ERROR_CODE = {
+	contributorLimit: "HELP_CONTRIBUTOR_LIMIT",
+	disposed: "HELP_DISPOSED",
+	duplicateSkill: "HELP_DUPLICATE_SKILL",
+	inactiveSnapshot: "HELP_INACTIVE_SNAPSHOT",
+	invalidContribution: "HELP_INVALID_CONTRIBUTION",
+	invalidGeneration: "HELP_INVALID_GENERATION",
+	invalidSnapshot: "HELP_INVALID_SNAPSHOT"
+};
+var DoomHelpError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "DoomHelpError";
+		this.code = code;
+	}
+};
+const DoomHelpSourceSchema = Type.String({
+	minLength: 1,
+	maxLength: MAX_SOURCE_LENGTH,
+	pattern: "^[A-Za-z0-9@][A-Za-z0-9@/._:-]*$"
+});
+const DoomHelpSkillNameSchema = Type.String({
+	minLength: 1,
+	maxLength: MAX_SKILL_NAME_LENGTH,
+	pattern: "^[a-z0-9][a-z0-9-]*$"
+});
+const DoomHelpSkillDescriptorSchema = Type.Object({
+	name: DoomHelpSkillNameSchema,
+	description: Type.String({
+		minLength: 1,
+		maxLength: 512
+	})
+}, { additionalProperties: false });
+const DoomHelpContributionSchema = Type.Object({
+	source: DoomHelpSourceSchema,
+	moduleUrl: Type.String({
+		minLength: 1,
+		maxLength: MAX_MODULE_URL_LENGTH
+	}),
+	skills: Type.Array(DoomHelpSkillDescriptorSchema, {
+		minItems: 1,
+		maxItems: 64
+	})
+}, { additionalProperties: false });
+const GenerationSchema = Type.String({
+	minLength: 1,
+	maxLength: MAX_IDENTIFIER_LENGTH
+});
+const DoomHelpActivationSchema = Type.Union([
+	Type.Literal("inactive"),
+	Type.Literal("activating"),
+	Type.Literal("active"),
+	Type.Literal("degraded")
+]);
+const DoomHelpSkillSchema = Type.Object({
+	source: DoomHelpSourceSchema,
+	name: DoomHelpSkillNameSchema,
+	description: Type.String({
+		minLength: 1,
+		maxLength: 512
+	}),
+	filePath: Type.String({
+		minLength: 1,
+		maxLength: MAX_MODULE_URL_LENGTH
+	}),
+	baseDir: Type.String({
+		minLength: 1,
+		maxLength: MAX_MODULE_URL_LENGTH
+	})
+}, { additionalProperties: false });
+const DoomHelpDiagnosticSchema = Type.Object({
+	source: Type.Optional(DoomHelpSourceSchema),
+	code: Type.String({
+		minLength: 1,
+		maxLength: 64,
+		pattern: "^[A-Z0-9_]+$"
+	}),
+	message: Type.String({
+		minLength: 1,
+		maxLength: 512
+	})
+}, { additionalProperties: false });
+const DoomHelpSnapshotSchema = Type.Object({
+	hostGeneration: GenerationSchema,
+	revision: Type.Integer({ minimum: 0 }),
+	activation: DoomHelpActivationSchema,
+	skills: Type.Array(DoomHelpSkillSchema, { maxItems: 64 }),
+	diagnostics: Type.Array(DoomHelpDiagnosticSchema, { maxItems: 64 })
+}, { additionalProperties: false });
+function schemaFailure(schema, value) {
+	const [first] = Errors(schema, value);
+	return first ? ` at ${first.instancePath || "/"}: ${first.message}` : "";
+}
+function cloneContribution(contribution) {
+	return {
+		source: contribution.source,
+		moduleUrl: contribution.moduleUrl,
+		skills: contribution.skills.map((skill) => ({ ...skill }))
+	};
+}
+function cloneSnapshot(snapshot) {
+	return {
+		...snapshot,
+		skills: snapshot.skills.map((skill) => ({ ...skill })),
+		diagnostics: snapshot.diagnostics.map((diagnostic) => ({ ...diagnostic }))
+	};
+}
+function validateContribution(contribution) {
+	if (!Check(DoomHelpContributionSchema, contribution)) throw new DoomHelpError(DOOM_HELP_ERROR_CODE.invalidContribution, `Invalid Help contribution${schemaFailure(DoomHelpContributionSchema, contribution)}.`);
+	const names = /* @__PURE__ */ new Set();
+	for (const skill of contribution.skills) {
+		if (names.has(skill.name)) throw new DoomHelpError(DOOM_HELP_ERROR_CODE.duplicateSkill, `Help contribution '${contribution.source}' declares duplicate skill '${skill.name}'.`);
+		names.add(skill.name);
+	}
+	return cloneContribution(contribution);
+}
+/** Creates the provider-owned Help service value for one Cordis session. */
+function createDoomHelpService(generation) {
+	if (!Check(GenerationSchema, generation)) throw new DoomHelpError(DOOM_HELP_ERROR_CODE.invalidGeneration, "Doom Help requires a valid generation.");
+	const contributions = /* @__PURE__ */ new Map();
+	const contributionListeners = /* @__PURE__ */ new Set();
+	const snapshotListeners = /* @__PURE__ */ new Set();
+	let registrationSequence = 0;
+	let disposed = false;
+	let snapshot = {
+		hostGeneration: generation,
+		revision: 0,
+		activation: "inactive",
+		skills: [],
+		diagnostics: []
+	};
+	const ensureActive = () => {
+		if (disposed) throw new DoomHelpError(DOOM_HELP_ERROR_CODE.disposed, "The Doom Help service is disposed.");
+	};
+	const list = () => [...contributions.values()].map(({ contribution }) => cloneContribution(contribution)).sort((left, right) => left.source.localeCompare(right.source));
+	const notifyContributions = () => {
+		const value = list();
+		for (const listener of contributionListeners) listener(value);
+	};
+	return Object.freeze({
+		generation,
+		register(contribution) {
+			ensureActive();
+			const validated = validateContribution(contribution);
+			if (!contributions.has(validated.source) && contributions.size >= 32) throw new DoomHelpError(DOOM_HELP_ERROR_CODE.contributorLimit, `Help accepts at most 32 contributors.`);
+			registrationSequence += 1;
+			const token = Symbol(validated.source);
+			const registrationGeneration = `${generation}:help:${registrationSequence}`;
+			contributions.set(validated.source, {
+				token,
+				generation: registrationGeneration,
+				contribution: validated
+			});
+			notifyContributions();
+			let registrationDisposed = false;
+			return Object.freeze({
+				source: validated.source,
+				generation: registrationGeneration,
+				dispose() {
+					if (registrationDisposed) return;
+					registrationDisposed = true;
+					if (contributions.get(validated.source)?.token !== token) return;
+					contributions.delete(validated.source);
+					notifyContributions();
+				}
+			});
+		},
+		listContributions: list,
+		subscribeContributions(listener) {
+			ensureActive();
+			contributionListeners.add(listener);
+			return () => contributionListeners.delete(listener);
+		},
+		getSnapshot: () => cloneSnapshot(snapshot),
+		publish(draft) {
+			ensureActive();
+			if (draft.activation === "inactive" && draft.skills.length > 0) throw new DoomHelpError(DOOM_HELP_ERROR_CODE.inactiveSnapshot, "Inactive Help snapshots cannot expose skills.");
+			const next = {
+				hostGeneration: generation,
+				revision: snapshot.revision + 1,
+				activation: draft.activation,
+				skills: draft.skills.map((skill) => ({ ...skill })),
+				diagnostics: draft.diagnostics.map((diagnostic) => ({ ...diagnostic }))
+			};
+			if (!Check(DoomHelpSnapshotSchema, next)) throw new DoomHelpError(DOOM_HELP_ERROR_CODE.invalidSnapshot, `Invalid Help snapshot${schemaFailure(DoomHelpSnapshotSchema, next)}.`);
+			snapshot = next;
+			const published = cloneSnapshot(snapshot);
+			for (const listener of snapshotListeners) listener(cloneSnapshot(published));
+			return published;
+		},
+		subscribeSnapshot(listener) {
+			ensureActive();
+			snapshotListeners.add(listener);
+			return () => snapshotListeners.delete(listener);
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			contributions.clear();
+			contributionListeners.clear();
+			snapshotListeners.clear();
+		}
+	});
+}
+function readDoomHelpService(context) {
+	return context.get(DOOM_HELP_SERVICE);
+}
+function requireDoomHelpService(context) {
+	const service = readDoomHelpService(context);
+	if (!service) throw new Error("Doom Help is unavailable. Load @agimon-ai/doompi-help.");
+	return service;
+}
+//#endregion
+export { DOOM_HELP_ERROR_CODE, DOOM_HELP_MAX_CONTRIBUTORS, DOOM_HELP_MAX_DESCRIPTION_LENGTH, DOOM_HELP_MAX_DIAGNOSTICS, DOOM_HELP_MAX_DIAGNOSTIC_LENGTH, DOOM_HELP_MAX_SKILLS, DOOM_HELP_SERVICE, DoomHelpActivationSchema, DoomHelpContributionSchema, DoomHelpDiagnosticSchema, DoomHelpError, DoomHelpSkillDescriptorSchema, DoomHelpSkillNameSchema, DoomHelpSkillSchema, DoomHelpSnapshotSchema, DoomHelpSourceSchema, createDoomHelpService, readDoomHelpService, requireDoomHelpService };
+
+//# sourceMappingURL=help.mjs.map

package/dist/schemas/help.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"help.mjs","names":[],"sources":["../../src/schemas/help.ts"],"sourcesContent":["import type { Context } from '@deepseek-ai/cordis';\nimport { type Static, Type } from 'typebox';\nimport { Check, Errors } from 'typebox/value';\n\n/** Provider-owned Cordis service for the live Help catalog. */\nexport const DOOM_HELP_SERVICE = 'doom/help';\nexport const DOOM_HELP_MAX_CONTRIBUTORS = 32;\nexport const DOOM_HELP_MAX_SKILLS = 64;\nexport const DOOM_HELP_MAX_DIAGNOSTICS = 64;\nexport const DOOM_HELP_MAX_DESCRIPTION_LENGTH = 512;\nexport const DOOM_HELP_MAX_DIAGNOSTIC_LENGTH = 512;\n\nconst MAX_SOURCE_LENGTH = 128;\nconst MAX_SKILL_NAME_LENGTH = 64;\nconst MAX_MODULE_URL_LENGTH = 4_096;\nconst MAX_IDENTIFIER_LENGTH = 256;\n\nexport const DOOM_HELP_ERROR_CODE = {\n  contributorLimit: 'HELP_CONTRIBUTOR_LIMIT',\n  disposed: 'HELP_DISPOSED',\n  duplicateSkill: 'HELP_DUPLICATE_SKILL',\n  inactiveSnapshot: 'HELP_INACTIVE_SNAPSHOT',\n  invalidContribution: 'HELP_INVALID_CONTRIBUTION',\n  invalidGeneration: 'HELP_INVALID_GENERATION',\n  invalidSnapshot: 'HELP_INVALID_SNAPSHOT',\n} as const;\n\nexport type DoomHelpErrorCode = (typeof DOOM_HELP_ERROR_CODE)[keyof typeof DOOM_HELP_ERROR_CODE];\n\nexport class DoomHelpError extends Error {\n  readonly code: DoomHelpErrorCode;\n\n  constructor(code: DoomHelpErrorCode, message: string) {\n    super(message);\n    this.name = 'DoomHelpError';\n    this.code = code;\n  }\n}\n\nexport const DoomHelpSourceSchema = Type.String({\n  minLength: 1,\n  maxLength: MAX_SOURCE_LENGTH,\n  pattern: '^[A-Za-z0-9@][A-Za-z0-9@/._:-]*$',\n});\n\nexport const DoomHelpSkillNameSchema = Type.String({\n  minLength: 1,\n  maxLength: MAX_SKILL_NAME_LENGTH,\n  pattern: '^[a-z0-9][a-z0-9-]*$',\n});\n\nexport const DoomHelpSkillDescriptorSchema = Type.Object(\n  {\n    name: DoomHelpSkillNameSchema,\n    description: Type.String({ minLength: 1, maxLength: DOOM_HELP_MAX_DESCRIPTION_LENGTH }),\n  },\n  { additionalProperties: false },\n);\nexport type DoomHelpSkillDescriptor = Static<typeof DoomHelpSkillDescriptorSchema>;\n\nexport const DoomHelpContributionSchema = Type.Object(\n  {\n    source: DoomHelpSourceSchema,\n    moduleUrl: Type.String({ minLength: 1, maxLength: MAX_MODULE_URL_LENGTH }),\n    skills: Type.Array(DoomHelpSkillDescriptorSchema, { minItems: 1, maxItems: DOOM_HELP_MAX_SKILLS }),\n  },\n  { additionalProperties: false },\n);\nexport type DoomHelpContribution = Static<typeof DoomHelpContributionSchema>;\n\nconst GenerationSchema = Type.String({ minLength: 1, maxLength: MAX_IDENTIFIER_LENGTH });\n\nexport const DoomHelpActivationSchema = Type.Union([\n  Type.Literal('inactive'),\n  Type.Literal('activating'),\n  Type.Literal('active'),\n  Type.Literal('degraded'),\n]);\nexport type DoomHelpActivation = Static<typeof DoomHelpActivationSchema>;\n\nexport const DoomHelpSkillSchema = Type.Object(\n  {\n    source: DoomHelpSourceSchema,\n    name: DoomHelpSkillNameSchema,\n    description: Type.String({ minLength: 1, maxLength: DOOM_HELP_MAX_DESCRIPTION_LENGTH }),\n    filePath: Type.String({ minLength: 1, maxLength: MAX_MODULE_URL_LENGTH }),\n    baseDir: Type.String({ minLength: 1, maxLength: MAX_MODULE_URL_LENGTH }),\n  },\n  { additionalProperties: false },\n);\nexport type DoomHelpSkill = Static<typeof DoomHelpSkillSchema>;\n\nexport const DoomHelpDiagnosticSchema = Type.Object(\n  {\n    source: Type.Optional(DoomHelpSourceSchema),\n    code: Type.String({ minLength: 1, maxLength: 64, pattern: '^[A-Z0-9_]+$' }),\n    message: Type.String({ minLength: 1, maxLength: DOOM_HELP_MAX_DIAGNOSTIC_LENGTH }),\n  },\n  { additionalProperties: false },\n);\nexport type DoomHelpDiagnostic = Static<typeof DoomHelpDiagnosticSchema>;\n\nexport const DoomHelpSnapshotSchema = Type.Object(\n  {\n    hostGeneration: GenerationSchema,\n    revision: Type.Integer({ minimum: 0 }),\n    activation: DoomHelpActivationSchema,\n    skills: Type.Array(DoomHelpSkillSchema, { maxItems: DOOM_HELP_MAX_SKILLS }),\n    diagnostics: Type.Array(DoomHelpDiagnosticSchema, { maxItems: DOOM_HELP_MAX_DIAGNOSTICS }),\n  },\n  { additionalProperties: false },\n);\nexport type DoomHelpSnapshot = Static<typeof DoomHelpSnapshotSchema>;\n\nexport interface DoomHelpSnapshotDraft {\n  readonly activation: DoomHelpActivation;\n  readonly skills: readonly DoomHelpSkill[];\n  readonly diagnostics: readonly DoomHelpDiagnostic[];\n}\n\nexport interface DoomHelpContributionHandle {\n  readonly source: string;\n  readonly generation: string;\n  dispose(): void;\n}\n\n/** Direct, session-local registrar and query surface owned by doompi-help. */\nexport interface DoomHelpService {\n  readonly generation: string;\n  register(contribution: DoomHelpContribution): DoomHelpContributionHandle;\n  listContributions(): readonly DoomHelpContribution[];\n  subscribeContributions(listener: (contributions: readonly DoomHelpContribution[]) => void): () => void;\n  getSnapshot(): DoomHelpSnapshot;\n  publish(snapshot: DoomHelpSnapshotDraft): DoomHelpSnapshot;\n  subscribeSnapshot(listener: (snapshot: DoomHelpSnapshot) => void): () => void;\n  dispose(): void;\n}\n\ndeclare module '@deepseek-ai/cordis' {\n  interface Context {\n    'doom/help': DoomHelpService;\n  }\n}\n\ninterface RegisteredContribution {\n  readonly token: symbol;\n  readonly generation: string;\n  readonly contribution: DoomHelpContribution;\n}\n\nfunction schemaFailure(\n  schema: typeof DoomHelpContributionSchema | typeof DoomHelpSnapshotSchema,\n  value: unknown,\n): string {\n  const [first] = Errors(schema, value);\n  return first ? ` at ${first.instancePath || '/'}: ${first.message}` : '';\n}\n\nfunction cloneContribution(contribution: DoomHelpContribution): DoomHelpContribution {\n  return {\n    source: contribution.source,\n    moduleUrl: contribution.moduleUrl,\n    skills: contribution.skills.map((skill) => ({ ...skill })),\n  };\n}\n\nfunction cloneSnapshot(snapshot: DoomHelpSnapshot): DoomHelpSnapshot {\n  return {\n    ...snapshot,\n    skills: snapshot.skills.map((skill) => ({ ...skill })),\n    diagnostics: snapshot.diagnostics.map((diagnostic) => ({ ...diagnostic })),\n  };\n}\n\nfunction validateContribution(contribution: DoomHelpContribution): DoomHelpContribution {\n  if (!Check(DoomHelpContributionSchema, contribution)) {\n    throw new DoomHelpError(\n      DOOM_HELP_ERROR_CODE.invalidContribution,\n      `Invalid Help contribution${schemaFailure(DoomHelpContributionSchema, contribution)}.`,\n    );\n  }\n  const names = new Set<string>();\n  for (const skill of contribution.skills) {\n    if (names.has(skill.name)) {\n      throw new DoomHelpError(\n        DOOM_HELP_ERROR_CODE.duplicateSkill,\n        `Help contribution '${contribution.source}' declares duplicate skill '${skill.name}'.`,\n      );\n    }\n    names.add(skill.name);\n  }\n  return cloneContribution(contribution);\n}\n\n/** Creates the provider-owned Help service value for one Cordis session. */\nexport function createDoomHelpService(generation: string): DoomHelpService {\n  if (!Check(GenerationSchema, generation)) {\n    throw new DoomHelpError(DOOM_HELP_ERROR_CODE.invalidGeneration, 'Doom Help requires a valid generation.');\n  }\n\n  const contributions = new Map<string, RegisteredContribution>();\n  const contributionListeners = new Set<(value: readonly DoomHelpContribution[]) => void>();\n  const snapshotListeners = new Set<(value: DoomHelpSnapshot) => void>();\n  let registrationSequence = 0;\n  let disposed = false;\n  let snapshot: DoomHelpSnapshot = {\n    hostGeneration: generation,\n    revision: 0,\n    activation: 'inactive',\n    skills: [],\n    diagnostics: [],\n  };\n\n  const ensureActive = (): void => {\n    if (disposed) throw new DoomHelpError(DOOM_HELP_ERROR_CODE.disposed, 'The Doom Help service is disposed.');\n  };\n  const list = (): readonly DoomHelpContribution[] =>\n    [...contributions.values()]\n      .map(({ contribution }) => cloneContribution(contribution))\n      .sort((left, right) => left.source.localeCompare(right.source));\n  const notifyContributions = (): void => {\n    const value = list();\n    for (const listener of contributionListeners) listener(value);\n  };\n\n  const service: DoomHelpService = {\n    generation,\n    register(contribution) {\n      ensureActive();\n      const validated = validateContribution(contribution);\n      if (!contributions.has(validated.source) && contributions.size >= DOOM_HELP_MAX_CONTRIBUTORS) {\n        throw new DoomHelpError(\n          DOOM_HELP_ERROR_CODE.contributorLimit,\n          `Help accepts at most ${DOOM_HELP_MAX_CONTRIBUTORS} contributors.`,\n        );\n      }\n      registrationSequence += 1;\n      const token = Symbol(validated.source);\n      const registrationGeneration = `${generation}:help:${registrationSequence}`;\n      contributions.set(validated.source, {\n        token,\n        generation: registrationGeneration,\n        contribution: validated,\n      });\n      notifyContributions();\n      let registrationDisposed = false;\n      return Object.freeze({\n        source: validated.source,\n        generation: registrationGeneration,\n        dispose() {\n          if (registrationDisposed) return;\n          registrationDisposed = true;\n          if (contributions.get(validated.source)?.token !== token) return;\n          contributions.delete(validated.source);\n          notifyContributions();\n        },\n      });\n    },\n    listContributions: list,\n    subscribeContributions(listener) {\n      ensureActive();\n      contributionListeners.add(listener);\n      return () => contributionListeners.delete(listener);\n    },\n    getSnapshot: () => cloneSnapshot(snapshot),\n    publish(draft) {\n      ensureActive();\n      if (draft.activation === 'inactive' && draft.skills.length > 0) {\n        throw new DoomHelpError(DOOM_HELP_ERROR_CODE.inactiveSnapshot, 'Inactive Help snapshots cannot expose skills.');\n      }\n      const next: DoomHelpSnapshot = {\n        hostGeneration: generation,\n        revision: snapshot.revision + 1,\n        activation: draft.activation,\n        skills: draft.skills.map((skill) => ({ ...skill })),\n        diagnostics: draft.diagnostics.map((diagnostic) => ({ ...diagnostic })),\n      };\n      if (!Check(DoomHelpSnapshotSchema, next)) {\n        throw new DoomHelpError(\n          DOOM_HELP_ERROR_CODE.invalidSnapshot,\n          `Invalid Help snapshot${schemaFailure(DoomHelpSnapshotSchema, next)}.`,\n        );\n      }\n      snapshot = next;\n      const published = cloneSnapshot(snapshot);\n      for (const listener of snapshotListeners) listener(cloneSnapshot(published));\n      return published;\n    },\n    subscribeSnapshot(listener) {\n      ensureActive();\n      snapshotListeners.add(listener);\n      return () => snapshotListeners.delete(listener);\n    },\n    dispose() {\n      if (disposed) return;\n      disposed = true;\n      contributions.clear();\n      contributionListeners.clear();\n      snapshotListeners.clear();\n    },\n  };\n  return Object.freeze(service);\n}\n\nexport function readDoomHelpService(context: Context): DoomHelpService | undefined {\n  return context.get(DOOM_HELP_SERVICE) as DoomHelpService | undefined;\n}\n\nexport function requireDoomHelpService(context: Context): DoomHelpService {\n  const service = readDoomHelpService(context);\n  if (!service) throw new Error('Doom Help is unavailable. Load @agimon-ai/doompi-help.');\n  return service;\n}\n"],"mappings":"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"}

package/dist/schemas/httpApiContracts.cjs

@@ -0,0 +1,388 @@
+const require_contextApi = require("../constants/contextApi.cjs");
+let typebox = require("typebox");
+//#region src/schemas/httpApiContracts.ts
+const Text = typebox.Type.String();
+const Optional = typebox.Type.Optional;
+const Strings = typebox.Type.Array(Text);
+const Flag = typebox.Type.Boolean();
+const NumberValue = typebox.Type.Number();
+const ApiErrorSchema = typebox.Type.Object({
+	error: Text,
+	hash: Optional(Text)
+});
+const ApiOkSchema = typebox.Type.Object({ ok: typebox.Type.Literal(true) });
+const Json = typebox.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 = typebox.Type.Object({
+	id: Text,
+	scope: typebox.Type.Union([
+		typebox.Type.Literal("global"),
+		typebox.Type.Literal("workspace"),
+		typebox.Type.Literal("session")
+	]),
+	revision: NumberValue,
+	manifestUrl: Text,
+	rawAssetBaseUrl: Text,
+	verifiedAssetBaseUrl: Text,
+	entryPath: Text,
+	stylePaths: Strings,
+	channels: Strings
+});
+const SessionSummarySchema = typebox.Type.Object({
+	id: Text,
+	workspaceId: Optional(Text),
+	webComposition: Optional(WebCompositionSchema),
+	name: Text,
+	cwd: Text,
+	createdAt: Text,
+	updatedAt: Text,
+	phase: typebox.Type.Union([
+		typebox.Type.Literal("idle"),
+		typebox.Type.Literal("turn"),
+		typebox.Type.Literal("compaction"),
+		typebox.Type.Literal("retry")
+	]),
+	phaseSince: Text,
+	attach: typebox.Type.Literal("attached"),
+	pendingMessageCount: NumberValue,
+	everPrompted: Flag,
+	awaitingInput: Flag,
+	lastSettledAt: Optional(Text),
+	parentSessionId: Optional(Text),
+	sessionProvenance: Optional(Text)
+});
+const HubSnapshotFrameSchema = typebox.Type.Object({
+	type: typebox.Type.Literal("sessions_snapshot"),
+	sessions: typebox.Type.Array(SessionSummarySchema)
+});
+const HubUpsertFrameSchema = typebox.Type.Object({
+	type: typebox.Type.Literal("session_upsert"),
+	session: SessionSummarySchema
+});
+const HubRemovedFrameSchema = typebox.Type.Object({
+	type: typebox.Type.Literal("session_removed"),
+	sessionId: Text
+});
+const Workspace = typebox.Type.Object({
+	id: Text,
+	root: Text
+});
+const SavedSession = typebox.Type.Object({
+	id: Text,
+	name: Optional(Text),
+	firstMessage: Text,
+	createdAt: Text,
+	updatedAt: Text,
+	messageCount: NumberValue
+});
+const query = (name, schema = Text, 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 = typebox.Type.String({ contentEncoding: "binary" });
+const headlessHttpContracts = [
+	host("health", "/api/health", "GET", typebox.Type.Object({
+		ok: typebox.Type.Literal(true),
+		role: typebox.Type.Literal("hub"),
+		protocol: typebox.Type.Literal(1),
+		sessions: NumberValue
+	}), { authentication: "none" }),
+	host("telemetry.browser", "/api/telemetry/browser", "POST", ApiOkSchema, { body: body(typebox.Type.Object({
+		v: typebox.Type.Literal(1),
+		events: typebox.Type.Array(typebox.Type.Object({
+			name: typebox.Type.String({ pattern: "^web\\.browser\\.[a-z_]{1,40}$" }),
+			duration_ms: Optional(NumberValue),
+			count: Optional(NumberValue)
+		}), { maxItems: 10 })
+	})) }),
+	host("compositions", "/api/compositions", "GET", typebox.Type.Object({
+		global: Optional(WebCompositionSchema),
+		publicKey: Optional(Text),
+		shell: Optional(typebox.Type.Object({
+			publicKey: Text,
+			revision: NumberValue
+		})),
+		workspaces: typebox.Type.Array(typebox.Type.Object({
+			id: Text,
+			root: Text,
+			webComposition: Optional(WebCompositionSchema)
+		}))
+	})),
+	host("directories", "/api/directories", "GET", typebox.Type.Object({ directories: Strings }), { parameters: [query("q")] }),
+	host("sessions.list", "/api/sessions", "GET", typebox.Type.Object({ sessions: typebox.Type.Array(SessionSummarySchema) })),
+	host("sessions.create", "/api/sessions", "POST", typebox.Type.Object({ sessionId: Text }), {
+		body: body(typebox.Type.Object({
+			cwd: typebox.Type.String({ minLength: 1 }),
+			name: Optional(Text)
+		})),
+		responses: jsonApiResponses(typebox.Type.Object({ sessionId: Text }), 201)
+	}),
+	host("sessions.get", "/api/sessions/{sessionId}", "GET", SessionSummarySchema),
+	host("sessions.delete", "/api/sessions/{sessionId}", "DELETE", ApiOkSchema),
+	host("sessions.history", "/api/sessions/{sessionId}/history", "GET", typebox.Type.Object({ sessions: typebox.Type.Array(SavedSession) }), { availability: "Host provides sessionHistory" }),
+	host("sessions.restart", "/api/sessions/{sessionId}/restart", "POST", ApiOkSchema, { availability: "Host provides restartSession" }),
+	host("sessions.resume", "/api/sessions/{sessionId}/resume", "POST", typebox.Type.Object({ sessionId: Text }), {
+		availability: "Host provides resumeSession",
+		body: body(typebox.Type.Object({ targetSessionId: typebox.Type.String({ pattern: "^[A-Za-z0-9_-]+$" }) }))
+	}),
+	host("sessions.file", "/api/sessions/{sessionId}/file", "GET", Binary, {
+		parameters: [query("path", Text, true)],
+		responses: {
+			...jsonApiResponses(Binary),
+			"200": {
+				description: "File bytes, MIME type follows the file extension",
+				contentType: "*/*",
+				schema: Binary
+			}
+		}
+	}),
+	host("sessions.channels", "/api/sessions/{sessionId}/channels", "GET", typebox.Type.Object({ channels: typebox.Type.Array(typebox.Type.Object({
+		type: Text,
+		sessionId: Text,
+		payload: Json
+	})) })),
+	host("sessions.channel.send", "/api/sessions/{sessionId}/channel/{frameType}", "POST", ApiOkSchema, {
+		body: body(Json),
+		responses: jsonApiResponses(ApiOkSchema, 202),
+		description: "Deliver a payload to the selected channel contract identified by frameType."
+	}),
+	host("workspaces.list", "/api/workspaces", "GET", typebox.Type.Object({ workspaces: typebox.Type.Array(Workspace) })),
+	host("workspaces.admit", "/api/workspaces", "POST", typebox.Type.Object({ workspace: Workspace }), {
+		body: body(typebox.Type.Object({ root: Text })),
+		responses: jsonApiResponses(typebox.Type.Object({ workspace: Workspace }), 201)
+	}),
+	host("workspaces.remove", "/api/workspaces/{workspaceId}", "DELETE", ApiOkSchema),
+	host("events", "/api/events", "GET", Text, { responses: {
+		"200": {
+			description: "SSE sessions_snapshot, session_upsert, session_removed 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
+			},
+			contentType: "text/event-stream",
+			schema: Text
+		},
+		"401": {
+			description: "Authentication required",
+			schema: ApiErrorSchema
+		}
+	} })
+];
+const AuthType = typebox.Type.Union([typebox.Type.Literal("api_key"), typebox.Type.Literal("oauth")]);
+const Provider = typebox.Type.Object({
+	id: Text,
+	name: Text,
+	methods: typebox.Type.Array(typebox.Type.Object({
+		type: AuthType,
+		label: Text
+	})),
+	authenticated: Optional(typebox.Type.Object({
+		type: AuthType,
+		source: Optional(Text)
+	}))
+});
+const LoginEvent = typebox.Type.Union([
+	typebox.Type.Object({
+		type: typebox.Type.Literal("info"),
+		message: Text,
+		links: Optional(typebox.Type.Array(typebox.Type.Object({
+			url: Text,
+			label: Optional(Text)
+		})))
+	}),
+	typebox.Type.Object({
+		type: typebox.Type.Literal("auth_url"),
+		url: Text,
+		instructions: Optional(Text)
+	}),
+	typebox.Type.Object({
+		type: typebox.Type.Literal("device_code"),
+		userCode: Text,
+		verificationUri: Text,
+		intervalSeconds: Optional(NumberValue),
+		expiresInSeconds: Optional(NumberValue)
+	}),
+	typebox.Type.Object({
+		type: typebox.Type.Literal("progress"),
+		message: Text
+	})
+]);
+const LoginFlowSchema = typebox.Type.Object({
+	id: Text,
+	providerId: Text,
+	providerName: Text,
+	type: AuthType,
+	status: typebox.Type.Union([
+		typebox.Type.Literal("running"),
+		typebox.Type.Literal("succeeded"),
+		typebox.Type.Literal("failed"),
+		typebox.Type.Literal("cancelled")
+	]),
+	events: typebox.Type.Array(LoginEvent),
+	prompt: Optional(typebox.Type.Object({
+		id: Text,
+		type: typebox.Type.Union([
+			typebox.Type.Literal("text"),
+			typebox.Type.Literal("secret"),
+			typebox.Type.Literal("select"),
+			typebox.Type.Literal("manual_code")
+		]),
+		message: Text,
+		placeholder: Optional(Text),
+		options: Optional(typebox.Type.Array(typebox.Type.Object({
+			id: Text,
+			label: Text,
+			description: Optional(Text)
+		})))
+	})),
+	remote: Optional(Flag),
+	error: Optional(Text)
+});
+const Flow = typebox.Type.Object({ flow: LoginFlowSchema });
+const machineHttpContracts = [
+	host("providers.list", "/providers", "GET", typebox.Type.Object({ providers: typebox.Type.Array(Provider) })),
+	host("models.list", "/models", "GET", typebox.Type.Object({ models: typebox.Type.Array(typebox.Type.Object({
+		value: Text,
+		label: Text,
+		group: Text
+	})) })),
+	host("providers.logout", "/providers/{providerId}", "DELETE", ApiOkSchema),
+	host("logins.create", "/logins", "POST", Flow, {
+		body: body(typebox.Type.Object({
+			providerId: Text,
+			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(typebox.Type.Object({
+		promptId: Text,
+		value: Text
+	})) })
+].map((route) => ({
+	...route,
+	basePath: "doompi"
+}));
+const Source = typebox.Type.Union([
+	typebox.Type.Literal("extension"),
+	typebox.Type.Literal("mcp"),
+	typebox.Type.Literal("plugin"),
+	typebox.Type.Literal("core")
+]);
+const Detail = typebox.Type.Union([typebox.Type.Object({
+	itemKind: typebox.Type.Literal("tool"),
+	name: Text,
+	owner: Text,
+	source: Source,
+	active: Flag,
+	tokens: typebox.Type.Object({
+		schemaTokens: NumberValue,
+		promptTokens: NumberValue,
+		totalTokens: NumberValue
+	}),
+	description: Optional(Text),
+	promptSnippet: Optional(Text),
+	promptGuidelines: Optional(Strings),
+	parameters: Optional(Json)
+}), typebox.Type.Object({
+	itemKind: typebox.Type.Literal("skill"),
+	name: Text,
+	owner: Text,
+	source: Source,
+	active: typebox.Type.Literal(true),
+	tokens: NumberValue,
+	description: Text,
+	filePath: Optional(Text),
+	modelInvocable: Flag
+})]);
+const sessionHttpContracts = [{
+	...host("context.item", require_contextApi.ITEM_ROUTE, "GET", typebox.Type.Object({
+		revision: NumberValue,
+		item: Detail
+	}), { parameters: [query("kind", typebox.Type.Union([typebox.Type.Literal("tool"), typebox.Type.Literal("skill")]), true), query("name", Text, true)] }),
+	scope: "session",
+	basePath: require_contextApi.API_BASE_PATH
+}, {
+	...host("files.complete", "/", "GET", typebox.Type.Object({ files: Strings }), { parameters: [query("q", typebox.Type.String({ maxLength: 256 }))] }),
+	scope: "session",
+	basePath: "files"
+}];
+//#endregion
+exports.ApiErrorSchema = ApiErrorSchema;
+exports.ApiOkSchema = ApiOkSchema;
+exports.HubRemovedFrameSchema = HubRemovedFrameSchema;
+exports.HubSnapshotFrameSchema = HubSnapshotFrameSchema;
+exports.HubUpsertFrameSchema = HubUpsertFrameSchema;
+exports.LoginFlowSchema = LoginFlowSchema;
+exports.SessionSummarySchema = SessionSummarySchema;
+exports.WebCompositionSchema = WebCompositionSchema;
+exports.headlessHttpContracts = headlessHttpContracts;
+exports.jsonApiResponses = jsonApiResponses;
+exports.machineHttpContracts = machineHttpContracts;
+exports.sessionHttpContracts = sessionHttpContracts;
+
+//# sourceMappingURL=httpApiContracts.cjs.map