@obversa/api 0.1.0

package/dist/index.js

@@ -0,0 +1,806 @@
+export { EngineError, EngineIncompleteResultError, LANE_DEAD_FAILURES, assistantResult, classifyEngineFailure, engineSelection, finalResultPart, finalResultText, modelIdentity, reportedUsage, requireFinalResultText, validateAgentResult, validateIncompleteResultEvidence } from './chunk-6ZP73HZN.js';
+import { validateNewDomainEvent, GraphValidationError } from './chunk-VWZKI7AG.js';
+export { GraphValidationError, compileGraphDefinition, validateDomainEventEnvelope, validateDomainEventId, validateNewDomainEvent, validateRunDefinition, validateRunStartRecord, validateRunStoragePolicy, validateRunStorageRecord } from './chunk-VWZKI7AG.js';
+export { acceptedResultMatches, validateAcceptedResultRecord } from './chunk-6NA4RDQ4.js';
+import { validateCallbackRequest } from './chunk-6NAMCSPJ.js';
+export { ApprovalSubjectError, approvalSubjectDigest, assertApprovalPermissionsAdmitted, callbackRequestDigest, createApprovalCallbackGate, createCallbackGate, snapshotApprovalSubject, validateActionDecision, validateApprovalRecord, validateApprovalSubject, validateCallbackRequest, validateCallbackResponse } from './chunk-6NAMCSPJ.js';
+import { validateStorageId } from './chunk-WGLWWKF3.js';
+export { validateArtifactReference, validateArtifactScope, validateNewArtifact, validateStorageId } from './chunk-WGLWWKF3.js';
+import { canonicalJson, cloneFrozenJson, digestJson, JsonValueError, StorageError } from './chunk-AJ353QD5.js';
+export { JsonValueError, StorageError, canonicalJson, cloneFrozenJson, digestJson } from './chunk-AJ353QD5.js';
+import { isDeepStrictEqual } from 'util';
+
+// src/contracts.ts
+var SUBAGENT_TOOLS = ["Task", "Agent", "task"];
+var CLAUDE_SUBAGENT_TOOLS = ["Task", "Agent"];
+function assertReadAccess(request) {
+  if (request.workspaceMode === "read" && (request.tools?.length ?? 0) === 0) {
+    throw new TypeError("read workspace requires at least one declared tool");
+  }
+}
+function isEngine(value) {
+  return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.run === "function";
+}
+
+// src/memory-types.ts
+var MEMORY_ROOT = "/memories";
+
+// src/graph-executor.ts
+var GraphExecutionError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "GraphExecutionError";
+    this.code = code;
+  }
+};
+function issue(code, path, message) {
+  return { code, path, message };
+}
+function fail(code, path, message) {
+  throw new GraphValidationError(`Invalid graph plan: ${message}`, [
+    issue(code, path, message)
+  ]);
+}
+function record(value, path, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    fail("INVALID_SHAPE", path, `${label} must be an object.`);
+  }
+  return value;
+}
+function list(value, path, label) {
+  if (!Array.isArray(value)) {
+    fail("INVALID_SHAPE", path, `${label} must be an array.`);
+  }
+  return value;
+}
+function requireFields(value, fields, path) {
+  for (const field of fields) {
+    if (!Object.hasOwn(value, field)) {
+      fail(
+        "MISSING_FIELD",
+        `${path}/${field}`,
+        `Required field "${field}" is missing.`
+      );
+    }
+  }
+}
+function exactFields(value, fields, path) {
+  requireFields(value, fields, path);
+  const expected = new Set(fields);
+  for (const field of Object.keys(value)) {
+    if (!expected.has(field)) {
+      fail(
+        "UNKNOWN_FIELD",
+        `${path}/${field}`,
+        `Unknown field "${field}" is not allowed.`
+      );
+    }
+  }
+}
+function json(value, path) {
+  try {
+    return cloneFrozenJson(value);
+  } catch (error) {
+    if (!(error instanceof JsonValueError)) throw error;
+    fail("INVALID_JSON_VALUE", `${path}${error.path}`, error.message);
+  }
+}
+function text(value, path, label) {
+  if (typeof value !== "string" || value.trim().length === 0 || /[\u0000-\u001f\u007f]/.test(value)) {
+    fail("INVALID_TEXT", path, `${label} must be a non-empty string without control characters.`);
+  }
+  return value;
+}
+function identifier(value, path, label) {
+  if (typeof value !== "string" || value.length === 0 || value !== value.trim() || /[\u0000-\u001f\u007f]/.test(value)) {
+    fail(
+      "INVALID_ID",
+      path,
+      `${label} must be a non-empty trimmed string without control characters.`
+    );
+  }
+  return value;
+}
+function positiveVersion(value, path) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    fail("INVALID_VERSION", path, "Version must be a positive safe integer.");
+  }
+  return value;
+}
+function digest(value, path) {
+  if (typeof value !== "string" || !/^sha256:[0-9a-f]{64}$/.test(value)) {
+    fail("INVALID_DIGEST", path, "Digest must be lowercase sha256 followed by 64 hex characters.");
+  }
+  return value;
+}
+function unique(values, path, label) {
+  const seen = /* @__PURE__ */ new Set();
+  for (let index = 0; index < values.length; index += 1) {
+    const value = text(values[index], `${path}/${index}`, label);
+    if (seen.has(value)) fail("DUPLICATE_ID", `${path}/${index}`, `Duplicate ${label} "${value}".`);
+    seen.add(value);
+  }
+}
+function target(value, path) {
+  const item = record(value, path, "Execution target");
+  requireFields(item, ["adapter", "provider", "modelFamily", "model", "tools"], path);
+  text(value.adapter, `${path}/adapter`, "adapter");
+  text(value.provider, `${path}/provider`, "provider");
+  text(value.modelFamily, `${path}/modelFamily`, "modelFamily");
+  text(value.model, `${path}/model`, "model");
+  unique(list(value.tools, `${path}/tools`, "tools"), `${path}/tools`, "tool");
+}
+function bound(value, path) {
+  const item = record(value, path, "Plan bound");
+  requireFields(item, ["kind"], path);
+  if (value.kind === "known") {
+    requireFields(item, ["value"], path);
+    if (!Number.isSafeInteger(value.value) || value.value < 0) {
+      fail("INVALID_BOUND", `${path}/value`, "A known bound must be a non-negative safe integer.");
+    }
+    return;
+  }
+  if (value.kind === "unknown") {
+    requireFields(item, ["reason"], path);
+    text(value.reason, `${path}/reason`, "unknown-bound reason");
+    return;
+  }
+  fail("INVALID_BOUND", `${path}/kind`, "Bound kind must be known or unknown.");
+}
+function permission(value, path) {
+  const item = record(value, path, "Permission");
+  requireFields(item, ["name", "scope"], path);
+  text(value.name, `${path}/name`, "permission name");
+  json(value.scope, `${path}/scope`);
+}
+function packageIdentity(value, path) {
+  const item = record(value, path, "Package identity");
+  requireFields(item, ["source", "version", "digest"], path);
+  text(value.source, `${path}/source`, "package source");
+  text(value.version, `${path}/version`, "package version");
+  digest(value.digest, `${path}/digest`);
+}
+function strictTarget(value, path) {
+  const item = record(value, path, "Execution target");
+  exactFields(item, ["adapter", "provider", "modelFamily", "model", "tools"], path);
+  target(item, path);
+}
+function strictPermission(value, path) {
+  const item = record(value, path, "Permission");
+  exactFields(item, ["name", "scope"], path);
+  permission(item, path);
+}
+function strictBound(value, path) {
+  const item = record(value, path, "Plan bound");
+  bound(item, path);
+  exactFields(
+    item,
+    item.kind === "known" ? ["kind", "value"] : ["kind", "reason"],
+    path
+  );
+}
+function preflightPolicy(value, laneIds) {
+  const root = record(value, "/preflight", "Preflight policy");
+  exactFields(root, ["timeoutMs", "lanes"], "/preflight");
+  if (!Number.isSafeInteger(root.timeoutMs) || root.timeoutMs < 1 || root.timeoutMs > 2147483647) {
+    fail("INVALID_BOUND", "/preflight/timeoutMs", "Preflight timeout must be an integer from 1 to 2147483647 milliseconds.");
+  }
+  const remaining = new Set(laneIds);
+  const lanes = list(root.lanes, "/preflight/lanes", "Preflight lanes");
+  for (let index = 0; index < lanes.length; index += 1) {
+    const path = `/preflight/lanes/${index}`;
+    const lane = record(lanes[index], path, "Preflight lane");
+    exactFields(lane, ["laneId", "live", "unsupportedStatic"], path);
+    const laneId = identifier(lane.laneId, `${path}/laneId`, "lane id");
+    if (!remaining.delete(laneId)) {
+      fail("INVALID_LANE_RESOLUTION", `${path}/laneId`, "Preflight lane is unknown or duplicated.");
+    }
+    if (lane.live !== "required" && lane.live !== "skip") {
+      fail("INVALID_SHAPE", `${path}/live`, "Preflight live policy must be required or skip.");
+    }
+    if (lane.unsupportedStatic !== "block" && lane.unsupportedStatic !== "allow") {
+      fail("INVALID_SHAPE", `${path}/unsupportedStatic`, "Unsupported static policy must be block or allow.");
+    }
+  }
+  if (remaining.size !== 0) {
+    fail("INVALID_LANE_RESOLUTION", "/preflight/lanes", "Every resolved lane needs one preflight policy.");
+  }
+  return root;
+}
+function validateResolvedPlan(value) {
+  const raw = json(value, "");
+  const root = record(raw, "", "Resolved plan");
+  exactFields(root, [
+    "schemaVersion",
+    "graph",
+    "package",
+    "inputContract",
+    "outputContract",
+    "phases",
+    "nodes",
+    "edges",
+    "policies",
+    "executionLanes",
+    "permissions",
+    "bounds",
+    "requirements",
+    ...Object.hasOwn(root, "preflight") ? ["preflight"] : []
+  ], "");
+  const graph = record(root.graph, "/graph", "Graph metadata");
+  exactFields(graph, [
+    "id",
+    "definitionVersion",
+    "kind",
+    "typeVersion",
+    "definitionDigest"
+  ], "/graph");
+  const packageValue = record(root.package, "/package", "Package identity");
+  exactFields(packageValue, ["source", "version", "digest"], "/package");
+  const phases = list(root.phases, "/phases", "Phases");
+  phases.forEach((phase, index) => {
+    const item = record(phase, `/phases/${index}`, "Phase");
+    exactFields(item, ["id", "name", "nodeIds"], `/phases/${index}`);
+  });
+  const nodes = list(root.nodes, "/nodes", "Nodes");
+  nodes.forEach((node, index) => {
+    const item = record(node, `/nodes/${index}`, "Node description");
+    exactFields(item, [
+      "id",
+      "phaseId",
+      "inputContract",
+      "outputContract",
+      "laneId"
+    ], `/nodes/${index}`);
+  });
+  const edges = list(root.edges, "/edges", "Edges");
+  edges.forEach((edge, index) => {
+    const item = record(edge, `/edges/${index}`, "Edge description");
+    exactFields(item, ["id", "source", "target"], `/edges/${index}`);
+  });
+  const policies = record(root.policies, "/policies", "Policies");
+  exactFields(policies, [
+    "retry",
+    "stop",
+    "concurrency",
+    "write",
+    "budget",
+    "action"
+  ], "/policies");
+  const lanes = list(root.executionLanes, "/executionLanes", "Execution lanes");
+  lanes.forEach((lane, index) => {
+    const path = `/executionLanes/${index}`;
+    const item = record(lane, path, "Resolved execution lane");
+    exactFields(item, [
+      "id",
+      "requested",
+      "knownSubstitutions",
+      "effective",
+      "fallbacks"
+    ], path);
+    strictTarget(item.requested, `${path}/requested`);
+    list(
+      item.knownSubstitutions,
+      `${path}/knownSubstitutions`,
+      "Known substitutions"
+    ).forEach((targetValue, targetIndex) => {
+      strictTarget(
+        targetValue,
+        `${path}/knownSubstitutions/${targetIndex}`
+      );
+    });
+    strictTarget(item.effective, `${path}/effective`);
+    list(item.fallbacks, `${path}/fallbacks`, "Fallbacks").forEach((targetValue, targetIndex) => {
+      strictTarget(targetValue, `${path}/fallbacks/${targetIndex}`);
+    });
+  });
+  const permissions = record(root.permissions, "/permissions", "Permissions");
+  exactFields(permissions, ["requested", "admitted"], "/permissions");
+  list(permissions.requested, "/permissions/requested", "Requested permissions").forEach((item, index) => {
+    strictPermission(item, `/permissions/requested/${index}`);
+  });
+  list(permissions.admitted, "/permissions/admitted", "Admitted permissions").forEach((item, index) => {
+    strictPermission(item, `/permissions/admitted/${index}`);
+  });
+  const bounds = record(root.bounds, "/bounds", "Bounds");
+  exactFields(bounds, [
+    "dispatches",
+    "maxConcurrency",
+    "maxFanOut"
+  ], "/bounds");
+  const dispatches = record(
+    bounds.dispatches,
+    "/bounds/dispatches",
+    "Dispatch bounds"
+  );
+  exactFields(dispatches, ["min", "max"], "/bounds/dispatches");
+  strictBound(dispatches.min, "/bounds/dispatches/min");
+  strictBound(dispatches.max, "/bounds/dispatches/max");
+  strictBound(bounds.maxConcurrency, "/bounds/maxConcurrency");
+  strictBound(bounds.maxFanOut, "/bounds/maxFanOut");
+  const requirements = record(root.requirements, "/requirements", "Requirements");
+  exactFields(requirements, ["memory"], "/requirements");
+  const plan = root;
+  const description = validateGraphDescription({
+    schemaVersion: plan.schemaVersion,
+    graph: plan.graph,
+    inputContract: plan.inputContract,
+    outputContract: plan.outputContract,
+    phases: plan.phases,
+    nodes: plan.nodes,
+    edges: plan.edges,
+    policies: plan.policies,
+    executionLanes: plan.executionLanes.map((lane) => ({
+      id: lane.id,
+      requested: lane.requested,
+      knownSubstitutions: lane.knownSubstitutions
+    })),
+    requestedPermissions: plan.permissions.requested,
+    bounds: plan.bounds,
+    requirements: plan.requirements
+  });
+  const rebuilt = resolveGraphPlan(description, {
+    package: plan.package,
+    admission: {
+      package: plan.package,
+      permissions: plan.permissions.admitted
+    },
+    executionLanes: plan.executionLanes.map((lane) => ({
+      id: lane.id,
+      effective: lane.effective,
+      fallbacks: lane.fallbacks
+    })),
+    ...Object.hasOwn(root, "preflight") ? { preflight: plan.preflight } : {}
+  }).plan;
+  if (!isDeepStrictEqual(plan, rebuilt)) {
+    fail(
+      "RESOLVED_PLAN_MISMATCH",
+      "",
+      "Resolved plan does not match its graph description and host resolution."
+    );
+  }
+  return rebuilt;
+}
+function validateGraphDescription(value) {
+  const raw = json(value, "");
+  const root = record(raw, "", "Graph description");
+  requireFields(root, [
+    "schemaVersion",
+    "graph",
+    "inputContract",
+    "outputContract",
+    "phases",
+    "nodes",
+    "edges",
+    "policies",
+    "executionLanes",
+    "requestedPermissions",
+    "bounds",
+    "requirements"
+  ], "");
+  const graph = record(root.graph, "/graph", "Graph metadata");
+  requireFields(graph, [
+    "id",
+    "definitionVersion",
+    "kind",
+    "typeVersion",
+    "definitionDigest"
+  ], "/graph");
+  const phaseValues = list(root.phases, "/phases", "Phases");
+  const nodeValues = list(root.nodes, "/nodes", "Nodes");
+  const edgeValues = list(root.edges, "/edges", "Edges");
+  const laneValues = list(root.executionLanes, "/executionLanes", "Execution lanes");
+  const permissionValues = list(
+    root.requestedPermissions,
+    "/requestedPermissions",
+    "Requested permissions"
+  );
+  const policies = record(root.policies, "/policies", "Policies");
+  requireFields(policies, [
+    "retry",
+    "stop",
+    "concurrency",
+    "write",
+    "budget",
+    "action"
+  ], "/policies");
+  const bounds = record(root.bounds, "/bounds", "Bounds");
+  requireFields(bounds, [
+    "dispatches",
+    "maxConcurrency",
+    "maxFanOut"
+  ], "/bounds");
+  const dispatchBounds = record(bounds.dispatches, "/bounds/dispatches", "Dispatch bounds");
+  requireFields(dispatchBounds, ["min", "max"], "/bounds/dispatches");
+  const requirements = record(root.requirements, "/requirements", "Requirements");
+  requireFields(requirements, ["memory"], "/requirements");
+  phaseValues.forEach((phase, index) => {
+    const item = record(phase, `/phases/${index}`, "Phase");
+    requireFields(item, ["id", "name", "nodeIds"], `/phases/${index}`);
+    list(item.nodeIds, `/phases/${index}/nodeIds`, "Phase nodeIds");
+  });
+  nodeValues.forEach((node, index) => {
+    const item = record(node, `/nodes/${index}`, "Node description");
+    requireFields(item, [
+      "id",
+      "phaseId",
+      "inputContract",
+      "outputContract",
+      "laneId"
+    ], `/nodes/${index}`);
+  });
+  edgeValues.forEach((edge, index) => {
+    const item = record(edge, `/edges/${index}`, "Edge description");
+    requireFields(item, ["id", "source", "target"], `/edges/${index}`);
+  });
+  laneValues.forEach((lane, index) => {
+    const item = record(lane, `/executionLanes/${index}`, "Execution lane");
+    requireFields(item, [
+      "id",
+      "requested",
+      "knownSubstitutions"
+    ], `/executionLanes/${index}`);
+    list(
+      item.knownSubstitutions,
+      `/executionLanes/${index}/knownSubstitutions`,
+      "Known substitutions"
+    );
+  });
+  permissionValues.forEach((item, index) => {
+    record(item, `/requestedPermissions/${index}`, "Permission");
+  });
+  const description = root;
+  if (description.schemaVersion !== 1) {
+    fail("INVALID_SCHEMA_VERSION", "/schemaVersion", "Graph description schemaVersion must be 1.");
+  }
+  identifier(description.graph.id, "/graph/id", "graph id");
+  positiveVersion(description.graph.definitionVersion, "/graph/definitionVersion");
+  text(description.graph.kind, "/graph/kind", "graph kind");
+  positiveVersion(description.graph.typeVersion, "/graph/typeVersion");
+  digest(description.graph.definitionDigest, "/graph/definitionDigest");
+  description.phases.forEach((phase, index) => {
+    identifier(phase.id, `/phases/${index}/id`, "phase id");
+  });
+  description.nodes.forEach((node, index) => {
+    identifier(node.id, `/nodes/${index}/id`, "node id");
+  });
+  description.edges.forEach((edge, index) => {
+    identifier(edge.id, `/edges/${index}/id`, "edge id");
+  });
+  description.executionLanes.forEach((lane, index) => {
+    identifier(lane.id, `/executionLanes/${index}/id`, "lane id");
+  });
+  description.phases.forEach((phase, phaseIndex) => {
+    phase.nodeIds.forEach((nodeId, nodeIndex) => {
+      identifier(nodeId, `/phases/${phaseIndex}/nodeIds/${nodeIndex}`, "node id");
+    });
+  });
+  description.nodes.forEach((node, index) => {
+    identifier(node.phaseId, `/nodes/${index}/phaseId`, "phase id");
+    if (node.laneId !== null) {
+      identifier(node.laneId, `/nodes/${index}/laneId`, "lane id");
+    }
+  });
+  description.edges.forEach((edge, index) => {
+    identifier(edge.source, `/edges/${index}/source`, "node id");
+    identifier(edge.target, `/edges/${index}/target`, "node id");
+  });
+  unique(description.phases.map((phase) => phase.id), "/phases", "phase id");
+  unique(description.nodes.map((node) => node.id), "/nodes", "node id");
+  unique(description.edges.map((edge) => edge.id), "/edges", "edge id");
+  unique(description.executionLanes.map((lane) => lane.id), "/executionLanes", "lane id");
+  unique(description.requestedPermissions.map((item) => item.name), "/requestedPermissions", "permission name");
+  const phaseIds = new Set(description.phases.map((phase) => phase.id));
+  const nodeIds = new Set(description.nodes.map((node) => node.id));
+  const laneIds = new Set(description.executionLanes.map((lane) => lane.id));
+  const assignedNodes = [];
+  const assignedPhaseByNode = /* @__PURE__ */ new Map();
+  for (let index = 0; index < description.phases.length; index += 1) {
+    const phase = description.phases[index];
+    text(phase.name, `/phases/${index}/name`, "phase name");
+    unique(phase.nodeIds, `/phases/${index}/nodeIds`, "node id");
+    for (const nodeId of phase.nodeIds) {
+      if (!nodeIds.has(nodeId)) {
+        fail("UNKNOWN_NODE", `/phases/${index}/nodeIds`, `Phase refers to unknown node "${nodeId}".`);
+      }
+      assignedNodes.push(nodeId);
+      assignedPhaseByNode.set(nodeId, phase.id);
+    }
+  }
+  if (assignedNodes.length !== nodeIds.size || new Set(assignedNodes).size !== nodeIds.size) {
+    fail("INVALID_PHASE_ASSIGNMENT", "/phases", "Every node must appear in exactly one phase.");
+  }
+  for (let index = 0; index < description.nodes.length; index += 1) {
+    const node = description.nodes[index];
+    if (!phaseIds.has(node.phaseId)) {
+      fail("UNKNOWN_PHASE", `/nodes/${index}/phaseId`, `Node refers to unknown phase "${node.phaseId}".`);
+    }
+    if (assignedPhaseByNode.get(node.id) !== node.phaseId) {
+      fail(
+        "INVALID_PHASE_ASSIGNMENT",
+        `/nodes/${index}/phaseId`,
+        `Node "${node.id}" claims phase "${node.phaseId}" but is listed in phase "${assignedPhaseByNode.get(node.id)}".`
+      );
+    }
+    if (node.laneId !== null && !laneIds.has(node.laneId)) {
+      fail("UNKNOWN_LANE", `/nodes/${index}/laneId`, `Node refers to unknown lane "${node.laneId}".`);
+    }
+  }
+  for (let index = 0; index < description.edges.length; index += 1) {
+    const edge = description.edges[index];
+    if (!nodeIds.has(edge.source) || !nodeIds.has(edge.target)) {
+      fail("UNKNOWN_NODE", `/edges/${index}`, "Edge refers to an unknown node.");
+    }
+  }
+  for (let index = 0; index < description.executionLanes.length; index += 1) {
+    const lane = description.executionLanes[index];
+    target(lane.requested, `/executionLanes/${index}/requested`);
+    const substitutions = /* @__PURE__ */ new Set();
+    for (let item = 0; item < lane.knownSubstitutions.length; item += 1) {
+      const substitution = lane.knownSubstitutions[item];
+      target(substitution, `/executionLanes/${index}/knownSubstitutions/${item}`);
+      const key = canonicalJson(substitution);
+      if (substitutions.has(key)) {
+        fail("DUPLICATE_SUBSTITUTION", `/executionLanes/${index}/knownSubstitutions/${item}`, "Execution substitution is duplicated.");
+      }
+      substitutions.add(key);
+    }
+  }
+  for (let index = 0; index < description.requestedPermissions.length; index += 1) {
+    permission(description.requestedPermissions[index], `/requestedPermissions/${index}`);
+  }
+  bound(description.bounds.dispatches.min, "/bounds/dispatches/min");
+  bound(description.bounds.dispatches.max, "/bounds/dispatches/max");
+  bound(description.bounds.maxConcurrency, "/bounds/maxConcurrency");
+  bound(description.bounds.maxFanOut, "/bounds/maxFanOut");
+  const min = description.bounds.dispatches.min;
+  const max = description.bounds.dispatches.max;
+  if (min.kind === "known" && max.kind === "known" && min.value > max.value) {
+    fail("INVALID_BOUND", "/bounds/dispatches", "Minimum dispatches cannot exceed maximum dispatches.");
+  }
+  if (description.requirements.memory !== "required" && description.requirements.memory !== "unused") {
+    fail("INVALID_REQUIREMENT", "/requirements/memory", "Memory must be required or unused.");
+  }
+  return description;
+}
+function resolveGraphPlan(value, input) {
+  const description = validateGraphDescription(value);
+  const raw = json(input, "");
+  const root = record(raw, "", "Plan resolution");
+  requireFields(root, ["package", "admission", "executionLanes"], "");
+  const admission = record(root.admission, "/admission", "Package admission");
+  requireFields(admission, ["package", "permissions"], "/admission");
+  list(admission.permissions, "/admission/permissions", "Admitted permissions").forEach((item, index) => {
+    record(item, `/admission/permissions/${index}`, "Permission");
+  });
+  list(root.executionLanes, "/executionLanes", "Lane resolutions").forEach((item, index) => {
+    const lane = record(item, `/executionLanes/${index}`, "Lane resolution");
+    requireFields(lane, ["id", "effective"], `/executionLanes/${index}`);
+    list(
+      lane.fallbacks ?? [],
+      `/executionLanes/${index}/fallbacks`,
+      "Fallbacks"
+    );
+  });
+  const resolution = root;
+  packageIdentity(resolution.package, "/package");
+  packageIdentity(resolution.admission.package, "/admission/package");
+  if (!isDeepStrictEqual(resolution.package, resolution.admission.package)) {
+    fail("PACKAGE_NOT_ADMITTED", "/admission/package", "Host admission does not match the requested package.");
+  }
+  unique(resolution.executionLanes.map((lane) => lane.id), "/executionLanes", "lane resolution id");
+  const resolutions = new Map(resolution.executionLanes.map((lane) => [lane.id, lane]));
+  if (resolutions.size !== description.executionLanes.length) {
+    fail("INVALID_LANE_RESOLUTION", "/executionLanes", "Every described lane needs exactly one resolution.");
+  }
+  const resolvedLanes = [];
+  for (let index = 0; index < description.executionLanes.length; index += 1) {
+    const lane = description.executionLanes[index];
+    const resolved = resolutions.get(lane.id);
+    if (!resolved) {
+      fail("INVALID_LANE_RESOLUTION", "/executionLanes", `Lane "${lane.id}" has no resolution.`);
+    }
+    target(resolved.effective, `/executionLanes/${index}/effective`);
+    const allowed = [lane.requested, ...lane.knownSubstitutions];
+    if (!allowed.some((candidate) => isDeepStrictEqual(candidate, resolved.effective))) {
+      fail("UNKNOWN_SUBSTITUTION", `/executionLanes/${index}/effective`, `Lane "${lane.id}" uses an undeclared substitution.`);
+    }
+    const fallbacks = resolved.fallbacks ?? [];
+    const fallbackKeys = /* @__PURE__ */ new Set();
+    for (let fallbackIndex = 0; fallbackIndex < fallbacks.length; fallbackIndex += 1) {
+      const fallback = fallbacks[fallbackIndex];
+      const path = `/executionLanes/${index}/fallbacks/${fallbackIndex}`;
+      target(fallback, path);
+      if (!allowed.some((candidate) => isDeepStrictEqual(candidate, fallback))) {
+        fail("UNKNOWN_SUBSTITUTION", path, `Lane "${lane.id}" uses an undeclared fallback.`);
+      }
+      if (isDeepStrictEqual(fallback, resolved.effective)) {
+        fail("DUPLICATE_SUBSTITUTION", path, "A fallback cannot repeat the effective target.");
+      }
+      const key = canonicalJson(fallback);
+      if (fallbackKeys.has(key)) {
+        fail("DUPLICATE_SUBSTITUTION", path, "Execution fallback is duplicated.");
+      }
+      fallbackKeys.add(key);
+    }
+    resolvedLanes.push({
+      ...lane,
+      effective: resolved.effective,
+      fallbacks
+    });
+    resolutions.delete(lane.id);
+  }
+  if (resolutions.size > 0) {
+    fail("INVALID_LANE_RESOLUTION", "/executionLanes", "Resolution contains an unknown lane.");
+  }
+  const preflight = Object.hasOwn(root, "preflight") ? preflightPolicy(root.preflight, resolvedLanes.map((lane) => lane.id)) : void 0;
+  const admittedByName = /* @__PURE__ */ new Map();
+  for (let index = 0; index < resolution.admission.permissions.length; index += 1) {
+    const item = resolution.admission.permissions[index];
+    permission(item, `/admission/permissions/${index}`);
+    if (admittedByName.has(item.name)) {
+      fail("DUPLICATE_PERMISSION", `/admission/permissions/${index}`, `Permission "${item.name}" is duplicated.`);
+    }
+    admittedByName.set(item.name, item);
+  }
+  for (let index = 0; index < description.requestedPermissions.length; index += 1) {
+    const requested = description.requestedPermissions[index];
+    const admitted = admittedByName.get(requested.name);
+    if (!admitted || canonicalJson(admitted.scope) !== canonicalJson(requested.scope)) {
+      fail("PERMISSION_NOT_ADMITTED", `/requestedPermissions/${index}`, `Permission "${requested.name}" is outside host admission.`);
+    }
+  }
+  const plan = cloneFrozenJson({
+    schemaVersion: 1,
+    graph: description.graph,
+    package: resolution.package,
+    inputContract: description.inputContract,
+    outputContract: description.outputContract,
+    phases: description.phases,
+    nodes: description.nodes,
+    edges: description.edges,
+    policies: description.policies,
+    executionLanes: resolvedLanes,
+    ...preflight === void 0 ? {} : { preflight },
+    permissions: {
+      requested: description.requestedPermissions,
+      admitted: resolution.admission.permissions
+    },
+    bounds: description.bounds,
+    requirements: description.requirements
+  });
+  const canonical = canonicalJson(plan);
+  return Object.freeze({
+    plan,
+    canonicalJson: canonical,
+    digest: digestJson(plan)
+  });
+}
+
+// src/events/store.ts
+function fail2(message, path) {
+  throw new StorageError("INVALID_STORED_VALUE", message, { path });
+}
+function validateEventStreamRef(value) {
+  let safe;
+  try {
+    safe = cloneFrozenJson(value);
+  } catch (error) {
+    if (!(error instanceof JsonValueError)) throw error;
+    fail2(error.message, error.path);
+  }
+  if (safe === null || typeof safe !== "object" || Array.isArray(safe)) {
+    fail2("Event stream reference must be an object.", "");
+  }
+  const record2 = safe;
+  const fields = Object.keys(record2).sort();
+  if (fields.length !== 2 || fields[0] !== "namespace" || fields[1] !== "streamId") {
+    fail2(
+      "Event stream reference must contain exactly namespace and streamId.",
+      ""
+    );
+  }
+  validateStorageId(record2.namespace, "/namespace");
+  validateStorageId(record2.streamId, "/streamId");
+  return record2;
+}
+function validateStreamRevision(value, path) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    fail2("Stream revision must be a non-negative safe integer.", path);
+  }
+  return value;
+}
+function validateDomainEventBatch(value) {
+  let safe;
+  try {
+    safe = cloneFrozenJson(value);
+  } catch (error) {
+    if (!(error instanceof JsonValueError)) throw error;
+    fail2(error.message, `/events${error.path}`);
+  }
+  if (!Array.isArray(safe) || safe.length === 0) {
+    fail2("An append batch must contain at least one event.", "/events");
+  }
+  const events = safe.map((event) => validateNewDomainEvent(event));
+  return Object.freeze(events);
+}
+function jsonContains(value, needle) {
+  if (typeof value === "string") return value.includes(needle);
+  if (value === null || typeof value !== "object") return false;
+  if (Array.isArray(value)) {
+    return value.some((item) => jsonContains(item, needle));
+  }
+  return Object.entries(value).some(([key, item]) => key.includes(needle) || jsonContains(item, needle));
+}
+function findKnownSecretInEvents(knownSecrets, serializedBytes, events) {
+  return knownSecrets.find((secret) => serializedBytes.includes(secret) || events.some((event) => jsonContains(event, secret)));
+}
+
+// src/callback/client-contract.ts
+var CALLBACK_DIGEST = /^[0-9a-f]{64}$/u;
+function callbackObject(value) {
+  const stored = cloneFrozenJson(value);
+  if (stored === null || typeof stored !== "object" || Array.isArray(stored)) {
+    throw new TypeError("a stored callback event must be an object");
+  }
+  return stored;
+}
+function exactFields2(value, fields) {
+  const actual = Object.keys(value).sort();
+  const expected = [...fields].sort();
+  if (actual.length !== expected.length || actual.some((field, index) => field !== expected[index])) {
+    throw new TypeError("a stored callback event has missing or unknown fields");
+  }
+}
+function callbackText(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`a stored callback event needs ${field}`);
+  }
+  return value;
+}
+function validateCallbackEvent(value) {
+  const event = callbackObject(value);
+  switch (event.kind) {
+    case "callback-requested":
+      exactFields2(event, ["kind", "request"]);
+      validateCallbackRequest(event.request);
+      break;
+    case "callback-claimed":
+      exactFields2(event, ["kind", "requestId", "routerId", "claimToken"]);
+      callbackText(event.requestId, "requestId");
+      callbackText(event.routerId, "routerId");
+      callbackText(event.claimToken, "claimToken");
+      break;
+    case "callback-released":
+      exactFields2(event, ["kind", "requestId", "routerId"]);
+      callbackText(event.requestId, "requestId");
+      callbackText(event.routerId, "routerId");
+      break;
+    case "callback-submitted":
+      if (typeof event.requestDigest !== "string" || !CALLBACK_DIGEST.test(event.requestDigest)) {
+        throw new TypeError("a stored callback submission has an invalid requestDigest");
+      }
+      exactFields2(event, ["kind", "requestId", "requestDigest", "routerId", "response"]);
+      callbackText(event.requestId, "requestId");
+      callbackText(event.routerId, "routerId");
+      break;
+    case "callback-rejected":
+      exactFields2(event, ["kind", "requestId", "routerId", "reason"]);
+      callbackText(event.requestId, "requestId");
+      callbackText(event.routerId, "routerId");
+      callbackText(event.reason, "reason");
+      break;
+    case "callback-superseded":
+      exactFields2(event, ["kind", "requestId", "supersededBy"]);
+      callbackText(event.requestId, "requestId");
+      callbackText(event.supersededBy, "supersededBy");
+      break;
+    default:
+      throw new TypeError("a stored callback event has an unknown kind");
+  }
+  return event;
+}
+
+export { CLAUDE_SUBAGENT_TOOLS, GraphExecutionError, MEMORY_ROOT, SUBAGENT_TOOLS, assertReadAccess, findKnownSecretInEvents, isEngine, resolveGraphPlan, validateCallbackEvent, validateDomainEventBatch, validateEventStreamRef, validateGraphDescription, validateResolvedPlan, validateStreamRevision };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map