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

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

@@ -0,0 +1 @@
+{"version":3,"file":"agentModel.d.cts","names":[],"sources":["../../src/schemas/agentModel.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAiBa;qBAEA,4BAA0B,KAAA;;;;;YAS3B,uBAAuB,cAAc"}

package/dist/schemas/agentModel.d.mts

@@ -0,0 +1,26 @@
+import { Static, Type } from "typebox";
+//#region src/schemas/agentModel.d.ts
+/**
+ * The custom session entry the runtime journals when the agent's model changes
+ * without a client having asked for it.
+ *
+ * Pi reports a thinking-level switch on the wire as `thinking_level_changed`,
+ * so a cockpit can follow that field from the frame alone. It has no matching
+ * event for the model: `model_select` is delivered to extensions inside the
+ * agent process and never leaves it. A client therefore learns about a model
+ * an extension chose (plan mode applying its configured planning model) only
+ * by asking for `get_state`, which nothing prompts it to do.
+ *
+ * This entry closes that gap on the road the minor-mode projection already
+ * uses: it rides Pi's `entry_appended` frames, so any RPC client sees the
+ * change live and on replay without a new protocol.
+ */
+export declare const DOOM_AGENT_MODEL_ENTRY_TYPE = "doom-agent-model";
+export declare const AgentModelProjectionSchema: Type.TObject<{
+  provider: Type.TString;
+  id: Type.TString;
+}>;
+/** The model the agent is on, named the way `set_model` and `get_state` name it. */
+export type AgentModelProjection = Static<typeof AgentModelProjectionSchema>;
+//#endregion
+//# sourceMappingURL=agentModel.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"agentModel.d.mts","names":[],"sources":["../../src/schemas/agentModel.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAiBa;qBAEA,4BAA0B,KAAA;;;;;YAS3B,uBAAuB,cAAc"}

package/dist/schemas/agentModel.mjs

@@ -0,0 +1,32 @@
+import { Type } from "typebox";
+//#region src/schemas/agentModel.ts
+/**
+* The custom session entry the runtime journals when the agent's model changes
+* without a client having asked for it.
+*
+* Pi reports a thinking-level switch on the wire as `thinking_level_changed`,
+* so a cockpit can follow that field from the frame alone. It has no matching
+* event for the model: `model_select` is delivered to extensions inside the
+* agent process and never leaves it. A client therefore learns about a model
+* an extension chose (plan mode applying its configured planning model) only
+* by asking for `get_state`, which nothing prompts it to do.
+*
+* This entry closes that gap on the road the minor-mode projection already
+* uses: it rides Pi's `entry_appended` frames, so any RPC client sees the
+* change live and on replay without a new protocol.
+*/
+const DOOM_AGENT_MODEL_ENTRY_TYPE = "doom-agent-model";
+const AgentModelProjectionSchema = Type.Object({
+	provider: Type.String({
+		minLength: 1,
+		maxLength: 128
+	}),
+	id: Type.String({
+		minLength: 1,
+		maxLength: 256
+	})
+}, { additionalProperties: false });
+//#endregion
+export { AgentModelProjectionSchema, DOOM_AGENT_MODEL_ENTRY_TYPE };
+
+//# sourceMappingURL=agentModel.mjs.map

package/dist/schemas/agentModel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentModel.mjs","names":[],"sources":["../../src/schemas/agentModel.ts"],"sourcesContent":["import { type Static, Type } from 'typebox';\n\n/**\n * The custom session entry the runtime journals when the agent's model changes\n * without a client having asked for it.\n *\n * Pi reports a thinking-level switch on the wire as `thinking_level_changed`,\n * so a cockpit can follow that field from the frame alone. It has no matching\n * event for the model: `model_select` is delivered to extensions inside the\n * agent process and never leaves it. A client therefore learns about a model\n * an extension chose (plan mode applying its configured planning model) only\n * by asking for `get_state`, which nothing prompts it to do.\n *\n * This entry closes that gap on the road the minor-mode projection already\n * uses: it rides Pi's `entry_appended` frames, so any RPC client sees the\n * change live and on replay without a new protocol.\n */\nexport const DOOM_AGENT_MODEL_ENTRY_TYPE = 'doom-agent-model';\n\nexport const AgentModelProjectionSchema = Type.Object(\n  {\n    provider: Type.String({ minLength: 1, maxLength: 128 }),\n    id: Type.String({ minLength: 1, maxLength: 256 }),\n  },\n  { additionalProperties: false },\n);\n\n/** The model the agent is on, named the way `set_model` and `get_state` name it. */\nexport type AgentModelProjection = Static<typeof AgentModelProjectionSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,MAAa,8BAA8B;AAE3C,MAAa,6BAA6B,KAAK,OAC7C;CACE,UAAU,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAI,CAAC;CACtD,IAAI,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAI,CAAC;AAClD,GACA,EAAE,sBAAsB,MAAM,CAChC"}

package/dist/schemas/apiContracts.cjs

@@ -0,0 +1,145 @@
+let typebox = require("typebox");
+let typebox_value = require("typebox/value");
+//#region src/schemas/apiContracts.ts
+const DOOM_API_CONTRACT_VERSION = 1;
+const DOOM_API_CONTRACT_FILE = "contracts.json";
+const Schema = typebox.Type.Unsafe(typebox.Type.Union([typebox.Type.Boolean(), typebox.Type.Record(typebox.Type.String(), typebox.Type.Unknown())]));
+const Scope = typebox.Type.Union([
+	typebox.Type.Literal("global"),
+	typebox.Type.Literal("workspace"),
+	typebox.Type.Literal("session")
+]);
+const Named = typebox.Type.String({ minLength: 1 });
+const ResponseSchema = typebox.Type.Object({
+	description: Named,
+	contentType: typebox.Type.Optional(Named),
+	schema: typebox.Type.Optional(Schema),
+	events: typebox.Type.Optional(typebox.Type.Record(Named, Schema))
+});
+/** Data-only package entry. Schemas use JSON Schema draft-07, including TypeBox output; OpenAPI export translates tuple keywords. */
+const DoomApiContractSchema = typebox.Type.Object({
+	version: typebox.Type.Literal(1),
+	protocols: typebox.Type.Optional(typebox.Type.Record(Named, Named)),
+	schemas: typebox.Type.Optional(typebox.Type.Record(Named, Schema)),
+	http: typebox.Type.Array(typebox.Type.Object({
+		id: Named,
+		scope: Scope,
+		/** Omit for host-owned absolute routes. */
+		basePath: typebox.Type.Optional(typebox.Type.String({ pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$" })),
+		path: typebox.Type.String({ pattern: "^/" }),
+		method: typebox.Type.Union([
+			typebox.Type.Literal("GET"),
+			typebox.Type.Literal("POST"),
+			typebox.Type.Literal("PUT"),
+			typebox.Type.Literal("PATCH"),
+			typebox.Type.Literal("DELETE"),
+			typebox.Type.Literal("HEAD"),
+			typebox.Type.Literal("OPTIONS")
+		]),
+		description: Named,
+		availability: typebox.Type.Optional(Named),
+		authentication: typebox.Type.Union([
+			typebox.Type.Literal("none"),
+			typebox.Type.Literal("owner"),
+			typebox.Type.Literal("device")
+		]),
+		parameters: typebox.Type.Optional(typebox.Type.Array(typebox.Type.Object({
+			name: Named,
+			in: typebox.Type.Union([
+				typebox.Type.Literal("path"),
+				typebox.Type.Literal("query"),
+				typebox.Type.Literal("header")
+			]),
+			required: typebox.Type.Boolean(),
+			schema: Schema
+		}))),
+		body: typebox.Type.Optional(typebox.Type.Object({
+			contentType: Named,
+			contentTypes: typebox.Type.Optional(typebox.Type.Array(Named, { minItems: 1 })),
+			required: typebox.Type.Boolean(),
+			schema: Schema
+		})),
+		responses: typebox.Type.Record(typebox.Type.String({ pattern: "^(?:[1-5][0-9]{2}|default)$" }), ResponseSchema, { minProperties: 1 })
+	})),
+	sockets: typebox.Type.Array(typebox.Type.Object({
+		id: Named,
+		scope: Scope,
+		description: Named,
+		availability: typebox.Type.Optional(Named),
+		service: Named,
+		member: Named,
+		direction: typebox.Type.Union([typebox.Type.Literal("client-to-server"), typebox.Type.Literal("server-to-client")]),
+		kind: typebox.Type.Union([
+			typebox.Type.Literal("method"),
+			typebox.Type.Literal("state"),
+			typebox.Type.Literal("channel")
+		]),
+		input: Schema,
+		output: typebox.Type.Optional(Schema),
+		errors: typebox.Type.Optional(Schema)
+	})),
+	/** Explicitly enumerate dynamic values whose shape is supplied at runtime. */
+	dynamic: typebox.Type.Array(typebox.Type.String({ minLength: 1 })),
+	gaps: typebox.Type.Optional(typebox.Type.Array(Named))
+});
+function defineApiContract(contract) {
+	return contract;
+}
+function parseApiContract(value) {
+	if (!(0, typebox_value.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 = typebox.Type.Object({
+		packageName: Named,
+		packageVersion: Named,
+		scopes: typebox.Type.Array(Scope, { uniqueItems: true }),
+		owners: typebox.Type.Array(typebox.Type.Object({
+			majorMode: Named,
+			layer: Named
+		}), { minItems: 1 }),
+		contract: typebox.Type.Optional(DoomApiContractSchema),
+		problem: typebox.Type.Optional(Named),
+		module: typebox.Type.Optional(typebox.Type.String({ pattern: "^\\./[^\\\\%?#]+$" }))
+	});
+	const CompiledSchema = typebox.Type.Object({
+		version: typebox.Type.Literal(1),
+		generation: Named,
+		fingerprint: typebox.Type.String({ pattern: "^[a-f0-9]{64}$" }),
+		packages: typebox.Type.Array(PackageSchema)
+	});
+	if (!(0, typebox_value.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
+exports.DOOM_API_CONTRACT_FILE = DOOM_API_CONTRACT_FILE;
+exports.DOOM_API_CONTRACT_VERSION = DOOM_API_CONTRACT_VERSION;
+exports.DoomApiContractSchema = DoomApiContractSchema;
+exports.defineApiContract = defineApiContract;
+exports.parseApiContract = parseApiContract;
+exports.parseCompiledContracts = parseCompiledContracts;
+
+//# sourceMappingURL=apiContracts.cjs.map

package/dist/schemas/apiContracts.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiContracts.cjs","names":["Type","Check"],"sources":["../../src/schemas/apiContracts.ts"],"sourcesContent":["import { type Static, Type } from 'typebox';\nimport { Check } from 'typebox/value';\n\nimport type { DoomApiScope } from './packageApi';\nimport type { DoomServerBundleOwner } from './serverBundle';\n\nexport const DOOM_API_CONTRACT_VERSION = 1;\nexport const DOOM_API_CONTRACT_FILE = 'contracts.json';\nconst Schema = Type.Unsafe<object | boolean>(Type.Union([Type.Boolean(), Type.Record(Type.String(), Type.Unknown())]));\nconst Scope = Type.Union([Type.Literal('global'), Type.Literal('workspace'), Type.Literal('session')]);\nconst Named = Type.String({ minLength: 1 });\nconst ResponseSchema = Type.Object({\n  description: Named,\n  contentType: Type.Optional(Named),\n  schema: Type.Optional(Schema),\n  events: Type.Optional(Type.Record(Named, Schema)),\n});\n\n/** Data-only package entry. Schemas use JSON Schema draft-07, including TypeBox output; OpenAPI export translates tuple keywords. */\nexport const DoomApiContractSchema = Type.Object({\n  version: Type.Literal(DOOM_API_CONTRACT_VERSION),\n  protocols: Type.Optional(Type.Record(Named, Named)),\n  schemas: Type.Optional(Type.Record(Named, Schema)),\n  http: Type.Array(\n    Type.Object({\n      id: Named,\n      scope: Scope,\n      /** Omit for host-owned absolute routes. */\n      basePath: Type.Optional(Type.String({ pattern: '^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$' })),\n      path: Type.String({ pattern: '^/' }),\n      method: Type.Union([\n        Type.Literal('GET'),\n        Type.Literal('POST'),\n        Type.Literal('PUT'),\n        Type.Literal('PATCH'),\n        Type.Literal('DELETE'),\n        Type.Literal('HEAD'),\n        Type.Literal('OPTIONS'),\n      ]),\n      description: Named,\n      availability: Type.Optional(Named),\n      authentication: Type.Union([Type.Literal('none'), Type.Literal('owner'), Type.Literal('device')]),\n      parameters: Type.Optional(\n        Type.Array(\n          Type.Object({\n            name: Named,\n            in: Type.Union([Type.Literal('path'), Type.Literal('query'), Type.Literal('header')]),\n            required: Type.Boolean(),\n            schema: Schema,\n          }),\n        ),\n      ),\n      body: Type.Optional(\n        Type.Object({\n          contentType: Named,\n          contentTypes: Type.Optional(Type.Array(Named, { minItems: 1 })),\n          required: Type.Boolean(),\n          schema: Schema,\n        }),\n      ),\n      responses: Type.Record(Type.String({ pattern: '^(?:[1-5][0-9]{2}|default)$' }), ResponseSchema, {\n        minProperties: 1,\n      }),\n    }),\n  ),\n  sockets: Type.Array(\n    Type.Object({\n      id: Named,\n      scope: Scope,\n      description: Named,\n      availability: Type.Optional(Named),\n      service: Named,\n      member: Named,\n      direction: Type.Union([Type.Literal('client-to-server'), Type.Literal('server-to-client')]),\n      kind: Type.Union([Type.Literal('method'), Type.Literal('state'), Type.Literal('channel')]),\n      input: Schema,\n      output: Type.Optional(Schema),\n      errors: Type.Optional(Schema),\n    }),\n  ),\n  /** Explicitly enumerate dynamic values whose shape is supplied at runtime. */\n  dynamic: Type.Array(Type.String({ minLength: 1 })),\n  gaps: Type.Optional(Type.Array(Named)),\n});\n\nexport type DoomApiContract = Static<typeof DoomApiContractSchema>;\nexport type DoomHttpContract = DoomApiContract['http'][number];\nexport type DoomSocketContract = DoomApiContract['sockets'][number];\n\nexport function defineApiContract(contract: DoomApiContract): DoomApiContract {\n  return contract;\n}\n\nexport function parseApiContract(value: unknown): DoomApiContract {\n  if (!Check(DoomApiContractSchema, value)) throw new Error('Invalid DoomPi API contract');\n  const contract = value as DoomApiContract;\n  const ids = new Set<string>();\n  for (const entry of [...contract.http, ...contract.sockets]) {\n    const key = `${entry.scope}:${entry.id}`;\n    if (ids.has(key)) throw new Error(`Duplicate API contract operation: ${key}`);\n    ids.add(key);\n  }\n  // Reject non-JSON data rather than silently losing it during export.\n  const visit = (item: unknown, ancestors: Set<object>): void => {\n    if (item === null || typeof item === 'string' || typeof item === 'boolean') return;\n    if (typeof item === 'number' && Number.isFinite(item)) return;\n    if (typeof item !== 'object' || ancestors.has(item)) throw new Error('API contracts must contain finite JSON data');\n    ancestors.add(item);\n    for (const child of Object.values(item)) visit(child, ancestors);\n    ancestors.delete(item);\n  };\n  visit(contract, new Set());\n  return contract;\n}\n\nexport interface DoomPackageContract {\n  packageName: string;\n  packageVersion: string;\n  scopes: readonly DoomApiScope[];\n  owners: readonly DoomServerBundleOwner[];\n  contract?: DoomApiContract;\n  problem?: string;\n  /** Generation-relative compiler output, never imported by the export command. */\n  module?: string;\n}\n\nexport interface DoomCompiledContracts {\n  version: typeof DOOM_API_CONTRACT_VERSION;\n  generation: string;\n  fingerprint: string;\n  packages: DoomPackageContract[];\n}\n\nexport function parseCompiledContracts(value: unknown): DoomCompiledContracts {\n  const PackageSchema = Type.Object({\n    packageName: Named,\n    packageVersion: Named,\n    scopes: Type.Array(Scope, { uniqueItems: true }),\n    owners: Type.Array(Type.Object({ majorMode: Named, layer: Named }), { minItems: 1 }),\n    contract: Type.Optional(DoomApiContractSchema),\n    problem: Type.Optional(Named),\n    module: Type.Optional(Type.String({ pattern: '^\\\\./[^\\\\\\\\%?#]+$' })),\n  });\n  const CompiledSchema = Type.Object({\n    version: Type.Literal(DOOM_API_CONTRACT_VERSION),\n    generation: Named,\n    fingerprint: Type.String({ pattern: '^[a-f0-9]{64}$' }),\n    packages: Type.Array(PackageSchema),\n  });\n  if (!Check(CompiledSchema, value)) throw new Error('Invalid compiled API contracts');\n  const data = value as DoomCompiledContracts;\n  const names = new Set<string>();\n  for (const entry of data.packages) {\n    if (names.has(entry.packageName) || entry.module?.split('/').includes('..'))\n      throw new Error('Invalid compiled package contract');\n    names.add(entry.packageName);\n    if (entry.contract !== undefined) parseApiContract(entry.contract);\n  }\n  return data;\n}\n"],"mappings":"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"}

package/dist/schemas/apiContracts.d.cts

@@ -0,0 +1,81 @@
+import { DoomApiScope } from "./packageApi.cjs";
+import { DoomServerBundleOwner } from "./serverBundle.cjs";
+import { Static, Type } from "typebox";
+//#region src/schemas/apiContracts.d.ts
+export declare const DOOM_API_CONTRACT_VERSION = 1;
+export declare const DOOM_API_CONTRACT_FILE = "contracts.json";
+/** Data-only package entry. Schemas use JSON Schema draft-07, including TypeBox output; OpenAPI export translates tuple keywords. */
+export declare const DoomApiContractSchema: Type.TObject<{
+  version: Type.TLiteral<1>;
+  protocols: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+  schemas: Type.TOptional<Type.TRecord<"^.*$", Type.TUnsafe<boolean | object>>>;
+  http: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    scope: Type.TUnion<[Type.TLiteral<"global">, Type.TLiteral<"workspace">, Type.TLiteral<"session">]>;
+    /** Omit for host-owned absolute routes. */
+    basePath: Type.TOptional<Type.TString>;
+    path: Type.TString;
+    method: Type.TUnion<[Type.TLiteral<"GET">, Type.TLiteral<"POST">, Type.TLiteral<"PUT">, Type.TLiteral<"PATCH">, Type.TLiteral<"DELETE">, Type.TLiteral<"HEAD">, Type.TLiteral<"OPTIONS">]>;
+    description: Type.TString;
+    availability: Type.TOptional<Type.TString>;
+    authentication: Type.TUnion<[Type.TLiteral<"none">, Type.TLiteral<"owner">, Type.TLiteral<"device">]>;
+    parameters: Type.TOptional<Type.TArray<Type.TObject<{
+      name: Type.TString;
+      in: Type.TUnion<[Type.TLiteral<"path">, Type.TLiteral<"query">, Type.TLiteral<"header">]>;
+      required: Type.TBoolean;
+      schema: Type.TUnsafe<boolean | object>;
+    }>>>;
+    body: Type.TOptional<Type.TObject<{
+      contentType: Type.TString;
+      contentTypes: Type.TOptional<Type.TArray<Type.TString>>;
+      required: Type.TBoolean;
+      schema: Type.TUnsafe<boolean | object>;
+    }>>;
+    responses: Type.TRecord<"^.*$", Type.TObject<{
+      description: Type.TString;
+      contentType: Type.TOptional<Type.TString>;
+      schema: Type.TOptional<Type.TUnsafe<boolean | object>>;
+      events: Type.TOptional<Type.TRecord<"^.*$", Type.TUnsafe<boolean | object>>>;
+    }>>;
+  }>>;
+  sockets: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    scope: Type.TUnion<[Type.TLiteral<"global">, Type.TLiteral<"workspace">, Type.TLiteral<"session">]>;
+    description: Type.TString;
+    availability: Type.TOptional<Type.TString>;
+    service: Type.TString;
+    member: Type.TString;
+    direction: Type.TUnion<[Type.TLiteral<"client-to-server">, Type.TLiteral<"server-to-client">]>;
+    kind: Type.TUnion<[Type.TLiteral<"method">, Type.TLiteral<"state">, Type.TLiteral<"channel">]>;
+    input: Type.TUnsafe<boolean | object>;
+    output: Type.TOptional<Type.TUnsafe<boolean | object>>;
+    errors: Type.TOptional<Type.TUnsafe<boolean | object>>;
+  }>>;
+  /** Explicitly enumerate dynamic values whose shape is supplied at runtime. */
+  dynamic: Type.TArray<Type.TString>;
+  gaps: Type.TOptional<Type.TArray<Type.TString>>;
+}>;
+export type DoomApiContract = Static<typeof DoomApiContractSchema>;
+export type DoomHttpContract = DoomApiContract['http'][number];
+export type DoomSocketContract = DoomApiContract['sockets'][number];
+export declare function defineApiContract(contract: DoomApiContract): DoomApiContract;
+export declare function parseApiContract(value: unknown): DoomApiContract;
+export interface DoomPackageContract {
+  packageName: string;
+  packageVersion: string;
+  scopes: readonly DoomApiScope[];
+  owners: readonly DoomServerBundleOwner[];
+  contract?: DoomApiContract;
+  problem?: string;
+  /** Generation-relative compiler output, never imported by the export command. */
+  module?: string;
+}
+export interface DoomCompiledContracts {
+  version: typeof DOOM_API_CONTRACT_VERSION;
+  generation: string;
+  fingerprint: string;
+  packages: DoomPackageContract[];
+}
+export declare function parseCompiledContracts(value: unknown): DoomCompiledContracts;
+//#endregion
+//# sourceMappingURL=apiContracts.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apiContracts.d.cts","names":[],"sources":["../../src/schemas/apiContracts.ts"],"mappings":";;;;qBAMa;qBACA;;qBAYA,uBAAqB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkEtB,kBAAkB,cAAc;YAChC,mBAAmB;YACnB,qBAAqB;wBAEjB,kBAAkB,UAAU,kBAAkB;wBAI9C,iBAAiB,iBAAiB;iBAsBjC;EACf;EACA;EACA,iBAAiB;EACjB,iBAAiB;EACjB,WAAW;EACX;;EAEA;;iBAGe;EACf,gBAAgB;EAChB;EACA;EACA,UAAU;;wBAGI,uBAAuB,iBAAiB"}

package/dist/schemas/apiContracts.d.mts

@@ -0,0 +1,81 @@
+import { DoomApiScope } from "./packageApi.mjs";
+import { DoomServerBundleOwner } from "./serverBundle.mjs";
+import { Static, Type } from "typebox";
+//#region src/schemas/apiContracts.d.ts
+export declare const DOOM_API_CONTRACT_VERSION = 1;
+export declare const DOOM_API_CONTRACT_FILE = "contracts.json";
+/** Data-only package entry. Schemas use JSON Schema draft-07, including TypeBox output; OpenAPI export translates tuple keywords. */
+export declare const DoomApiContractSchema: Type.TObject<{
+  version: Type.TLiteral<1>;
+  protocols: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+  schemas: Type.TOptional<Type.TRecord<"^.*$", Type.TUnsafe<boolean | object>>>;
+  http: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    scope: Type.TUnion<[Type.TLiteral<"global">, Type.TLiteral<"workspace">, Type.TLiteral<"session">]>;
+    /** Omit for host-owned absolute routes. */
+    basePath: Type.TOptional<Type.TString>;
+    path: Type.TString;
+    method: Type.TUnion<[Type.TLiteral<"GET">, Type.TLiteral<"POST">, Type.TLiteral<"PUT">, Type.TLiteral<"PATCH">, Type.TLiteral<"DELETE">, Type.TLiteral<"HEAD">, Type.TLiteral<"OPTIONS">]>;
+    description: Type.TString;
+    availability: Type.TOptional<Type.TString>;
+    authentication: Type.TUnion<[Type.TLiteral<"none">, Type.TLiteral<"owner">, Type.TLiteral<"device">]>;
+    parameters: Type.TOptional<Type.TArray<Type.TObject<{
+      name: Type.TString;
+      in: Type.TUnion<[Type.TLiteral<"path">, Type.TLiteral<"query">, Type.TLiteral<"header">]>;
+      required: Type.TBoolean;
+      schema: Type.TUnsafe<boolean | object>;
+    }>>>;
+    body: Type.TOptional<Type.TObject<{
+      contentType: Type.TString;
+      contentTypes: Type.TOptional<Type.TArray<Type.TString>>;
+      required: Type.TBoolean;
+      schema: Type.TUnsafe<boolean | object>;
+    }>>;
+    responses: Type.TRecord<"^.*$", Type.TObject<{
+      description: Type.TString;
+      contentType: Type.TOptional<Type.TString>;
+      schema: Type.TOptional<Type.TUnsafe<boolean | object>>;
+      events: Type.TOptional<Type.TRecord<"^.*$", Type.TUnsafe<boolean | object>>>;
+    }>>;
+  }>>;
+  sockets: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    scope: Type.TUnion<[Type.TLiteral<"global">, Type.TLiteral<"workspace">, Type.TLiteral<"session">]>;
+    description: Type.TString;
+    availability: Type.TOptional<Type.TString>;
+    service: Type.TString;
+    member: Type.TString;
+    direction: Type.TUnion<[Type.TLiteral<"client-to-server">, Type.TLiteral<"server-to-client">]>;
+    kind: Type.TUnion<[Type.TLiteral<"method">, Type.TLiteral<"state">, Type.TLiteral<"channel">]>;
+    input: Type.TUnsafe<boolean | object>;
+    output: Type.TOptional<Type.TUnsafe<boolean | object>>;
+    errors: Type.TOptional<Type.TUnsafe<boolean | object>>;
+  }>>;
+  /** Explicitly enumerate dynamic values whose shape is supplied at runtime. */
+  dynamic: Type.TArray<Type.TString>;
+  gaps: Type.TOptional<Type.TArray<Type.TString>>;
+}>;
+export type DoomApiContract = Static<typeof DoomApiContractSchema>;
+export type DoomHttpContract = DoomApiContract['http'][number];
+export type DoomSocketContract = DoomApiContract['sockets'][number];
+export declare function defineApiContract(contract: DoomApiContract): DoomApiContract;
+export declare function parseApiContract(value: unknown): DoomApiContract;
+export interface DoomPackageContract {
+  packageName: string;
+  packageVersion: string;
+  scopes: readonly DoomApiScope[];
+  owners: readonly DoomServerBundleOwner[];
+  contract?: DoomApiContract;
+  problem?: string;
+  /** Generation-relative compiler output, never imported by the export command. */
+  module?: string;
+}
+export interface DoomCompiledContracts {
+  version: typeof DOOM_API_CONTRACT_VERSION;
+  generation: string;
+  fingerprint: string;
+  packages: DoomPackageContract[];
+}
+export declare function parseCompiledContracts(value: unknown): DoomCompiledContracts;
+//#endregion
+//# sourceMappingURL=apiContracts.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apiContracts.d.mts","names":[],"sources":["../../src/schemas/apiContracts.ts"],"mappings":";;;;qBAMa;qBACA;;qBAYA,uBAAqB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkEtB,kBAAkB,cAAc;YAChC,mBAAmB;YACnB,qBAAqB;wBAEjB,kBAAkB,UAAU,kBAAkB;wBAI9C,iBAAiB,iBAAiB;iBAsBjC;EACf;EACA;EACA,iBAAiB;EACjB,iBAAiB;EACjB,WAAW;EACX;;EAEA;;iBAGe;EACf,gBAAgB;EAChB;EACA;EACA,UAAU;;wBAGI,uBAAuB,iBAAiB"}

package/dist/schemas/apiContracts.mjs

@@ -0,0 +1,140 @@
+import { Type } from "typebox";
+import { Check } from "typebox/value";
+//#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
+export { DOOM_API_CONTRACT_FILE, DOOM_API_CONTRACT_VERSION, DoomApiContractSchema, defineApiContract, parseApiContract, parseCompiledContracts };
+
+//# sourceMappingURL=apiContracts.mjs.map

package/dist/schemas/apiContracts.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiContracts.mjs","names":[],"sources":["../../src/schemas/apiContracts.ts"],"sourcesContent":["import { type Static, Type } from 'typebox';\nimport { Check } from 'typebox/value';\n\nimport type { DoomApiScope } from './packageApi';\nimport type { DoomServerBundleOwner } from './serverBundle';\n\nexport const DOOM_API_CONTRACT_VERSION = 1;\nexport const DOOM_API_CONTRACT_FILE = 'contracts.json';\nconst Schema = Type.Unsafe<object | boolean>(Type.Union([Type.Boolean(), Type.Record(Type.String(), Type.Unknown())]));\nconst Scope = Type.Union([Type.Literal('global'), Type.Literal('workspace'), Type.Literal('session')]);\nconst Named = Type.String({ minLength: 1 });\nconst ResponseSchema = Type.Object({\n  description: Named,\n  contentType: Type.Optional(Named),\n  schema: Type.Optional(Schema),\n  events: Type.Optional(Type.Record(Named, Schema)),\n});\n\n/** Data-only package entry. Schemas use JSON Schema draft-07, including TypeBox output; OpenAPI export translates tuple keywords. */\nexport const DoomApiContractSchema = Type.Object({\n  version: Type.Literal(DOOM_API_CONTRACT_VERSION),\n  protocols: Type.Optional(Type.Record(Named, Named)),\n  schemas: Type.Optional(Type.Record(Named, Schema)),\n  http: Type.Array(\n    Type.Object({\n      id: Named,\n      scope: Scope,\n      /** Omit for host-owned absolute routes. */\n      basePath: Type.Optional(Type.String({ pattern: '^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$' })),\n      path: Type.String({ pattern: '^/' }),\n      method: Type.Union([\n        Type.Literal('GET'),\n        Type.Literal('POST'),\n        Type.Literal('PUT'),\n        Type.Literal('PATCH'),\n        Type.Literal('DELETE'),\n        Type.Literal('HEAD'),\n        Type.Literal('OPTIONS'),\n      ]),\n      description: Named,\n      availability: Type.Optional(Named),\n      authentication: Type.Union([Type.Literal('none'), Type.Literal('owner'), Type.Literal('device')]),\n      parameters: Type.Optional(\n        Type.Array(\n          Type.Object({\n            name: Named,\n            in: Type.Union([Type.Literal('path'), Type.Literal('query'), Type.Literal('header')]),\n            required: Type.Boolean(),\n            schema: Schema,\n          }),\n        ),\n      ),\n      body: Type.Optional(\n        Type.Object({\n          contentType: Named,\n          contentTypes: Type.Optional(Type.Array(Named, { minItems: 1 })),\n          required: Type.Boolean(),\n          schema: Schema,\n        }),\n      ),\n      responses: Type.Record(Type.String({ pattern: '^(?:[1-5][0-9]{2}|default)$' }), ResponseSchema, {\n        minProperties: 1,\n      }),\n    }),\n  ),\n  sockets: Type.Array(\n    Type.Object({\n      id: Named,\n      scope: Scope,\n      description: Named,\n      availability: Type.Optional(Named),\n      service: Named,\n      member: Named,\n      direction: Type.Union([Type.Literal('client-to-server'), Type.Literal('server-to-client')]),\n      kind: Type.Union([Type.Literal('method'), Type.Literal('state'), Type.Literal('channel')]),\n      input: Schema,\n      output: Type.Optional(Schema),\n      errors: Type.Optional(Schema),\n    }),\n  ),\n  /** Explicitly enumerate dynamic values whose shape is supplied at runtime. */\n  dynamic: Type.Array(Type.String({ minLength: 1 })),\n  gaps: Type.Optional(Type.Array(Named)),\n});\n\nexport type DoomApiContract = Static<typeof DoomApiContractSchema>;\nexport type DoomHttpContract = DoomApiContract['http'][number];\nexport type DoomSocketContract = DoomApiContract['sockets'][number];\n\nexport function defineApiContract(contract: DoomApiContract): DoomApiContract {\n  return contract;\n}\n\nexport function parseApiContract(value: unknown): DoomApiContract {\n  if (!Check(DoomApiContractSchema, value)) throw new Error('Invalid DoomPi API contract');\n  const contract = value as DoomApiContract;\n  const ids = new Set<string>();\n  for (const entry of [...contract.http, ...contract.sockets]) {\n    const key = `${entry.scope}:${entry.id}`;\n    if (ids.has(key)) throw new Error(`Duplicate API contract operation: ${key}`);\n    ids.add(key);\n  }\n  // Reject non-JSON data rather than silently losing it during export.\n  const visit = (item: unknown, ancestors: Set<object>): void => {\n    if (item === null || typeof item === 'string' || typeof item === 'boolean') return;\n    if (typeof item === 'number' && Number.isFinite(item)) return;\n    if (typeof item !== 'object' || ancestors.has(item)) throw new Error('API contracts must contain finite JSON data');\n    ancestors.add(item);\n    for (const child of Object.values(item)) visit(child, ancestors);\n    ancestors.delete(item);\n  };\n  visit(contract, new Set());\n  return contract;\n}\n\nexport interface DoomPackageContract {\n  packageName: string;\n  packageVersion: string;\n  scopes: readonly DoomApiScope[];\n  owners: readonly DoomServerBundleOwner[];\n  contract?: DoomApiContract;\n  problem?: string;\n  /** Generation-relative compiler output, never imported by the export command. */\n  module?: string;\n}\n\nexport interface DoomCompiledContracts {\n  version: typeof DOOM_API_CONTRACT_VERSION;\n  generation: string;\n  fingerprint: string;\n  packages: DoomPackageContract[];\n}\n\nexport function parseCompiledContracts(value: unknown): DoomCompiledContracts {\n  const PackageSchema = Type.Object({\n    packageName: Named,\n    packageVersion: Named,\n    scopes: Type.Array(Scope, { uniqueItems: true }),\n    owners: Type.Array(Type.Object({ majorMode: Named, layer: Named }), { minItems: 1 }),\n    contract: Type.Optional(DoomApiContractSchema),\n    problem: Type.Optional(Named),\n    module: Type.Optional(Type.String({ pattern: '^\\\\./[^\\\\\\\\%?#]+$' })),\n  });\n  const CompiledSchema = Type.Object({\n    version: Type.Literal(DOOM_API_CONTRACT_VERSION),\n    generation: Named,\n    fingerprint: Type.String({ pattern: '^[a-f0-9]{64}$' }),\n    packages: Type.Array(PackageSchema),\n  });\n  if (!Check(CompiledSchema, value)) throw new Error('Invalid compiled API contracts');\n  const data = value as DoomCompiledContracts;\n  const names = new Set<string>();\n  for (const entry of data.packages) {\n    if (names.has(entry.packageName) || entry.module?.split('/').includes('..'))\n      throw new Error('Invalid compiled package contract');\n    names.add(entry.packageName);\n    if (entry.contract !== undefined) parseApiContract(entry.contract);\n  }\n  return data;\n}\n"],"mappings":"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"}

package/dist/schemas/askUser.cjs

@@ -0,0 +1,42 @@
+let typebox = require("typebox");
+//#region src/schemas/askUser.ts
+/** Namespaced Cordis events emitted by the ask-user provider. */
+const DOOM_ASK_USER_PROMPT_EVENT = "doom/ask-user/prompt";
+const DOOM_ASK_USER_BLOCKED_EVENT = "doom/ask-user/blocked";
+const MAX_QUESTIONS = 3;
+const MAX_OPTIONS = 16;
+const MAX_TEXT_LENGTH = 4096;
+const AskUserPromptOptionSchema = typebox.Type.Object({
+	label: typebox.Type.String({
+		minLength: 1,
+		maxLength: MAX_TEXT_LENGTH
+	}),
+	description: typebox.Type.String({ maxLength: MAX_TEXT_LENGTH }),
+	hasPreview: typebox.Type.Boolean()
+}, { additionalProperties: false });
+const AskUserPromptQuestionSchema = typebox.Type.Object({
+	question: typebox.Type.String({
+		minLength: 1,
+		maxLength: MAX_TEXT_LENGTH
+	}),
+	header: typebox.Type.String({
+		minLength: 1,
+		maxLength: MAX_TEXT_LENGTH
+	}),
+	multiSelect: typebox.Type.Boolean(),
+	options: typebox.Type.Array(AskUserPromptOptionSchema, { maxItems: MAX_OPTIONS })
+}, { additionalProperties: false });
+const AskUserPromptEventSchema = typebox.Type.Object({ questions: typebox.Type.Array(AskUserPromptQuestionSchema, {
+	minItems: 1,
+	maxItems: MAX_QUESTIONS
+}) }, { additionalProperties: false });
+const AskUserBlockedEventSchema = typebox.Type.Object({ active: typebox.Type.Boolean() }, { additionalProperties: false });
+//#endregion
+exports.AskUserBlockedEventSchema = AskUserBlockedEventSchema;
+exports.AskUserPromptEventSchema = AskUserPromptEventSchema;
+exports.AskUserPromptOptionSchema = AskUserPromptOptionSchema;
+exports.AskUserPromptQuestionSchema = AskUserPromptQuestionSchema;
+exports.DOOM_ASK_USER_BLOCKED_EVENT = DOOM_ASK_USER_BLOCKED_EVENT;
+exports.DOOM_ASK_USER_PROMPT_EVENT = DOOM_ASK_USER_PROMPT_EVENT;
+
+//# sourceMappingURL=askUser.cjs.map

package/dist/schemas/askUser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"askUser.cjs","names":["Type"],"sources":["../../src/schemas/askUser.ts"],"sourcesContent":["import { type Static, Type } from 'typebox';\n\n/** Namespaced Cordis events emitted by the ask-user provider. */\nexport const DOOM_ASK_USER_PROMPT_EVENT = 'doom/ask-user/prompt';\nexport const DOOM_ASK_USER_BLOCKED_EVENT = 'doom/ask-user/blocked';\n\nconst MAX_QUESTIONS = 3;\nconst MAX_OPTIONS = 16;\nconst MAX_TEXT_LENGTH = 4_096;\n\nexport const AskUserPromptOptionSchema = Type.Object(\n  {\n    label: Type.String({ minLength: 1, maxLength: MAX_TEXT_LENGTH }),\n    description: Type.String({ maxLength: MAX_TEXT_LENGTH }),\n    hasPreview: Type.Boolean(),\n  },\n  { additionalProperties: false },\n);\nexport type AskUserPromptOption = Static<typeof AskUserPromptOptionSchema>;\n\nexport const AskUserPromptQuestionSchema = Type.Object(\n  {\n    question: Type.String({ minLength: 1, maxLength: MAX_TEXT_LENGTH }),\n    header: Type.String({ minLength: 1, maxLength: MAX_TEXT_LENGTH }),\n    multiSelect: Type.Boolean(),\n    options: Type.Array(AskUserPromptOptionSchema, { maxItems: MAX_OPTIONS }),\n  },\n  { additionalProperties: false },\n);\nexport type AskUserPromptQuestion = Static<typeof AskUserPromptQuestionSchema>;\n\nexport const AskUserPromptEventSchema = Type.Object(\n  { questions: Type.Array(AskUserPromptQuestionSchema, { minItems: 1, maxItems: MAX_QUESTIONS }) },\n  { additionalProperties: false },\n);\nexport type AskUserPromptEvent = Static<typeof AskUserPromptEventSchema>;\n\nexport const AskUserBlockedEventSchema = Type.Object({ active: Type.Boolean() }, { additionalProperties: false });\nexport type AskUserBlockedEvent = Static<typeof AskUserBlockedEventSchema>;\n\ndeclare module '@deepseek-ai/cordis' {\n  interface Events {\n    'doom/ask-user/prompt'(event: AskUserPromptEvent): void;\n    'doom/ask-user/blocked'(event: AskUserBlockedEvent): void;\n  }\n}\n"],"mappings":";;;AAGA,MAAa,6BAA6B;AAC1C,MAAa,8BAA8B;AAE3C,MAAM,gBAAgB;AACtB,MAAM,cAAc;AACpB,MAAM,kBAAkB;AAExB,MAAa,4BAA4BA,QAAAA,KAAK,OAC5C;CACE,OAAOA,QAAAA,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAgB,CAAC;CAC/D,aAAaA,QAAAA,KAAK,OAAO,EAAE,WAAW,gBAAgB,CAAC;CACvD,YAAYA,QAAAA,KAAK,QAAQ;AAC3B,GACA,EAAE,sBAAsB,MAAM,CAChC;AAGA,MAAa,8BAA8BA,QAAAA,KAAK,OAC9C;CACE,UAAUA,QAAAA,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAgB,CAAC;CAClE,QAAQA,QAAAA,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAgB,CAAC;CAChE,aAAaA,QAAAA,KAAK,QAAQ;CAC1B,SAASA,QAAAA,KAAK,MAAM,2BAA2B,EAAE,UAAU,YAAY,CAAC;AAC1E,GACA,EAAE,sBAAsB,MAAM,CAChC;AAGA,MAAa,2BAA2BA,QAAAA,KAAK,OAC3C,EAAE,WAAWA,QAAAA,KAAK,MAAM,6BAA6B;CAAE,UAAU;CAAG,UAAU;AAAc,CAAC,EAAE,GAC/F,EAAE,sBAAsB,MAAM,CAChC;AAGA,MAAa,4BAA4BA,QAAAA,KAAK,OAAO,EAAE,QAAQA,QAAAA,KAAK,QAAQ,EAAE,GAAG,EAAE,sBAAsB,MAAM,CAAC"}