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

package/dist/services/toolCost/index.d.cts

@@ -0,0 +1,38 @@
+import { ToolEntry, ToolSource } from "../../tool-inventory.cjs";
+//#region src/services/toolCost/index.d.ts
+/**
+ * What one tool costs before anything is asked of it.
+ *
+ * A tool is sent to the model twice over. Its schema travels in the tool list,
+ * and its prose travels in the system prompt: Pi's `BuildSystemPromptOptions`
+ * takes `toolSnippets` keyed by tool name and `promptGuidelines` appended to the
+ * default guidelines, separately from the tools themselves. Pricing only the
+ * schema would undercount every tool that carries either, so the two are counted
+ * apart and reported together.
+ *
+ * The tokenizer is injected rather than imported, matching how MCP schema
+ * pricing already takes a `countTokens`. This module stays free of any opinion
+ * about which vocabulary the caller's model actually uses.
+ */
+export interface ToolCost {
+  /** The tool-list payload: name, description, and parameter schema. */
+  schemaTokens: number;
+  /** The system-prompt payload: snippet and guideline bullets. */
+  promptTokens: number;
+  totalTokens: number;
+}
+export type CountTokens = (text: string) => number;
+export declare function tokensForTool(entry: ToolEntry, countTokens: CountTokens): ToolCost;
+/**
+ * Every tool in a source, and what the source costs in total.
+ *
+ * An inactive tool is still priced: it is in the composition, and the point of
+ * the figure is to show what the composition costs. Whether the model may call
+ * it is a separate question from whether it is being paid for.
+ */
+export declare function tokensForSource(source: ToolSource, countTokens: CountTokens): {
+  tools: ReadonlyMap<string, ToolCost>;
+  totalTokens: number;
+};
+//#endregion
+//# sourceMappingURL=index.d.cts.map

package/dist/services/toolCost/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/services/toolCost/index.ts"],"mappings":";;;;;;;;;;;;;;;;iBAgBiB;;EAEf;;EAEA;EACA;;YAGU,eAAe;wBAeX,cAAc,OAAO,WAAW,aAAa,cAAc;;;;;;;;wBAc3D,gBACd,QAAQ,YACR,aAAa;EACV,OAAO,oBAAoB;EAAW"}

package/dist/services/toolCost/index.d.mts

@@ -0,0 +1,38 @@
+import { ToolEntry, ToolSource } from "../../tool-inventory.mjs";
+//#region src/services/toolCost/index.d.ts
+/**
+ * What one tool costs before anything is asked of it.
+ *
+ * A tool is sent to the model twice over. Its schema travels in the tool list,
+ * and its prose travels in the system prompt: Pi's `BuildSystemPromptOptions`
+ * takes `toolSnippets` keyed by tool name and `promptGuidelines` appended to the
+ * default guidelines, separately from the tools themselves. Pricing only the
+ * schema would undercount every tool that carries either, so the two are counted
+ * apart and reported together.
+ *
+ * The tokenizer is injected rather than imported, matching how MCP schema
+ * pricing already takes a `countTokens`. This module stays free of any opinion
+ * about which vocabulary the caller's model actually uses.
+ */
+export interface ToolCost {
+  /** The tool-list payload: name, description, and parameter schema. */
+  schemaTokens: number;
+  /** The system-prompt payload: snippet and guideline bullets. */
+  promptTokens: number;
+  totalTokens: number;
+}
+export type CountTokens = (text: string) => number;
+export declare function tokensForTool(entry: ToolEntry, countTokens: CountTokens): ToolCost;
+/**
+ * Every tool in a source, and what the source costs in total.
+ *
+ * An inactive tool is still priced: it is in the composition, and the point of
+ * the figure is to show what the composition costs. Whether the model may call
+ * it is a separate question from whether it is being paid for.
+ */
+export declare function tokensForSource(source: ToolSource, countTokens: CountTokens): {
+  tools: ReadonlyMap<string, ToolCost>;
+  totalTokens: number;
+};
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/dist/services/toolCost/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/services/toolCost/index.ts"],"mappings":";;;;;;;;;;;;;;;;iBAgBiB;;EAEf;;EAEA;EACA;;YAGU,eAAe;wBAeX,cAAc,OAAO,WAAW,aAAa,cAAc;;;;;;;;wBAc3D,gBACd,QAAQ,YACR,aAAa;EACV,OAAO,oBAAoB;EAAW"}

package/dist/services/toolCost/index.mjs

@@ -0,0 +1,46 @@
+//#region src/services/toolCost/index.ts
+/** Mirrors the wire shape MCP advertises, so both estimates stay comparable. */
+function schemaPayload(entry) {
+	return JSON.stringify({
+		name: entry.name,
+		...entry.description === void 0 ? {} : { description: entry.description },
+		...entry.parameters === void 0 ? {} : { parameters: entry.parameters }
+	});
+}
+function promptPayload(entry) {
+	return [entry.promptSnippet ?? "", ...entry.promptGuidelines ?? []].filter(Boolean).join("\n");
+}
+function tokensForTool(entry, countTokens) {
+	const schemaTokens = countTokens(schemaPayload(entry));
+	const prompt = promptPayload(entry);
+	const promptTokens = prompt.length === 0 ? 0 : countTokens(prompt);
+	return {
+		schemaTokens,
+		promptTokens,
+		totalTokens: schemaTokens + promptTokens
+	};
+}
+/**
+* Every tool in a source, and what the source costs in total.
+*
+* An inactive tool is still priced: it is in the composition, and the point of
+* the figure is to show what the composition costs. Whether the model may call
+* it is a separate question from whether it is being paid for.
+*/
+function tokensForSource(source, countTokens) {
+	const tools = /* @__PURE__ */ new Map();
+	let totalTokens = 0;
+	for (const entry of source.tools) {
+		const cost = tokensForTool(entry, countTokens);
+		tools.set(entry.name, cost);
+		totalTokens += cost.totalTokens;
+	}
+	return {
+		tools,
+		totalTokens
+	};
+}
+//#endregion
+export { tokensForSource, tokensForTool };
+
+//# sourceMappingURL=index.mjs.map

package/dist/services/toolCost/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/services/toolCost/index.ts"],"sourcesContent":["import type { ToolEntry, ToolSource } from '../toolInventory';\n\n/**\n * What one tool costs before anything is asked of it.\n *\n * A tool is sent to the model twice over. Its schema travels in the tool list,\n * and its prose travels in the system prompt: Pi's `BuildSystemPromptOptions`\n * takes `toolSnippets` keyed by tool name and `promptGuidelines` appended to the\n * default guidelines, separately from the tools themselves. Pricing only the\n * schema would undercount every tool that carries either, so the two are counted\n * apart and reported together.\n *\n * The tokenizer is injected rather than imported, matching how MCP schema\n * pricing already takes a `countTokens`. This module stays free of any opinion\n * about which vocabulary the caller's model actually uses.\n */\nexport interface ToolCost {\n  /** The tool-list payload: name, description, and parameter schema. */\n  schemaTokens: number;\n  /** The system-prompt payload: snippet and guideline bullets. */\n  promptTokens: number;\n  totalTokens: number;\n}\n\nexport type CountTokens = (text: string) => number;\n\n/** Mirrors the wire shape MCP advertises, so both estimates stay comparable. */\nfunction schemaPayload(entry: ToolEntry): string {\n  return JSON.stringify({\n    name: entry.name,\n    ...(entry.description === undefined ? {} : { description: entry.description }),\n    ...(entry.parameters === undefined ? {} : { parameters: entry.parameters }),\n  });\n}\n\nfunction promptPayload(entry: ToolEntry): string {\n  return [entry.promptSnippet ?? '', ...(entry.promptGuidelines ?? [])].filter(Boolean).join('\\n');\n}\n\nexport function tokensForTool(entry: ToolEntry, countTokens: CountTokens): ToolCost {\n  const schemaTokens = countTokens(schemaPayload(entry));\n  const prompt = promptPayload(entry);\n  const promptTokens = prompt.length === 0 ? 0 : countTokens(prompt);\n  return { schemaTokens, promptTokens, totalTokens: schemaTokens + promptTokens };\n}\n\n/**\n * Every tool in a source, and what the source costs in total.\n *\n * An inactive tool is still priced: it is in the composition, and the point of\n * the figure is to show what the composition costs. Whether the model may call\n * it is a separate question from whether it is being paid for.\n */\nexport function tokensForSource(\n  source: ToolSource,\n  countTokens: CountTokens,\n): { tools: ReadonlyMap<string, ToolCost>; totalTokens: number } {\n  const tools = new Map<string, ToolCost>();\n  let totalTokens = 0;\n  for (const entry of source.tools) {\n    const cost = tokensForTool(entry, countTokens);\n    tools.set(entry.name, cost);\n    totalTokens += cost.totalTokens;\n  }\n  return { tools, totalTokens };\n}\n"],"mappings":";;AA2BA,SAAS,cAAc,OAA0B;CAC/C,OAAO,KAAK,UAAU;EACpB,MAAM,MAAM;EACZ,GAAI,MAAM,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,aAAa,MAAM,YAAY;EAC5E,GAAI,MAAM,eAAe,KAAA,IAAY,CAAC,IAAI,EAAE,YAAY,MAAM,WAAW;CAC3E,CAAC;AACH;AAEA,SAAS,cAAc,OAA0B;CAC/C,OAAO,CAAC,MAAM,iBAAiB,IAAI,GAAI,MAAM,oBAAoB,CAAC,CAAE,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,IAAI;AACjG;AAEA,SAAgB,cAAc,OAAkB,aAAoC;CAClF,MAAM,eAAe,YAAY,cAAc,KAAK,CAAC;CACrD,MAAM,SAAS,cAAc,KAAK;CAClC,MAAM,eAAe,OAAO,WAAW,IAAI,IAAI,YAAY,MAAM;CACjE,OAAO;EAAE;EAAc;EAAc,aAAa,eAAe;CAAa;AAChF;;;;;;;;AASA,SAAgB,gBACd,QACA,aAC+D;CAC/D,MAAM,wBAAQ,IAAI,IAAsB;CACxC,IAAI,cAAc;CAClB,KAAK,MAAM,SAAS,OAAO,OAAO;EAChC,MAAM,OAAO,cAAc,OAAO,WAAW;EAC7C,MAAM,IAAI,MAAM,MAAM,IAAI;EAC1B,eAAe,KAAK;CACtB;CACA,OAAO;EAAE;EAAO;CAAY;AAC9B"}

package/dist/services/toolOverrides/index.cjs

@@ -0,0 +1,45 @@
+//#region src/services/toolOverrides/index.ts
+function assertNonEmpty(value, field) {
+	if (value.trim().length === 0) throw new Error(`Doom tool override ${field} must not be empty.`);
+}
+/** Creates the host-owned tool replacement registry for one Doom runtime. */
+function createDoomToolOverridesService(generation) {
+	if (!generation) throw new Error("Doom tool overrides require a runtime generation.");
+	const owners = /* @__PURE__ */ new Map();
+	return Object.freeze({
+		generation,
+		claim(claim) {
+			assertNonEmpty(claim.source, "source");
+			if (claim.tools.length === 0) throw new Error("Doom tool override tools must not be empty.");
+			for (const tool of claim.tools) assertNonEmpty(tool, "tool");
+			const tools = Object.freeze([...new Set(claim.tools)]);
+			if (tools.some((tool) => owners.has(tool))) return Object.freeze({
+				granted: false,
+				tools,
+				dispose: () => void 0
+			});
+			const stored = Object.freeze({
+				source: claim.source,
+				tools
+			});
+			for (const tool of tools) owners.set(tool, stored);
+			let disposed = false;
+			return Object.freeze({
+				granted: true,
+				tools,
+				dispose() {
+					if (disposed) return;
+					disposed = true;
+					for (const tool of tools) if (owners.get(tool) === stored) owners.delete(tool);
+				}
+			});
+		},
+		owner(tool) {
+			return owners.get(tool)?.source;
+		}
+	});
+}
+//#endregion
+exports.createDoomToolOverridesService = createDoomToolOverridesService;
+
+//# sourceMappingURL=index.cjs.map

package/dist/services/toolOverrides/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../src/services/toolOverrides/index.ts"],"sourcesContent":["import type {\n  DoomToolOverrideClaim,\n  DoomToolOverrideRegistration,\n  DoomToolOverridesService,\n} from '../../schemas/toolOverrides';\n\ninterface StoredClaim {\n  readonly source: string;\n  readonly tools: readonly string[];\n}\n\nfunction assertNonEmpty(value: string, field: string): void {\n  if (value.trim().length === 0) throw new Error(`Doom tool override ${field} must not be empty.`);\n}\n\n/** Creates the host-owned tool replacement registry for one Doom runtime. */\nexport function createDoomToolOverridesService(generation: string): DoomToolOverridesService {\n  if (!generation) throw new Error('Doom tool overrides require a runtime generation.');\n\n  const owners = new Map<string, StoredClaim>();\n  return Object.freeze({\n    generation,\n    claim(claim: DoomToolOverrideClaim): DoomToolOverrideRegistration {\n      assertNonEmpty(claim.source, 'source');\n      if (claim.tools.length === 0) throw new Error('Doom tool override tools must not be empty.');\n      for (const tool of claim.tools) assertNonEmpty(tool, 'tool');\n\n      const tools = Object.freeze([...new Set(claim.tools)]);\n      if (tools.some((tool) => owners.has(tool))) {\n        return Object.freeze({ granted: false, tools, dispose: (): void => undefined });\n      }\n\n      const stored: StoredClaim = Object.freeze({ source: claim.source, tools });\n      for (const tool of tools) owners.set(tool, stored);\n\n      let disposed = false;\n      return Object.freeze({\n        granted: true,\n        tools,\n        dispose(): void {\n          if (disposed) return;\n          disposed = true;\n          for (const tool of tools) {\n            if (owners.get(tool) === stored) owners.delete(tool);\n          }\n        },\n      });\n    },\n    owner(tool: string): string | undefined {\n      return owners.get(tool)?.source;\n    },\n  });\n}\n"],"mappings":";AAWA,SAAS,eAAe,OAAe,OAAqB;CAC1D,IAAI,MAAM,KAAK,CAAC,CAAC,WAAW,GAAG,MAAM,IAAI,MAAM,sBAAsB,MAAM,oBAAoB;AACjG;;AAGA,SAAgB,+BAA+B,YAA8C;CAC3F,IAAI,CAAC,YAAY,MAAM,IAAI,MAAM,mDAAmD;CAEpF,MAAM,yBAAS,IAAI,IAAyB;CAC5C,OAAO,OAAO,OAAO;EACnB;EACA,MAAM,OAA4D;GAChE,eAAe,MAAM,QAAQ,QAAQ;GACrC,IAAI,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,6CAA6C;GAC3F,KAAK,MAAM,QAAQ,MAAM,OAAO,eAAe,MAAM,MAAM;GAE3D,MAAM,QAAQ,OAAO,OAAO,CAAC,GAAG,IAAI,IAAI,MAAM,KAAK,CAAC,CAAC;GACrD,IAAI,MAAM,MAAM,SAAS,OAAO,IAAI,IAAI,CAAC,GACvC,OAAO,OAAO,OAAO;IAAE,SAAS;IAAO;IAAO,eAAqB,KAAA;GAAU,CAAC;GAGhF,MAAM,SAAsB,OAAO,OAAO;IAAE,QAAQ,MAAM;IAAQ;GAAM,CAAC;GACzE,KAAK,MAAM,QAAQ,OAAO,OAAO,IAAI,MAAM,MAAM;GAEjD,IAAI,WAAW;GACf,OAAO,OAAO,OAAO;IACnB,SAAS;IACT;IACA,UAAgB;KACd,IAAI,UAAU;KACd,WAAW;KACX,KAAK,MAAM,QAAQ,OACjB,IAAI,OAAO,IAAI,IAAI,MAAM,QAAQ,OAAO,OAAO,IAAI;IAEvD;GACF,CAAC;EACH;EACA,MAAM,MAAkC;GACtC,OAAO,OAAO,IAAI,IAAI,CAAC,EAAE;EAC3B;CACF,CAAC;AACH"}

package/dist/services/toolOverrides/index.d.cts

@@ -0,0 +1,6 @@
+import { DoomToolOverridesService } from "../../schemas/toolOverrides.cjs";
+//#region src/services/toolOverrides/index.d.ts
+/** Creates the host-owned tool replacement registry for one Doom runtime. */
+export declare function createDoomToolOverridesService(generation: string): DoomToolOverridesService;
+//#endregion
+//# sourceMappingURL=index.d.cts.map

package/dist/services/toolOverrides/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/services/toolOverrides/index.ts"],"mappings":";;;wBAgBgB,+BAA+B,qBAAqB"}

package/dist/services/toolOverrides/index.d.mts

@@ -0,0 +1,6 @@
+import { DoomToolOverridesService } from "../../schemas/toolOverrides.mjs";
+//#region src/services/toolOverrides/index.d.ts
+/** Creates the host-owned tool replacement registry for one Doom runtime. */
+export declare function createDoomToolOverridesService(generation: string): DoomToolOverridesService;
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/dist/services/toolOverrides/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/services/toolOverrides/index.ts"],"mappings":";;;wBAgBgB,+BAA+B,qBAAqB"}

package/dist/services/toolOverrides/index.mjs

@@ -0,0 +1,45 @@
+//#region src/services/toolOverrides/index.ts
+function assertNonEmpty(value, field) {
+	if (value.trim().length === 0) throw new Error(`Doom tool override ${field} must not be empty.`);
+}
+/** Creates the host-owned tool replacement registry for one Doom runtime. */
+function createDoomToolOverridesService(generation) {
+	if (!generation) throw new Error("Doom tool overrides require a runtime generation.");
+	const owners = /* @__PURE__ */ new Map();
+	return Object.freeze({
+		generation,
+		claim(claim) {
+			assertNonEmpty(claim.source, "source");
+			if (claim.tools.length === 0) throw new Error("Doom tool override tools must not be empty.");
+			for (const tool of claim.tools) assertNonEmpty(tool, "tool");
+			const tools = Object.freeze([...new Set(claim.tools)]);
+			if (tools.some((tool) => owners.has(tool))) return Object.freeze({
+				granted: false,
+				tools,
+				dispose: () => void 0
+			});
+			const stored = Object.freeze({
+				source: claim.source,
+				tools
+			});
+			for (const tool of tools) owners.set(tool, stored);
+			let disposed = false;
+			return Object.freeze({
+				granted: true,
+				tools,
+				dispose() {
+					if (disposed) return;
+					disposed = true;
+					for (const tool of tools) if (owners.get(tool) === stored) owners.delete(tool);
+				}
+			});
+		},
+		owner(tool) {
+			return owners.get(tool)?.source;
+		}
+	});
+}
+//#endregion
+export { createDoomToolOverridesService };
+
+//# sourceMappingURL=index.mjs.map

package/dist/services/toolOverrides/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/services/toolOverrides/index.ts"],"sourcesContent":["import type {\n  DoomToolOverrideClaim,\n  DoomToolOverrideRegistration,\n  DoomToolOverridesService,\n} from '../../schemas/toolOverrides';\n\ninterface StoredClaim {\n  readonly source: string;\n  readonly tools: readonly string[];\n}\n\nfunction assertNonEmpty(value: string, field: string): void {\n  if (value.trim().length === 0) throw new Error(`Doom tool override ${field} must not be empty.`);\n}\n\n/** Creates the host-owned tool replacement registry for one Doom runtime. */\nexport function createDoomToolOverridesService(generation: string): DoomToolOverridesService {\n  if (!generation) throw new Error('Doom tool overrides require a runtime generation.');\n\n  const owners = new Map<string, StoredClaim>();\n  return Object.freeze({\n    generation,\n    claim(claim: DoomToolOverrideClaim): DoomToolOverrideRegistration {\n      assertNonEmpty(claim.source, 'source');\n      if (claim.tools.length === 0) throw new Error('Doom tool override tools must not be empty.');\n      for (const tool of claim.tools) assertNonEmpty(tool, 'tool');\n\n      const tools = Object.freeze([...new Set(claim.tools)]);\n      if (tools.some((tool) => owners.has(tool))) {\n        return Object.freeze({ granted: false, tools, dispose: (): void => undefined });\n      }\n\n      const stored: StoredClaim = Object.freeze({ source: claim.source, tools });\n      for (const tool of tools) owners.set(tool, stored);\n\n      let disposed = false;\n      return Object.freeze({\n        granted: true,\n        tools,\n        dispose(): void {\n          if (disposed) return;\n          disposed = true;\n          for (const tool of tools) {\n            if (owners.get(tool) === stored) owners.delete(tool);\n          }\n        },\n      });\n    },\n    owner(tool: string): string | undefined {\n      return owners.get(tool)?.source;\n    },\n  });\n}\n"],"mappings":";AAWA,SAAS,eAAe,OAAe,OAAqB;CAC1D,IAAI,MAAM,KAAK,CAAC,CAAC,WAAW,GAAG,MAAM,IAAI,MAAM,sBAAsB,MAAM,oBAAoB;AACjG;;AAGA,SAAgB,+BAA+B,YAA8C;CAC3F,IAAI,CAAC,YAAY,MAAM,IAAI,MAAM,mDAAmD;CAEpF,MAAM,yBAAS,IAAI,IAAyB;CAC5C,OAAO,OAAO,OAAO;EACnB;EACA,MAAM,OAA4D;GAChE,eAAe,MAAM,QAAQ,QAAQ;GACrC,IAAI,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,6CAA6C;GAC3F,KAAK,MAAM,QAAQ,MAAM,OAAO,eAAe,MAAM,MAAM;GAE3D,MAAM,QAAQ,OAAO,OAAO,CAAC,GAAG,IAAI,IAAI,MAAM,KAAK,CAAC,CAAC;GACrD,IAAI,MAAM,MAAM,SAAS,OAAO,IAAI,IAAI,CAAC,GACvC,OAAO,OAAO,OAAO;IAAE,SAAS;IAAO;IAAO,eAAqB,KAAA;GAAU,CAAC;GAGhF,MAAM,SAAsB,OAAO,OAAO;IAAE,QAAQ,MAAM;IAAQ;GAAM,CAAC;GACzE,KAAK,MAAM,QAAQ,OAAO,OAAO,IAAI,MAAM,MAAM;GAEjD,IAAI,WAAW;GACf,OAAO,OAAO,OAAO;IACnB,SAAS;IACT;IACA,UAAgB;KACd,IAAI,UAAU;KACd,WAAW;KACX,KAAK,MAAM,QAAQ,OACjB,IAAI,OAAO,IAAI,IAAI,MAAM,QAAQ,OAAO,OAAO,IAAI;IAEvD;GACF,CAAC;EACH;EACA,MAAM,MAAkC;GACtC,OAAO,OAAO,IAAI,IAAI,CAAC,EAAE;EAC3B;CACF,CAAC;AACH"}

package/dist/services/toolSurface/index.cjs

@@ -0,0 +1,105 @@
+const require_index = require("../kernel/index.cjs");
+//#region src/services/toolSurface/index.ts
+/**
+* The tool surface arbiter.
+*
+* DESIGN PATTERNS:
+* - One writer. Every owner registers a restriction; only this service calls
+*   the host setter. Two owners can no longer overwrite each other's list.
+* - Removal is inherent. The surface is recomputed from the full registered
+*   tool set on every change, so dropping a restriction restores the tools it
+*   hid without any owner keeping a snapshot.
+* - Restrictions are pure and ordered by registration. The result is a
+*   function of (registered tools, active layers, registered restrictions).
+* - Application is synchronous. A tool change has to be visible to the very
+*   next line, because callers gate user-facing messages on it. The kernel's
+*   coalesced flush still drives layer switches; it just lands on the same
+*   idempotent apply.
+*
+* AVOID:
+* - Letting one broken restriction take the surface down. A throwing
+*   restriction is skipped and reported; the rest still reach the host.
+* - Returning tool names the host does not know. Unknown names are dropped so
+*   a stale restriction cannot resurrect a tool that was never registered.
+*/
+const SLOT = "tools";
+function sameList(left, right) {
+	if (left.length !== right.length) return false;
+	return left.every((name, index) => name === right[index]);
+}
+function createDoomToolSurface(options) {
+	const kernel = require_index.createDoomKernel({ activeLayers: options.activeLayers });
+	let pushed;
+	let disposed = false;
+	const apply = (holders) => {
+		const available = [...new Set(options.allTools())];
+		const known = new Set(available);
+		let current = available;
+		for (const holder of holders) try {
+			const result = holder.restrict(current, available);
+			current = [...new Set(result)].filter((name) => known.has(name));
+		} catch (error) {
+			options.onError?.(holder.source, error);
+		}
+		if (sameList(options.activeTools(), current)) {
+			pushed = current;
+			return;
+		}
+		options.setActiveTools([...current]);
+		pushed = current;
+	};
+	const slot = kernel.defineSlot(SLOT, apply);
+	const applyNow = () => {
+		if (!disposed) apply(kernel.activeValues(SLOT));
+	};
+	return Object.freeze({
+		generation: options.generation,
+		register(definition) {
+			if (definition.source.trim().length === 0) throw new Error("A tool restriction needs a source.");
+			const holder = {
+				source: definition.source,
+				restrict: definition.restrict
+			};
+			const registration = slot.contribute({
+				source: definition.source,
+				layer: definition.layer,
+				value: holder
+			});
+			applyNow();
+			let removed = false;
+			return Object.freeze({
+				update(restrict) {
+					if (removed) return;
+					holder.restrict = restrict;
+					applyNow();
+				},
+				dispose() {
+					if (removed) return;
+					removed = true;
+					registration.dispose();
+					applyNow();
+				}
+			});
+		},
+		refresh() {
+			applyNow();
+		},
+		setActiveLayers(layers) {
+			if (disposed) return;
+			kernel.setActiveLayers(layers).catch(() => void 0);
+			applyNow();
+		},
+		active() {
+			return disposed ? [] : pushed ?? options.activeTools();
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			kernel.dispose();
+		}
+	});
+}
+//#endregion
+exports.createDoomToolSurface = createDoomToolSurface;
+
+//# sourceMappingURL=index.cjs.map

package/dist/services/toolSurface/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["createDoomKernel"],"sources":["../../../src/services/toolSurface/index.ts"],"sourcesContent":["/**\n * The tool surface arbiter.\n *\n * DESIGN PATTERNS:\n * - One writer. Every owner registers a restriction; only this service calls\n *   the host setter. Two owners can no longer overwrite each other's list.\n * - Removal is inherent. The surface is recomputed from the full registered\n *   tool set on every change, so dropping a restriction restores the tools it\n *   hid without any owner keeping a snapshot.\n * - Restrictions are pure and ordered by registration. The result is a\n *   function of (registered tools, active layers, registered restrictions).\n * - Application is synchronous. A tool change has to be visible to the very\n *   next line, because callers gate user-facing messages on it. The kernel's\n *   coalesced flush still drives layer switches; it just lands on the same\n *   idempotent apply.\n *\n * AVOID:\n * - Letting one broken restriction take the surface down. A throwing\n *   restriction is skipped and reported; the rest still reach the host.\n * - Returning tool names the host does not know. Unknown names are dropped so\n *   a stale restriction cannot resurrect a tool that was never registered.\n */\n\nimport { createDoomKernel } from '../../exports/kernel';\nimport type {\n  DoomToolRestriction,\n  DoomToolRestrictionDefinition,\n  DoomToolRestrictionHandle,\n  DoomToolSurfaceService,\n} from '../../schemas/toolSurface';\n\nconst SLOT = 'tools';\n\ninterface RestrictionHolder {\n  readonly source: string;\n  restrict: DoomToolRestriction;\n}\n\nexport interface CreateDoomToolSurfaceOptions {\n  /** Runtime generation, mirrored onto the service for diagnostics. */\n  readonly generation: string;\n  /** Every tool registered with the host, in host order. */\n  readonly allTools: () => readonly string[];\n  /** The tools the host currently exposes, in host order. */\n  readonly activeTools: () => readonly string[];\n  /** The host's whole-list setter. Called only when actual activation differs. */\n  readonly setActiveTools: (names: string[]) => void;\n  /** Layers active at creation. */\n  readonly activeLayers?: readonly string[];\n  /** Receives a restriction that threw. Defaults to silence. */\n  readonly onError?: (source: string, error: unknown) => void;\n}\n\nfunction sameList(left: readonly string[], right: readonly string[]): boolean {\n  if (left.length !== right.length) return false;\n  return left.every((name, index) => name === right[index]);\n}\n\nexport function createDoomToolSurface(options: CreateDoomToolSurfaceOptions): DoomToolSurfaceService {\n  const kernel = createDoomKernel({ activeLayers: options.activeLayers });\n  let pushed: readonly string[] | undefined;\n  let disposed = false;\n\n  const apply = (holders: readonly RestrictionHolder[]): void => {\n    const available = [...new Set(options.allTools())];\n    const known = new Set(available);\n    let current: readonly string[] = available;\n    for (const holder of holders) {\n      try {\n        const result = holder.restrict(current, available);\n        current = [...new Set(result)].filter((name) => known.has(name));\n      } catch (error) {\n        options.onError?.(holder.source, error);\n      }\n    }\n    const actual = options.activeTools();\n    if (sameList(actual, current)) {\n      pushed = current;\n      return;\n    }\n    options.setActiveTools([...current]);\n    pushed = current;\n  };\n\n  const slot = kernel.defineSlot<RestrictionHolder>(SLOT, apply);\n  const applyNow = (): void => {\n    if (!disposed) apply(kernel.activeValues<RestrictionHolder>(SLOT));\n  };\n\n  return Object.freeze({\n    generation: options.generation,\n    register(definition: DoomToolRestrictionDefinition): DoomToolRestrictionHandle {\n      if (definition.source.trim().length === 0) throw new Error('A tool restriction needs a source.');\n      const holder: RestrictionHolder = { source: definition.source, restrict: definition.restrict };\n      const registration = slot.contribute({ source: definition.source, layer: definition.layer, value: holder });\n      applyNow();\n      let removed = false;\n      return Object.freeze({\n        update(restrict: DoomToolRestriction): void {\n          if (removed) return;\n          holder.restrict = restrict;\n          applyNow();\n        },\n        dispose(): void {\n          if (removed) return;\n          removed = true;\n          registration.dispose();\n          applyNow();\n        },\n      });\n    },\n    refresh(): void {\n      applyNow();\n    },\n    setActiveLayers(layers: readonly string[]): void {\n      if (disposed) return;\n      void kernel.setActiveLayers(layers).catch(() => undefined);\n      applyNow();\n    },\n    active(): readonly string[] {\n      return disposed ? [] : (pushed ?? options.activeTools());\n    },\n    dispose(): void {\n      if (disposed) return;\n      disposed = true;\n      kernel.dispose();\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAM,OAAO;AAsBb,SAAS,SAAS,MAAyB,OAAmC;CAC5E,IAAI,KAAK,WAAW,MAAM,QAAQ,OAAO;CACzC,OAAO,KAAK,OAAO,MAAM,UAAU,SAAS,MAAM,MAAM;AAC1D;AAEA,SAAgB,sBAAsB,SAA+D;CACnG,MAAM,SAASA,cAAAA,iBAAiB,EAAE,cAAc,QAAQ,aAAa,CAAC;CACtE,IAAI;CACJ,IAAI,WAAW;CAEf,MAAM,SAAS,YAAgD;EAC7D,MAAM,YAAY,CAAC,GAAG,IAAI,IAAI,QAAQ,SAAS,CAAC,CAAC;EACjD,MAAM,QAAQ,IAAI,IAAI,SAAS;EAC/B,IAAI,UAA6B;EACjC,KAAK,MAAM,UAAU,SACnB,IAAI;GACF,MAAM,SAAS,OAAO,SAAS,SAAS,SAAS;GACjD,UAAU,CAAC,GAAG,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC,QAAQ,SAAS,MAAM,IAAI,IAAI,CAAC;EACjE,SAAS,OAAO;GACd,QAAQ,UAAU,OAAO,QAAQ,KAAK;EACxC;EAGF,IAAI,SADW,QAAQ,YACL,GAAG,OAAO,GAAG;GAC7B,SAAS;GACT;EACF;EACA,QAAQ,eAAe,CAAC,GAAG,OAAO,CAAC;EACnC,SAAS;CACX;CAEA,MAAM,OAAO,OAAO,WAA8B,MAAM,KAAK;CAC7D,MAAM,iBAAuB;EAC3B,IAAI,CAAC,UAAU,MAAM,OAAO,aAAgC,IAAI,CAAC;CACnE;CAEA,OAAO,OAAO,OAAO;EACnB,YAAY,QAAQ;EACpB,SAAS,YAAsE;GAC7E,IAAI,WAAW,OAAO,KAAK,CAAC,CAAC,WAAW,GAAG,MAAM,IAAI,MAAM,oCAAoC;GAC/F,MAAM,SAA4B;IAAE,QAAQ,WAAW;IAAQ,UAAU,WAAW;GAAS;GAC7F,MAAM,eAAe,KAAK,WAAW;IAAE,QAAQ,WAAW;IAAQ,OAAO,WAAW;IAAO,OAAO;GAAO,CAAC;GAC1G,SAAS;GACT,IAAI,UAAU;GACd,OAAO,OAAO,OAAO;IACnB,OAAO,UAAqC;KAC1C,IAAI,SAAS;KACb,OAAO,WAAW;KAClB,SAAS;IACX;IACA,UAAgB;KACd,IAAI,SAAS;KACb,UAAU;KACV,aAAa,QAAQ;KACrB,SAAS;IACX;GACF,CAAC;EACH;EACA,UAAgB;GACd,SAAS;EACX;EACA,gBAAgB,QAAiC;GAC/C,IAAI,UAAU;GACd,OAAY,gBAAgB,MAAM,CAAC,CAAC,YAAY,KAAA,CAAS;GACzD,SAAS;EACX;EACA,SAA4B;GAC1B,OAAO,WAAW,CAAC,IAAK,UAAU,QAAQ,YAAY;EACxD;EACA,UAAgB;GACd,IAAI,UAAU;GACd,WAAW;GACX,OAAO,QAAQ;EACjB;CACF,CAAC;AACH"}

package/dist/services/toolSurface/index.d.cts

@@ -0,0 +1,19 @@
+import { DoomToolSurfaceService } from "../../schemas/toolSurface.cjs";
+//#region src/services/toolSurface/index.d.ts
+export interface CreateDoomToolSurfaceOptions {
+  /** Runtime generation, mirrored onto the service for diagnostics. */
+  readonly generation: string;
+  /** Every tool registered with the host, in host order. */
+  readonly allTools: () => readonly string[];
+  /** The tools the host currently exposes, in host order. */
+  readonly activeTools: () => readonly string[];
+  /** The host's whole-list setter. Called only when actual activation differs. */
+  readonly setActiveTools: (names: string[]) => void;
+  /** Layers active at creation. */
+  readonly activeLayers?: readonly string[];
+  /** Receives a restriction that threw. Defaults to silence. */
+  readonly onError?: (source: string, error: unknown) => void;
+}
+export declare function createDoomToolSurface(options: CreateDoomToolSurfaceOptions): DoomToolSurfaceService;
+//#endregion
+//# sourceMappingURL=index.d.cts.map

package/dist/services/toolSurface/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/services/toolSurface/index.ts"],"mappings":";;iBAsCiB;;WAEN;;WAEA;;WAEA;;WAEA,iBAAiB;;WAEjB;;WAEA,WAAW,gBAAgB;;wBAQtB,sBAAsB,SAAS,+BAA+B"}

package/dist/services/toolSurface/index.d.mts

@@ -0,0 +1,19 @@
+import { DoomToolSurfaceService } from "../../schemas/toolSurface.mjs";
+//#region src/services/toolSurface/index.d.ts
+export interface CreateDoomToolSurfaceOptions {
+  /** Runtime generation, mirrored onto the service for diagnostics. */
+  readonly generation: string;
+  /** Every tool registered with the host, in host order. */
+  readonly allTools: () => readonly string[];
+  /** The tools the host currently exposes, in host order. */
+  readonly activeTools: () => readonly string[];
+  /** The host's whole-list setter. Called only when actual activation differs. */
+  readonly setActiveTools: (names: string[]) => void;
+  /** Layers active at creation. */
+  readonly activeLayers?: readonly string[];
+  /** Receives a restriction that threw. Defaults to silence. */
+  readonly onError?: (source: string, error: unknown) => void;
+}
+export declare function createDoomToolSurface(options: CreateDoomToolSurfaceOptions): DoomToolSurfaceService;
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/dist/services/toolSurface/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/services/toolSurface/index.ts"],"mappings":";;iBAsCiB;;WAEN;;WAEA;;WAEA;;WAEA,iBAAiB;;WAEjB;;WAEA,WAAW,gBAAgB;;wBAQtB,sBAAsB,SAAS,+BAA+B"}

package/dist/services/toolSurface/index.mjs

@@ -0,0 +1,105 @@
+import { createDoomKernel } from "../kernel/index.mjs";
+//#region src/services/toolSurface/index.ts
+/**
+* The tool surface arbiter.
+*
+* DESIGN PATTERNS:
+* - One writer. Every owner registers a restriction; only this service calls
+*   the host setter. Two owners can no longer overwrite each other's list.
+* - Removal is inherent. The surface is recomputed from the full registered
+*   tool set on every change, so dropping a restriction restores the tools it
+*   hid without any owner keeping a snapshot.
+* - Restrictions are pure and ordered by registration. The result is a
+*   function of (registered tools, active layers, registered restrictions).
+* - Application is synchronous. A tool change has to be visible to the very
+*   next line, because callers gate user-facing messages on it. The kernel's
+*   coalesced flush still drives layer switches; it just lands on the same
+*   idempotent apply.
+*
+* AVOID:
+* - Letting one broken restriction take the surface down. A throwing
+*   restriction is skipped and reported; the rest still reach the host.
+* - Returning tool names the host does not know. Unknown names are dropped so
+*   a stale restriction cannot resurrect a tool that was never registered.
+*/
+const SLOT = "tools";
+function sameList(left, right) {
+	if (left.length !== right.length) return false;
+	return left.every((name, index) => name === right[index]);
+}
+function createDoomToolSurface(options) {
+	const kernel = createDoomKernel({ activeLayers: options.activeLayers });
+	let pushed;
+	let disposed = false;
+	const apply = (holders) => {
+		const available = [...new Set(options.allTools())];
+		const known = new Set(available);
+		let current = available;
+		for (const holder of holders) try {
+			const result = holder.restrict(current, available);
+			current = [...new Set(result)].filter((name) => known.has(name));
+		} catch (error) {
+			options.onError?.(holder.source, error);
+		}
+		if (sameList(options.activeTools(), current)) {
+			pushed = current;
+			return;
+		}
+		options.setActiveTools([...current]);
+		pushed = current;
+	};
+	const slot = kernel.defineSlot(SLOT, apply);
+	const applyNow = () => {
+		if (!disposed) apply(kernel.activeValues(SLOT));
+	};
+	return Object.freeze({
+		generation: options.generation,
+		register(definition) {
+			if (definition.source.trim().length === 0) throw new Error("A tool restriction needs a source.");
+			const holder = {
+				source: definition.source,
+				restrict: definition.restrict
+			};
+			const registration = slot.contribute({
+				source: definition.source,
+				layer: definition.layer,
+				value: holder
+			});
+			applyNow();
+			let removed = false;
+			return Object.freeze({
+				update(restrict) {
+					if (removed) return;
+					holder.restrict = restrict;
+					applyNow();
+				},
+				dispose() {
+					if (removed) return;
+					removed = true;
+					registration.dispose();
+					applyNow();
+				}
+			});
+		},
+		refresh() {
+			applyNow();
+		},
+		setActiveLayers(layers) {
+			if (disposed) return;
+			kernel.setActiveLayers(layers).catch(() => void 0);
+			applyNow();
+		},
+		active() {
+			return disposed ? [] : pushed ?? options.activeTools();
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			kernel.dispose();
+		}
+	});
+}
+//#endregion
+export { createDoomToolSurface };
+
+//# sourceMappingURL=index.mjs.map

package/dist/services/toolSurface/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/services/toolSurface/index.ts"],"sourcesContent":["/**\n * The tool surface arbiter.\n *\n * DESIGN PATTERNS:\n * - One writer. Every owner registers a restriction; only this service calls\n *   the host setter. Two owners can no longer overwrite each other's list.\n * - Removal is inherent. The surface is recomputed from the full registered\n *   tool set on every change, so dropping a restriction restores the tools it\n *   hid without any owner keeping a snapshot.\n * - Restrictions are pure and ordered by registration. The result is a\n *   function of (registered tools, active layers, registered restrictions).\n * - Application is synchronous. A tool change has to be visible to the very\n *   next line, because callers gate user-facing messages on it. The kernel's\n *   coalesced flush still drives layer switches; it just lands on the same\n *   idempotent apply.\n *\n * AVOID:\n * - Letting one broken restriction take the surface down. A throwing\n *   restriction is skipped and reported; the rest still reach the host.\n * - Returning tool names the host does not know. Unknown names are dropped so\n *   a stale restriction cannot resurrect a tool that was never registered.\n */\n\nimport { createDoomKernel } from '../../exports/kernel';\nimport type {\n  DoomToolRestriction,\n  DoomToolRestrictionDefinition,\n  DoomToolRestrictionHandle,\n  DoomToolSurfaceService,\n} from '../../schemas/toolSurface';\n\nconst SLOT = 'tools';\n\ninterface RestrictionHolder {\n  readonly source: string;\n  restrict: DoomToolRestriction;\n}\n\nexport interface CreateDoomToolSurfaceOptions {\n  /** Runtime generation, mirrored onto the service for diagnostics. */\n  readonly generation: string;\n  /** Every tool registered with the host, in host order. */\n  readonly allTools: () => readonly string[];\n  /** The tools the host currently exposes, in host order. */\n  readonly activeTools: () => readonly string[];\n  /** The host's whole-list setter. Called only when actual activation differs. */\n  readonly setActiveTools: (names: string[]) => void;\n  /** Layers active at creation. */\n  readonly activeLayers?: readonly string[];\n  /** Receives a restriction that threw. Defaults to silence. */\n  readonly onError?: (source: string, error: unknown) => void;\n}\n\nfunction sameList(left: readonly string[], right: readonly string[]): boolean {\n  if (left.length !== right.length) return false;\n  return left.every((name, index) => name === right[index]);\n}\n\nexport function createDoomToolSurface(options: CreateDoomToolSurfaceOptions): DoomToolSurfaceService {\n  const kernel = createDoomKernel({ activeLayers: options.activeLayers });\n  let pushed: readonly string[] | undefined;\n  let disposed = false;\n\n  const apply = (holders: readonly RestrictionHolder[]): void => {\n    const available = [...new Set(options.allTools())];\n    const known = new Set(available);\n    let current: readonly string[] = available;\n    for (const holder of holders) {\n      try {\n        const result = holder.restrict(current, available);\n        current = [...new Set(result)].filter((name) => known.has(name));\n      } catch (error) {\n        options.onError?.(holder.source, error);\n      }\n    }\n    const actual = options.activeTools();\n    if (sameList(actual, current)) {\n      pushed = current;\n      return;\n    }\n    options.setActiveTools([...current]);\n    pushed = current;\n  };\n\n  const slot = kernel.defineSlot<RestrictionHolder>(SLOT, apply);\n  const applyNow = (): void => {\n    if (!disposed) apply(kernel.activeValues<RestrictionHolder>(SLOT));\n  };\n\n  return Object.freeze({\n    generation: options.generation,\n    register(definition: DoomToolRestrictionDefinition): DoomToolRestrictionHandle {\n      if (definition.source.trim().length === 0) throw new Error('A tool restriction needs a source.');\n      const holder: RestrictionHolder = { source: definition.source, restrict: definition.restrict };\n      const registration = slot.contribute({ source: definition.source, layer: definition.layer, value: holder });\n      applyNow();\n      let removed = false;\n      return Object.freeze({\n        update(restrict: DoomToolRestriction): void {\n          if (removed) return;\n          holder.restrict = restrict;\n          applyNow();\n        },\n        dispose(): void {\n          if (removed) return;\n          removed = true;\n          registration.dispose();\n          applyNow();\n        },\n      });\n    },\n    refresh(): void {\n      applyNow();\n    },\n    setActiveLayers(layers: readonly string[]): void {\n      if (disposed) return;\n      void kernel.setActiveLayers(layers).catch(() => undefined);\n      applyNow();\n    },\n    active(): readonly string[] {\n      return disposed ? [] : (pushed ?? options.activeTools());\n    },\n    dispose(): void {\n      if (disposed) return;\n      disposed = true;\n      kernel.dispose();\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAM,OAAO;AAsBb,SAAS,SAAS,MAAyB,OAAmC;CAC5E,IAAI,KAAK,WAAW,MAAM,QAAQ,OAAO;CACzC,OAAO,KAAK,OAAO,MAAM,UAAU,SAAS,MAAM,MAAM;AAC1D;AAEA,SAAgB,sBAAsB,SAA+D;CACnG,MAAM,SAAS,iBAAiB,EAAE,cAAc,QAAQ,aAAa,CAAC;CACtE,IAAI;CACJ,IAAI,WAAW;CAEf,MAAM,SAAS,YAAgD;EAC7D,MAAM,YAAY,CAAC,GAAG,IAAI,IAAI,QAAQ,SAAS,CAAC,CAAC;EACjD,MAAM,QAAQ,IAAI,IAAI,SAAS;EAC/B,IAAI,UAA6B;EACjC,KAAK,MAAM,UAAU,SACnB,IAAI;GACF,MAAM,SAAS,OAAO,SAAS,SAAS,SAAS;GACjD,UAAU,CAAC,GAAG,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC,QAAQ,SAAS,MAAM,IAAI,IAAI,CAAC;EACjE,SAAS,OAAO;GACd,QAAQ,UAAU,OAAO,QAAQ,KAAK;EACxC;EAGF,IAAI,SADW,QAAQ,YACL,GAAG,OAAO,GAAG;GAC7B,SAAS;GACT;EACF;EACA,QAAQ,eAAe,CAAC,GAAG,OAAO,CAAC;EACnC,SAAS;CACX;CAEA,MAAM,OAAO,OAAO,WAA8B,MAAM,KAAK;CAC7D,MAAM,iBAAuB;EAC3B,IAAI,CAAC,UAAU,MAAM,OAAO,aAAgC,IAAI,CAAC;CACnE;CAEA,OAAO,OAAO,OAAO;EACnB,YAAY,QAAQ;EACpB,SAAS,YAAsE;GAC7E,IAAI,WAAW,OAAO,KAAK,CAAC,CAAC,WAAW,GAAG,MAAM,IAAI,MAAM,oCAAoC;GAC/F,MAAM,SAA4B;IAAE,QAAQ,WAAW;IAAQ,UAAU,WAAW;GAAS;GAC7F,MAAM,eAAe,KAAK,WAAW;IAAE,QAAQ,WAAW;IAAQ,OAAO,WAAW;IAAO,OAAO;GAAO,CAAC;GAC1G,SAAS;GACT,IAAI,UAAU;GACd,OAAO,OAAO,OAAO;IACnB,OAAO,UAAqC;KAC1C,IAAI,SAAS;KACb,OAAO,WAAW;KAClB,SAAS;IACX;IACA,UAAgB;KACd,IAAI,SAAS;KACb,UAAU;KACV,aAAa,QAAQ;KACrB,SAAS;IACX;GACF,CAAC;EACH;EACA,UAAgB;GACd,SAAS;EACX;EACA,gBAAgB,QAAiC;GAC/C,IAAI,UAAU;GACd,OAAY,gBAAgB,MAAM,CAAC,CAAC,YAAY,KAAA,CAAS;GACzD,SAAS;EACX;EACA,SAA4B;GAC1B,OAAO,WAAW,CAAC,IAAK,UAAU,QAAQ,YAAY;EACxD;EACA,UAAgB;GACd,IAAI,UAAU;GACd,WAAW;GACX,OAAO,QAAQ;EACjB;CACF,CAAC;AACH"}

package/dist/services/traceContext/index.cjs

@@ -0,0 +1,13 @@
+//#region src/services/traceContext/index.ts
+const TRACEPARENT = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/u;
+/** Accepts only a valid W3C traceparent and never forwards tracestate or baggage. */
+function validatedTraceContext(value) {
+	if (typeof value !== "string") return void 0;
+	const match = TRACEPARENT.exec(value);
+	if (!match || /^0+$/u.test(match[1] ?? "") || /^0+$/u.test(match[2] ?? "")) return void 0;
+	return { traceparent: value };
+}
+//#endregion
+exports.validatedTraceContext = validatedTraceContext;
+
+//# sourceMappingURL=index.cjs.map

package/dist/services/traceContext/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../src/services/traceContext/index.ts"],"sourcesContent":["import type { DoomTraceContext } from '@agimon-ai/doompi-telemetry';\n\nconst TRACEPARENT = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/u;\n\n/** Accepts only a valid W3C traceparent and never forwards tracestate or baggage. */\nexport function validatedTraceContext(value: unknown): DoomTraceContext | undefined {\n  if (typeof value !== 'string') return undefined;\n  const match = TRACEPARENT.exec(value);\n  if (!match || /^0+$/u.test(match[1] ?? '') || /^0+$/u.test(match[2] ?? '')) return undefined;\n  return { traceparent: value };\n}\n"],"mappings":";AAEA,MAAM,cAAc;;AAGpB,SAAgB,sBAAsB,OAA8C;CAClF,IAAI,OAAO,UAAU,UAAU,OAAO,KAAA;CACtC,MAAM,QAAQ,YAAY,KAAK,KAAK;CACpC,IAAI,CAAC,SAAS,QAAQ,KAAK,MAAM,MAAM,EAAE,KAAK,QAAQ,KAAK,MAAM,MAAM,EAAE,GAAG,OAAO,KAAA;CACnF,OAAO,EAAE,aAAa,MAAM;AAC9B"}

package/dist/services/traceContext/index.mjs

@@ -0,0 +1,13 @@
+//#region src/services/traceContext/index.ts
+const TRACEPARENT = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/u;
+/** Accepts only a valid W3C traceparent and never forwards tracestate or baggage. */
+function validatedTraceContext(value) {
+	if (typeof value !== "string") return void 0;
+	const match = TRACEPARENT.exec(value);
+	if (!match || /^0+$/u.test(match[1] ?? "") || /^0+$/u.test(match[2] ?? "")) return void 0;
+	return { traceparent: value };
+}
+//#endregion
+export { validatedTraceContext };
+
+//# sourceMappingURL=index.mjs.map

package/dist/services/traceContext/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/services/traceContext/index.ts"],"sourcesContent":["import type { DoomTraceContext } from '@agimon-ai/doompi-telemetry';\n\nconst TRACEPARENT = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/u;\n\n/** Accepts only a valid W3C traceparent and never forwards tracestate or baggage. */\nexport function validatedTraceContext(value: unknown): DoomTraceContext | undefined {\n  if (typeof value !== 'string') return undefined;\n  const match = TRACEPARENT.exec(value);\n  if (!match || /^0+$/u.test(match[1] ?? '') || /^0+$/u.test(match[2] ?? '')) return undefined;\n  return { traceparent: value };\n}\n"],"mappings":";AAEA,MAAM,cAAc;;AAGpB,SAAgB,sBAAsB,OAA8C;CAClF,IAAI,OAAO,UAAU,UAAU,OAAO,KAAA;CACtC,MAAM,QAAQ,YAAY,KAAK,KAAK;CACpC,IAAI,CAAC,SAAS,QAAQ,KAAK,MAAM,MAAM,EAAE,KAAK,QAAQ,KAAK,MAAM,MAAM,EAAE,GAAG,OAAO,KAAA;CACnF,OAAO,EAAE,aAAa,MAAM;AAC9B"}