@contractspec/lib.surface-runtime 0.3.0 → 0.3.3

package/dist/browser/runtime/index.js

@@ -1,1496 +1,63 @@
-// src/telemetry/surface-metrics.ts
-import {
-  createCounter,
-  createHistogram
-} from "@contractspec/lib.observability/metrics";
-var METER_NAME = "@contractspec/lib.surface-runtime";
-var resolutionDurationMs = createHistogram("bundle_surface_resolution_duration_ms", "Time to resolve bundle spec to surface plan in milliseconds", METER_NAME);
-var patchAcceptanceCounter = createCounter("bundle_surface_patch_acceptance_total", "Total AI patch proposals accepted by user", METER_NAME);
-var patchRejectionCounter = createCounter("bundle_surface_patch_rejection_total", "Total AI patch proposals rejected by user", METER_NAME);
-var policyDenialCounter = createCounter("bundle_surface_policy_denial_total", "Total policy denials (actions denied by policy)", METER_NAME);
-var surfaceFallbackCounter = createCounter("bundle_surface_fallback_total", "Total surface or layout fallbacks during resolution", METER_NAME);
-var missingRendererCounter = createCounter("bundle_surface_renderer_missing_total", "Total slots with no renderer for requested node kind", METER_NAME);
-// src/runtime/resolve-preferences.ts
-var DIMENSION_KEYS = [
-  "guidance",
-  "density",
-  "dataDepth",
-  "control",
-  "media",
-  "pace",
-  "narrative"
-];
-var SCOPE_ORDER = [
-  "user",
-  "workspace-user",
-  "bundle",
-  "surface",
-  "entity",
-  "session"
-];
-function mergeByScope(layers, ctx) {
-  const merged = { ...ctx.preferences };
-  const sourceByDimension = {};
-  for (const scope of SCOPE_ORDER) {
-    const layer = layers[scope];
-    if (!layer)
-      continue;
-    for (const dim of DIMENSION_KEYS) {
-      const val = layer[dim];
-      if (val !== undefined) {
-        merged[dim] = val;
-        sourceByDimension[dim] = scope;
-      }
-    }
-  }
-  for (const dim of DIMENSION_KEYS) {
-    if (sourceByDimension[dim] === undefined) {
-      sourceByDimension[dim] = "session";
-    }
-  }
-  return { canonical: merged, sourceByDimension };
-}
-function resolveConstraints(_canonical, _ctx) {
-  return { constrained: {}, notes: [] };
-}
-function resolvePreferenceProfile(ctx) {
-  const layers = {
-    session: ctx.preferences
-  };
-  const { canonical, sourceByDimension } = mergeByScope(layers, ctx);
-  const { constrained, notes } = resolveConstraints(canonical, ctx);
-  return {
-    canonical,
-    sourceByDimension,
-    constrained,
-    notes
-  };
-}
-
-// src/spec/validate-surface-patch.ts
-var VALID_OPS = [
-  "insert-node",
-  "replace-node",
-  "remove-node",
-  "move-node",
-  "resize-panel",
-  "set-layout",
-  "reveal-field",
-  "hide-field",
-  "promote-action",
-  "set-focus"
-];
-var VALID_NODE_KINDS = [
-  "metric-strip",
-  "data-view",
-  "entity-card",
-  "entity-header",
-  "entity-summary",
-  "entity-section",
-  "entity-field",
-  "entity-activity",
-  "entity-relations",
-  "entity-timeline",
-  "entity-comments",
-  "entity-attachments",
-  "entity-view-switcher",
-  "entity-automation-panel",
-  "rich-doc",
-  "chat-thread",
-  "assistant-panel",
-  "action-bar",
-  "timeline",
-  "board",
-  "table",
-  "calendar",
-  "form",
-  "chart",
-  "relation-graph",
-  "custom-widget"
-];
-function validateSurfaceNode(node, path) {
-  if (!node.nodeId || typeof node.nodeId !== "string") {
-    throw new Error(`${path}: nodeId must be a non-empty string`);
-  }
-  if (!node.kind || !VALID_NODE_KINDS.includes(node.kind)) {
-    throw new Error(`${path}: kind must be one of ${VALID_NODE_KINDS.join(", ")}`);
-  }
-  if (node.children) {
-    for (let i = 0;i < node.children.length; i++) {
-      const child = node.children[i];
-      if (child)
-        validateSurfaceNode(child, `${path}.children[${i}]`);
-    }
-  }
-}
-function validateSurfacePatchOp(op, index) {
-  const path = `ops[${index}]`;
-  if (!op || typeof op !== "object" || !("op" in op)) {
-    throw new Error(`${path}: must be an object with op field`);
-  }
-  const opType = op.op;
-  if (!VALID_OPS.includes(opType)) {
-    throw new Error(`${path}: op must be one of ${VALID_OPS.join(", ")}`);
-  }
-  switch (op.op) {
-    case "insert-node":
-      if (!op.slotId || typeof op.slotId !== "string") {
-        throw new Error(`${path}: insert-node requires slotId string`);
-      }
-      if (!op.node) {
-        throw new Error(`${path}: insert-node requires node`);
-      }
-      validateSurfaceNode(op.node, `${path}.node`);
-      if (op.index !== undefined && typeof op.index !== "number") {
-        throw new Error(`${path}: insert-node index must be number if present`);
-      }
-      break;
-    case "replace-node":
-      if (!op.nodeId || typeof op.nodeId !== "string") {
-        throw new Error(`${path}: replace-node requires nodeId string`);
-      }
-      if (!op.node) {
-        throw new Error(`${path}: replace-node requires node`);
-      }
-      validateSurfaceNode(op.node, `${path}.node`);
-      break;
-    case "remove-node":
-      if (!op.nodeId || typeof op.nodeId !== "string") {
-        throw new Error(`${path}: remove-node requires nodeId string`);
-      }
-      break;
-    case "move-node":
-      if (!op.nodeId || typeof op.nodeId !== "string") {
-        throw new Error(`${path}: move-node requires nodeId string`);
-      }
-      if (!op.toSlotId || typeof op.toSlotId !== "string") {
-        throw new Error(`${path}: move-node requires toSlotId string`);
-      }
-      if (op.index !== undefined && typeof op.index !== "number") {
-        throw new Error(`${path}: move-node index must be number if present`);
-      }
-      break;
-    case "resize-panel":
-      if (!op.persistKey || typeof op.persistKey !== "string") {
-        throw new Error(`${path}: resize-panel requires persistKey string`);
-      }
-      if (!Array.isArray(op.sizes) || op.sizes.some((s) => typeof s !== "number")) {
-        throw new Error(`${path}: resize-panel requires sizes number[]`);
-      }
-      break;
-    case "set-layout":
-      if (!op.layoutId || typeof op.layoutId !== "string") {
-        throw new Error(`${path}: set-layout requires layoutId string`);
-      }
-      break;
-    case "reveal-field":
-    case "hide-field":
-      if (!op.fieldId || typeof op.fieldId !== "string") {
-        throw new Error(`${path}: ${op.op} requires fieldId string`);
-      }
-      break;
-    case "promote-action": {
-      if (!op.actionId || typeof op.actionId !== "string") {
-        throw new Error(`${path}: promote-action requires actionId string`);
-      }
-      const validPlacements = ["header", "inline", "context", "assistant"];
-      if (!op.placement || !validPlacements.includes(op.placement)) {
-        throw new Error(`${path}: promote-action placement must be one of ${validPlacements.join(", ")}`);
-      }
-      break;
-    }
-    case "set-focus":
-      if (!op.targetId || typeof op.targetId !== "string") {
-        throw new Error(`${path}: set-focus requires targetId string`);
-      }
-      break;
-    default:
-      throw new Error(`${path}: unknown op "${opType}"`);
-  }
-}
-function validateSurfacePatch(ops) {
-  if (!Array.isArray(ops)) {
-    throw new Error("Patch ops must be an array");
-  }
-  for (let i = 0;i < ops.length; i++) {
-    const op = ops[i];
-    if (op)
-      validateSurfacePatchOp(op, i);
-  }
-}
-function validateSurfaceNodeAgainstKinds(node, allowedKinds, path) {
-  if (!allowedKinds.includes(node.kind)) {
-    throw new Error(`${path}: kind "${node.kind}" not in allowed list [${allowedKinds.join(", ")}]`);
-  }
-  if (node.children) {
-    for (let i = 0;i < node.children.length; i++) {
-      const child = node.children[i];
-      if (child)
-        validateSurfaceNodeAgainstKinds(child, allowedKinds, `${path}.children[${i}]`);
-    }
-  }
-}
-function validatePatchProposal(ops, constraints) {
-  if (!Array.isArray(ops)) {
-    throw new Error("Patch ops must be an array");
-  }
-  const { allowedOps, allowedSlots, allowedNodeKinds } = constraints;
-  for (let i = 0;i < ops.length; i++) {
-    const op = ops[i];
-    if (!op)
-      continue;
-    const path = `ops[${i}]`;
-    if (!allowedOps.includes(op.op)) {
-      throw new Error(`${path}: op "${op.op}" not in allowed list [${allowedOps.join(", ")}]`);
-    }
-    switch (op.op) {
-      case "insert-node":
-        if (!allowedSlots.includes(op.slotId)) {
-          throw new Error(`${path}: slotId "${op.slotId}" not in allowed slots [${allowedSlots.join(", ")}]`);
-        }
-        if (op.node) {
-          validateSurfaceNodeAgainstKinds(op.node, allowedNodeKinds, `${path}.node`);
-        }
-        break;
-      case "move-node":
-        if (!allowedSlots.includes(op.toSlotId)) {
-          throw new Error(`${path}: toSlotId "${op.toSlotId}" not in allowed slots [${allowedSlots.join(", ")}]`);
-        }
-        break;
-      case "replace-node":
-        if (op.node) {
-          validateSurfaceNodeAgainstKinds(op.node, allowedNodeKinds, `${path}.node`);
-        }
-        break;
-      default:
-        break;
-    }
-  }
-  validateSurfacePatch(ops);
-}
-
-// src/runtime/apply-surface-patch.ts
-import { Logger } from "@contractspec/lib.observability";
-var logger = new Logger("@contractspec/lib.surface-runtime");
-function findNode(nodes, nodeId) {
-  for (const n of nodes) {
-    if (n.nodeId === nodeId)
-      return n;
-    if (n.children) {
-      const found = findNode(n.children, nodeId);
-      if (found)
-        return found;
-    }
-  }
-  return;
-}
-function collectNodeIds(nodes) {
-  const ids = new Set;
-  for (const n of nodes) {
-    ids.add(n.nodeId);
-    if (n.children)
-      collectNodeIds(n.children).forEach((id) => ids.add(id));
-  }
-  return ids;
-}
-function validateOp(op, nodeIds) {
-  if (op.op === "remove-node" || op.op === "replace-node" || op.op === "move-node") {
-    if (!nodeIds.has(op.nodeId)) {
-      throw new Error(`Patch op references unknown nodeId: ${op.nodeId}`);
-    }
-  }
-  if (op.op === "insert-node" && !op.node?.nodeId) {
-    throw new Error("insert-node requires node with nodeId");
-  }
-}
-function produceInverse(op, plan) {
-  switch (op.op) {
-    case "insert-node":
-      return op.node ? { op: "remove-node", nodeId: op.node.nodeId } : null;
-    case "remove-node": {
-      const node = findNode(plan.nodes, op.nodeId);
-      return node ? { op: "insert-node", slotId: "primary", node } : null;
-    }
-    case "replace-node": {
-      const prev = findNode(plan.nodes, op.nodeId);
-      return prev ? { op: "replace-node", nodeId: op.nodeId, node: prev } : null;
-    }
-    case "set-layout":
-      return { op: "set-layout", layoutId: plan.layoutId };
-    case "reveal-field":
-      return { op: "hide-field", fieldId: op.fieldId };
-    case "hide-field":
-      return { op: "reveal-field", fieldId: op.fieldId };
-    case "move-node":
-    case "resize-panel":
-    case "set-focus":
-    case "promote-action":
-      return null;
-    default:
-      return null;
-  }
-}
-function applySurfacePatch(plan, ops) {
-  if (ops.length === 0)
-    return { plan, inverseOps: [] };
-  validateSurfacePatch(ops);
-  const nodeIds = collectNodeIds(plan.nodes);
-  for (const op of ops) {
-    validateOp(op, nodeIds);
-  }
-  let nextNodes = [...plan.nodes];
-  let nextLayoutId = plan.layoutId;
-  const inverseOps = [];
-  for (const op of ops) {
-    const inv = produceInverse(op, {
-      ...plan,
-      nodes: nextNodes,
-      layoutId: nextLayoutId
-    });
-    if (inv)
-      inverseOps.unshift(inv);
-    switch (op.op) {
-      case "insert-node":
-        if (op.node)
-          nextNodes = [...nextNodes, op.node];
-        break;
-      case "remove-node":
-        nextNodes = nextNodes.filter((n) => n.nodeId !== op.nodeId);
-        break;
-      case "replace-node": {
-        const replace = (nodes) => nodes.map((n) => n.nodeId === op.nodeId ? op.node : { ...n, children: n.children ? replace(n.children) : undefined });
-        nextNodes = replace(nextNodes);
-        break;
-      }
-      case "set-layout":
-        nextLayoutId = op.layoutId;
-        break;
-      case "move-node":
-      case "resize-panel":
-      case "set-focus":
-      case "reveal-field":
-      case "hide-field":
-      case "promote-action":
-        break;
-    }
-  }
-  const result = {
-    plan: { ...plan, nodes: nextNodes, layoutId: nextLayoutId },
-    inverseOps
-  };
-  logger.info("bundle.surface.patch.applied", {
-    bundleKey: plan.bundleKey,
-    surfaceId: plan.surfaceId,
-    opCount: ops.length,
-    opTypes: [...new Set(ops.map((o) => o.op))]
-  });
-  return result;
-}
-
-// src/runtime/override-store.ts
-function buildOverrideTargetKey(bundleKey, surfaceId, routeId) {
-  return routeId ? `${bundleKey}:${routeId}:${surfaceId}` : `${bundleKey}:${surfaceId}`;
-}
-function createOverrideStoreWithApprovalGate(store, options) {
-  const { requireApprovalForWorkspacePatches = false, requestApproval } = options;
-  return {
-    list: store.list.bind(store),
-    async save(scope, targetKey, patch, saveOptions) {
-      if (requireApprovalForWorkspacePatches && scope === "workspace" && requestApproval) {
-        const approved = await requestApproval({ scope, targetKey, patch });
-        if (!approved) {
-          throw new Error("Workspace overlay save rejected: approval required and not granted");
-        }
-      }
-      return store.save(scope, targetKey, patch, saveOptions);
-    },
-    remove: store.remove.bind(store)
-  };
-}
-function createInMemoryOverrideStore() {
-  const overrides = new Map;
-  function nextId() {
-    return `ov_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
-  }
-  return {
-    async list(scope, targetKey) {
-      return Array.from(overrides.values()).filter((o) => o.scope === scope && o.targetKey === targetKey);
-    },
-    async save(scope, targetKey, patch, options) {
-      const overrideId = options?.overrideId ?? nextId();
-      const stored = {
-        overrideId,
-        scope,
-        targetKey,
-        patch,
-        createdAt: new Date().toISOString(),
-        createdBy: options?.createdBy
-      };
-      overrides.set(overrideId, stored);
-      return overrideId;
-    },
-    async remove(overrideId) {
-      overrides.delete(overrideId);
-    }
-  };
-}
-
-// src/runtime/resolve-bundle.ts
-import { traceAsync } from "@contractspec/lib.observability/tracing";
-import { Logger as Logger2 } from "@contractspec/lib.observability";
-var logger2 = new Logger2("@contractspec/lib.surface-runtime");
-function getOpTarget(op) {
-  switch (op.op) {
-    case "hide-field":
-    case "reveal-field":
-      return `field:${op.fieldId}`;
-    case "remove-node":
-    case "replace-node":
-    case "move-node":
-      return `node:${op.nodeId}`;
-    case "insert-node":
-      return op.slotId ? `slot:${op.slotId}` : null;
-    default:
-      return null;
-  }
-}
-function matchRoute(pathPattern, route) {
-  if (pathPattern === route)
-    return true;
-  const patternParts = pathPattern.split("/");
-  const routeParts = route.split("/");
-  if (patternParts.length !== routeParts.length)
-    return false;
-  for (let i = 0;i < patternParts.length; i++) {
-    const p = patternParts[i];
-    const r = routeParts[i];
-    if (p?.startsWith(":"))
-      continue;
-    if (p !== r)
-      return false;
-  }
-  return true;
-}
-function selectSurface(spec, ctx) {
-  const route = spec.routes.find((r) => matchRoute(r.path, ctx.route)) ?? spec.routes[0];
-  if (!route) {
-    throw new Error("No routes declared in bundle spec.");
-  }
-  const fallbackRoute = !spec.routes.find((r) => matchRoute(r.path, ctx.route));
-  let surface = spec.surfaces[route.defaultSurface];
-  let fallback;
-  if (!surface && route.candidateSurfaces?.length) {
-    for (const sid of route.candidateSurfaces) {
-      surface = spec.surfaces[sid];
-      if (surface) {
-        fallback = `surface=${sid}`;
-        break;
-      }
-    }
-  }
-  if (!surface) {
-    const overview = Object.values(spec.surfaces).find((s) => s.kind === "overview");
-    if (overview) {
-      surface = overview;
-      fallback = "surface=overview";
-    }
-  }
-  if (!surface) {
-    throw new Error(`Default surface "${route.defaultSurface}" was not found.`);
-  }
-  return {
-    surface,
-    routeId: route.routeId,
-    fallback: fallback ?? (fallbackRoute ? "route" : undefined)
-  };
-}
-function selectLayout(surface, ctx, spec) {
-  let preferredLayoutId;
-  if (ctx.activeViewId && ctx.entity?.type && spec?.entities?.viewKinds) {
-    const viewKind = spec.entities.viewKinds[ctx.activeViewId];
-    const entityType = spec.entities.entityTypes[ctx.entity.type];
-    if (viewKind?.defaultLayoutId && entityType?.supportedViews?.includes(ctx.activeViewId)) {
-      preferredLayoutId = viewKind.defaultLayoutId;
-    }
-  }
-  const matching = surface.layouts.filter((candidate) => candidate.when?.(ctx) ?? true);
-  let layout;
-  if (preferredLayoutId) {
-    layout = matching.find((l) => l.layoutId === preferredLayoutId) ?? surface.layouts.find((l) => l.layoutId === preferredLayoutId) ?? matching[matching.length - 1] ?? surface.layouts[0];
-  } else {
-    layout = matching[matching.length - 1] ?? surface.layouts[0];
-  }
-  if (!layout) {
-    throw new Error(`Surface "${surface.surfaceId}" has no layouts.`);
-  }
-  const layoutFallback = matching.length === 0 && surface.layouts.length > 0;
-  return { layout, layoutFallback: layoutFallback || undefined };
-}
-function resolveDataRecipes(recipes, ctx) {
-  const bindings = {};
-  for (const r of recipes) {
-    if (r.when?.(ctx) ?? true) {
-      const key = r.hydrateInto ?? r.recipeId;
-      bindings[key] = { recipeId: r.recipeId, source: r.source, _stub: true };
-    }
-  }
-  return bindings;
-}
-function allowFromDecision(decision) {
-  if (!decision)
-    return true;
-  return decision.effect === "allow" || decision.effect === "allow-session-only";
-}
-function generateResolutionId() {
-  return `res_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
-}
-var OVERLAY_SCOPE_ORDER = [
-  "system",
-  "workspace",
-  "team",
-  "user",
-  "session"
-];
-function buildAdaptation(ctx) {
-  const profile = resolvePreferenceProfile(ctx);
-  const notes = [...profile.notes];
-  const constrainedEntries = Object.entries(profile.constrained);
-  if (constrainedEntries.length > 0) {
-    notes.push(`constrained: ${constrainedEntries.map(([k, v]) => `${k}=${v}`).join(", ")}`);
-  }
-  return {
-    appliedDimensions: profile.canonical,
-    notes
-  };
-}
-async function resolveBundle(spec, ctx, options) {
-  return traceAsync("surface.resolveBundle", async (span) => {
-    const start = performance.now();
-    try {
-      const plan = await resolveBundleInternal(spec, ctx, options);
-      const durationMs = performance.now() - start;
-      resolutionDurationMs.record(durationMs, {
-        bundleKey: spec.meta.key,
-        surfaceId: plan.surfaceId,
-        fallback: plan.surfaceId === "_error" ? "error" : plan.audit.reasons.some((r) => r.startsWith("fallback=")) ? "yes" : "no"
-      });
-      span.setAttribute("bundle.key", spec.meta.key);
-      span.setAttribute("surface.id", plan.surfaceId);
-      span.setAttribute("resolution.duration_ms", durationMs);
-      logger2.info("bundle.surface.resolved", {
-        bundleKey: spec.meta.key,
-        surfaceId: plan.surfaceId,
-        layoutId: plan.layoutId,
-        resolutionMs: Math.round(durationMs),
-        fallback: plan.audit.reasons.some((r) => r.startsWith("fallback=")),
-        nodeCount: plan.nodes.length
-      });
-      return plan;
-    } catch (err) {
-      const durationMs = performance.now() - start;
-      resolutionDurationMs.record(durationMs, {
-        bundleKey: spec.meta.key,
-        surfaceId: "_error",
-        fallback: "error"
-      });
-      return createErrorPlan(spec, ctx, err);
-    }
-  }, "@contractspec/lib.surface-runtime");
-}
-async function resolveBundleInternal(spec, ctx, options) {
-  const {
-    surface,
-    routeId,
-    fallback: surfaceFallback
-  } = selectSurface(spec, ctx);
-  const { layout, layoutFallback } = selectLayout(surface, ctx, spec);
-  let bindings = resolveDataRecipes(surface.data, ctx);
-  const redactBinding = options?.policy?.redactBinding;
-  if (redactBinding) {
-    const redacted = {};
-    for (const [k, v] of Object.entries(bindings)) {
-      redacted[k] = redactBinding(k, ctx) ?? v;
-    }
-    bindings = redacted;
-  }
-  let nodes = [];
-  const evaluateNode = options?.policy?.evaluateNode;
-  if (evaluateNode) {
-    nodes = nodes.filter((n) => allowFromDecision(evaluateNode(n, ctx)));
-  }
-  const reasons = [
-    `surface=${surface.surfaceId}`,
-    `layout=${layout.layoutId}`,
-    `density=${ctx.preferences.density}`,
-    `narrative=${ctx.preferences.narrative}`
-  ];
-  if (surfaceFallback) {
-    reasons.push(`fallback=${surfaceFallback}`);
-    surfaceFallbackCounter.add(1, {
-      bundleKey: spec.meta.key,
-      type: "surface"
-    });
-  }
-  if (layoutFallback) {
-    reasons.push("fallback=layout");
-    surfaceFallbackCounter.add(1, { bundleKey: spec.meta.key, type: "layout" });
-  }
-  const resolutionId = generateResolutionId();
-  const plan = {
-    bundleKey: spec.meta.key,
-    surfaceId: surface.surfaceId,
-    layoutId: layout.layoutId,
-    layoutRoot: layout.root,
-    nodes,
-    actions: surface.actions ?? [],
-    commands: surface.commands ?? [],
-    bindings,
-    adaptation: buildAdaptation(ctx),
-    overlays: [],
-    ai: {
-      plannerId: spec.ai?.plannerId
-    },
-    audit: {
-      resolutionId,
-      createdAt: new Date().toISOString(),
-      reasons
-    },
-    locale: ctx.locale
-  };
-  options?.audit?.emit({
-    eventId: `evt_${resolutionId}`,
-    at: new Date().toISOString(),
-    actorId: ctx.actorId,
-    source: "system",
-    bundleKey: spec.meta.key,
-    surfaceId: surface.surfaceId,
-    eventType: "surface.resolved",
-    payload: {
-      resolutionId,
-      layoutId: layout.layoutId,
-      reasons,
-      nodeCount: nodes.length
-    }
-  });
-  let finalPlan = plan;
-  if (options?.overlayMerge) {
-    const { overrideStore, scopes = OVERLAY_SCOPE_ORDER } = options.overlayMerge;
-    const targetKey = buildOverrideTargetKey(spec.meta.key, surface.surfaceId, routeId);
-    const appliedOverlays = [];
-    const conflicts = [];
-    const seenTargets = new Map;
-    const conflictKeys = new Set;
-    for (const scope of scopes) {
-      if (scope === "session")
-        continue;
-      const stored = await overrideStore.list(scope, targetKey);
-      for (const ov of stored) {
-        if (ov.patch.length === 0)
-          continue;
-        for (const op of ov.patch) {
-          const opTarget = getOpTarget(op);
-          if (opTarget) {
-            const prev = seenTargets.get(opTarget);
-            if (prev && prev.scope !== scope) {
-              const ck = [opTarget, prev.scope, scope].sort().join(":");
-              if (!conflictKeys.has(ck)) {
-                conflictKeys.add(ck);
-                conflicts.push({
-                  targetKey: opTarget,
-                  scopeA: prev.scope,
-                  scopeB: scope,
-                  overlayIdA: prev.overlayId,
-                  overlayIdB: ov.overrideId
-                });
-              }
-            }
-            seenTargets.set(opTarget, { scope, overlayId: ov.overrideId });
-          }
-        }
-        try {
-          const { plan: next } = applySurfacePatch(finalPlan, ov.patch);
-          finalPlan = next;
-          appliedOverlays.push({
-            overlayId: ov.overrideId,
-            scope,
-            appliedOps: ov.patch.length
-          });
-        } catch (err) {
-          logger2.warn("bundle.overlay.apply.failed", {
-            overlayId: ov.overrideId,
-            scope,
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-      }
-    }
-    finalPlan = {
-      ...finalPlan,
-      overlays: appliedOverlays,
-      overlayConflicts: conflicts.length > 0 ? conflicts : undefined
-    };
-  }
-  return finalPlan;
-}
-function createErrorPlan(spec, ctx, err) {
-  const message = err instanceof Error ? err.message : String(err);
-  const errorLayoutRoot = {
-    type: "stack",
-    direction: "vertical",
-    children: [{ type: "slot", slotId: "primary" }]
-  };
-  return {
-    bundleKey: spec.meta.key,
-    surfaceId: "_error",
-    layoutId: "_error",
-    layoutRoot: errorLayoutRoot,
-    nodes: [],
-    actions: [],
-    commands: [],
-    bindings: {},
-    adaptation: {
-      appliedDimensions: ctx.preferences,
-      notes: [`resolution failed: ${message}`]
-    },
-    overlays: [],
-    ai: {},
-    audit: {
-      resolutionId: generateResolutionId(),
-      createdAt: new Date().toISOString(),
-      reasons: ["fallback=error", `error=${message}`]
-    },
-    locale: ctx.locale
-  };
-}
-
-// src/runtime/build-context.ts
-var DEFAULT_PREFERENCES = {
-  guidance: "hints",
-  density: "standard",
-  dataDepth: "detailed",
-  control: "standard",
-  media: "text",
-  pace: "balanced",
-  narrative: "top-down"
-};
-function buildContext(params) {
-  const {
-    route,
-    params: routeParams = {},
-    query = {},
-    tenantId = "default",
-    workspaceId,
-    actorId,
-    device = "desktop",
-    preferences: partialPrefs = {},
-    capabilities = [],
-    featureFlags = [],
-    mode,
-    locale,
-    timezone,
-    entity,
-    conversation,
-    activeViewId
-  } = params;
-  const preferences = {
-    ...DEFAULT_PREFERENCES,
-    ...partialPrefs
-  };
-  return {
-    tenantId,
-    workspaceId,
-    actorId,
-    route,
-    params: routeParams,
-    query,
-    device,
-    mode,
-    locale,
-    timezone,
-    entity,
-    conversation,
-    activeViewId,
-    preferences,
-    capabilities,
-    featureFlags
-  };
-}
-
-// src/runtime/preference-adapter.ts
-var defaultPreferenceAdapter = {
-  async resolve(ctx) {
-    return resolvePreferenceProfile(ctx);
-  },
-  async savePreferencePatch(_args) {}
-};
-
-// src/runtime/planner-prompt.ts
-var SAFETY_INSTRUCTIONS = `
-## Safety instructions (mandatory)
-- Do NOT emit JSX, HTML, or raw markup.
-- Do NOT invent node kinds; use only the allowed kinds listed above.
-- Do NOT call undeclared tools.
-- Prefer fewer high-confidence patches over many speculative ones.
-- Explain why a patch helps the user.
-`;
-function compilePlannerPrompt(input) {
-  const {
-    bundleMeta,
-    surfaceId,
-    allowedPatchOps,
-    allowedSlots,
-    allowedNodeKinds,
-    actions,
-    preferences,
-    basePrompt,
-    planSummary,
-    entity
-  } = input;
-  const parts = [];
-  parts.push(`# Bundle: ${bundleMeta.title} (${bundleMeta.key}@${bundleMeta.version})`);
-  parts.push(`# Surface: ${surfaceId}`);
-  parts.push("");
-  if (basePrompt) {
-    parts.push("## Base instructions");
-    parts.push(basePrompt);
-    parts.push("");
-  }
-  parts.push("## Allowed patch operations");
-  parts.push(allowedPatchOps.join(", "));
-  parts.push("");
-  parts.push("## Allowed slots");
-  parts.push(allowedSlots.join(", "));
-  parts.push("");
-  parts.push("## Allowed node kinds");
-  parts.push(allowedNodeKinds.join(", "));
-  parts.push("");
-  if (actions.length > 0) {
-    parts.push("## Visible actions");
-    for (const a of actions) {
-      parts.push(`- ${a.actionId}: ${a.title}`);
-    }
-    parts.push("");
-  }
-  parts.push("## Current preference profile");
-  parts.push(`guidance=${preferences.guidance}, density=${preferences.density}, ` + `dataDepth=${preferences.dataDepth}, control=${preferences.control}, ` + `media=${preferences.media}, pace=${preferences.pace}, narrative=${preferences.narrative}`);
-  parts.push("");
-  if (planSummary) {
-    parts.push("## Current plan summary");
-    parts.push(planSummary);
-    parts.push("");
-  }
-  if (entity) {
-    parts.push("## Entity context");
-    parts.push(`${entity.type}: ${entity.id}`);
-    parts.push("");
-  }
-  parts.push(SAFETY_INSTRUCTIONS.trim());
-  return parts.join(`
-`);
-}
-
-// src/runtime/planner-tools.ts
-var PROPOSE_PATCH_TOOL_SCHEMA = {
-  type: "object",
-  properties: {
-    proposalId: { type: "string", description: "Unique proposal identifier" },
-    ops: {
-      type: "array",
-      description: "Surface patch operations to propose",
-      items: {
-        type: "object",
-        required: ["op"],
-        properties: {
-          op: {
-            type: "string",
-            enum: [
-              "insert-node",
-              "replace-node",
-              "remove-node",
-              "move-node",
-              "resize-panel",
-              "set-layout",
-              "reveal-field",
-              "hide-field",
-              "promote-action",
-              "set-focus"
-            ]
-          },
-          slotId: { type: "string" },
-          nodeId: { type: "string" },
-          toSlotId: { type: "string" },
-          index: { type: "number" },
-          node: {
-            type: "object",
-            properties: {
-              nodeId: { type: "string" },
-              kind: { type: "string" },
-              title: { type: "string" },
-              props: { type: "object" },
-              children: { type: "array" }
-            }
-          },
-          persistKey: { type: "string" },
-          sizes: { type: "array", items: { type: "number" } },
-          layoutId: { type: "string" },
-          fieldId: { type: "string" },
-          actionId: { type: "string" },
-          placement: {
-            type: "string",
-            enum: ["header", "inline", "context", "assistant"]
-          },
-          targetId: { type: "string" }
-        }
-      }
-    }
-  },
-  required: ["proposalId", "ops"]
-};
-var proposePatchToolConfig = {
-  name: "propose-patch",
-  description: "Propose surface patches (layout changes, node insertions, etc.) for user approval. " + "Only use allowed ops, slots, and node kinds from the planner context.",
-  schema: PROPOSE_PATCH_TOOL_SCHEMA,
-  automationSafe: false,
-  requiresApproval: true
-};
-function buildSurfacePatchProposal(proposalId, ops) {
-  return {
-    proposalId,
-    source: "assistant",
-    ops,
-    approvalState: "proposed"
-  };
-}
-
-// src/runtime/field-renderer-registry.ts
-var FALLBACK_FIELD_KIND = "text";
-var CORE_FIELD_KINDS = {
-  text: {
-    fieldKind: "text",
-    viewer: "text-viewer",
-    editor: "text-editor",
-    summaryViewer: "text-summary",
-    tableCell: "text-cell",
-    filters: ["contains", "equals", "startsWith", "endsWith"],
-    validators: ["required", "maxLength", "regex"]
-  },
-  number: {
-    fieldKind: "number",
-    viewer: "number-viewer",
-    editor: "number-editor",
-    summaryViewer: "number-summary",
-    tableCell: "number-cell",
-    filters: ["equals", "gt", "gte", "lt", "lte", "between"],
-    validators: ["required", "min", "max", "integer"]
-  },
-  date: {
-    fieldKind: "date",
-    viewer: "date-viewer",
-    editor: "date-editor",
-    summaryViewer: "date-summary",
-    tableCell: "date-cell",
-    filters: ["equals", "before", "after", "between"],
-    validators: ["required", "min", "max"]
-  },
-  select: {
-    fieldKind: "select",
-    viewer: "select-viewer",
-    editor: "select-editor",
-    summaryViewer: "select-summary",
-    tableCell: "select-cell",
-    filters: ["equals", "in"],
-    validators: ["required", "oneOf"]
-  },
-  checkbox: {
-    fieldKind: "checkbox",
-    viewer: "checkbox-viewer",
-    editor: "checkbox-editor",
-    summaryViewer: "checkbox-summary",
-    tableCell: "checkbox-cell",
-    filters: ["equals"],
-    validators: ["required"]
-  }
-};
-var STUB_FIELD_KINDS = {
-  relation: {
-    fieldKind: "relation",
-    viewer: "relation-viewer-stub",
-    summaryViewer: "relation-chip-stub",
-    tableCell: "relation-chip-stub"
-  },
-  rollup: {
-    fieldKind: "rollup",
-    viewer: "rollup-viewer-stub",
-    summaryViewer: "rollup-chip-stub",
-    tableCell: "rollup-cell-stub"
-  },
-  formula: {
-    fieldKind: "formula",
-    viewer: "formula-viewer-stub",
-    summaryViewer: "formula-summary-stub",
-    tableCell: "formula-cell-stub"
-  },
-  people: {
-    fieldKind: "people",
-    viewer: "people-viewer-stub",
-    editor: "people-picker-stub",
-    summaryViewer: "people-chip-stub",
-    tableCell: "people-cell-stub"
-  },
-  options: {
-    fieldKind: "options",
-    viewer: "options-viewer-stub",
-    editor: "options-editor-stub",
-    summaryViewer: "options-chip-stub",
-    tableCell: "options-cell-stub"
-  },
-  instance: {
-    fieldKind: "instance",
-    viewer: "instance-viewer-stub",
-    summaryViewer: "instance-chip-stub",
-    tableCell: "instance-cell-stub"
-  },
-  url: {
-    fieldKind: "url",
-    viewer: "url-viewer",
-    editor: "url-editor",
-    summaryViewer: "url-summary",
-    tableCell: "url-cell",
-    validators: ["required", "regex"]
-  }
-};
-function createFieldRendererRegistry() {
-  const all = { ...CORE_FIELD_KINDS, ...STUB_FIELD_KINDS };
-  const fallback = CORE_FIELD_KINDS[FALLBACK_FIELD_KIND];
-  if (!fallback) {
-    throw new Error(`Fallback field kind "${FALLBACK_FIELD_KIND}" not found`);
-  }
-  return {
-    get(kind) {
-      return all[kind];
-    },
-    has(kind) {
-      return kind in all;
-    },
-    getOrFallback(kind) {
-      return all[kind] ?? fallback;
-    }
-  };
-}
-function createMutableFieldRendererRegistry() {
-  const base = { ...CORE_FIELD_KINDS, ...STUB_FIELD_KINDS };
-  const custom = new Map;
-  const fallback = CORE_FIELD_KINDS[FALLBACK_FIELD_KIND];
-  if (!fallback) {
-    throw new Error(`Fallback field kind "${FALLBACK_FIELD_KIND}" not found`);
-  }
-  return {
-    get(kind) {
-      return custom.get(kind) ?? base[kind];
-    },
-    has(kind) {
-      return custom.has(kind) || kind in base;
-    },
-    getOrFallback(kind) {
-      return custom.get(kind) ?? base[kind] ?? fallback;
-    },
-    registerFieldRenderer(kind, entry) {
-      if (entry.fieldKind !== kind) {
-        throw new Error(`Field renderer entry fieldKind "${entry.fieldKind}" must match kind "${kind}"`);
-      }
-      custom.set(kind, entry);
-    }
-  };
-}
-
-// src/runtime/widget-registry.ts
-function validateTrust(trust) {
-  if (trust === "ephemeral-ai") {
-    throw new Error("Widgets cannot be registered with ephemeral-ai trust. Registration is a code/package concern.");
-  }
-  if (trust !== "core" && trust !== "workspace" && trust !== "signed-plugin") {
-    throw new Error(`Invalid widget trust: ${trust}`);
-  }
-}
-function createWidgetRegistry() {
-  const entries = new Map;
-  return {
-    register(entry) {
-      validateTrust(entry.trust);
-      if (entry.nodeKind !== "custom-widget") {
-        throw new Error(`Widget "${entry.widgetKey}" must have nodeKind "custom-widget"`);
-      }
-      entries.set(entry.widgetKey, entry);
-    },
-    get(widgetKey) {
-      return entries.get(widgetKey);
-    },
-    has(widgetKey) {
-      return entries.has(widgetKey);
-    },
-    list() {
-      return Array.from(entries.values());
-    },
-    listByTrust(trust) {
-      return Array.from(entries.values()).filter((e) => e.trust === trust);
-    }
-  };
-}
-
-// src/runtime/extension-registry.ts
-function createActionRegistry() {
-  const entries = new Map;
-  return {
-    register(entry) {
-      entries.set(entry.actionId, entry);
-    },
-    get(actionId) {
-      return entries.get(actionId);
-    },
-    has(actionId) {
-      return entries.has(actionId);
-    },
-    list() {
-      return Array.from(entries.values());
-    }
-  };
-}
-function createCommandRegistry() {
-  const entries = new Map;
-  return {
-    register(entry) {
-      entries.set(entry.commandId, entry);
-    },
-    get(commandId) {
-      return entries.get(commandId);
-    },
-    has(commandId) {
-      return entries.has(commandId);
-    },
-    list() {
-      return Array.from(entries.values());
-    }
-  };
-}
-function createBundleExtensionRegistry(options) {
-  const actionRegistry = options.actionRegistry ?? createActionRegistry();
-  const commandRegistry = options.commandRegistry ?? createCommandRegistry();
-  return {
-    registerWidget(entry) {
-      options.widgetRegistry.register(entry);
-    },
-    registerFieldRenderer(kind, entry) {
-      options.fieldRendererRegistry.registerFieldRenderer(kind, entry);
-    },
-    registerAction(entry) {
-      actionRegistry.register(entry);
-    },
-    registerCommand(entry) {
-      commandRegistry.register(entry);
-    }
-  };
-}
-
-// src/runtime/overlay-alignment.ts
-import { applyOverlayModifications } from "@contractspec/lib.overlay-engine/merger";
-function toOverlayScopeContext(ctx) {
-  return {
-    tenantId: ctx.tenantId,
-    userId: ctx.actorId,
-    device: ctx.device,
-    tags: ctx.featureFlags
-  };
-}
-function toOverlayTargetRef(_ctx, target) {
-  return {
-    presentation: target.surfaceId ?? target.routeId,
-    bundleKey: target.bundleKey,
-    surfaceId: target.surfaceId,
-    routeId: target.routeId,
-    entityType: target.entityType
-  };
-}
-function toOverlayAppliesTo(ctx, target, scope) {
-  const scopeCtx = toOverlayScopeContext(ctx);
-  return {
-    ...scopeCtx,
-    ...target,
-    ...scope === "user" && ctx.actorId ? { userId: ctx.actorId } : {},
-    ...scope === "workspace" && ctx.workspaceId ? { tags: [...scopeCtx.tags ?? [], `workspace:${ctx.workspaceId}`] } : {}
-  };
-}
-function toOverlayRenderableField(field) {
-  return {
-    key: field.fieldId,
-    label: field.title,
-    visible: field.visible,
-    required: field.required,
-    order: 0
-  };
-}
-function fromOverlayRenderableField(overlay) {
-  return {
-    fieldId: overlay.key,
-    title: overlay.label ?? overlay.key,
-    visible: overlay.visible ?? true,
-    required: overlay.required ?? false
-  };
-}
-function toOverlayRenderable(fields) {
-  return {
-    fields: fields.map(toOverlayRenderableField)
-  };
-}
-function mergeOverlayResultIntoFields(fields, merged) {
-  const fieldMap = new Map(fields.map((f) => [f.fieldId, { ...f }]));
-  const result = [];
-  for (const overlay of merged.fields) {
-    const existing = fieldMap.get(overlay.key);
-    if (existing) {
-      result.push({
-        ...existing,
-        title: overlay.label ?? existing.title,
-        visible: overlay.visible ?? existing.visible,
-        required: overlay.required ?? existing.required
-      });
-    }
-  }
-  return result;
-}
-function applyEntityFieldOverlays(fields, overlays, options) {
-  if (!overlays.length)
-    return fields;
-  const target = toOverlayRenderable(fields);
-  const merged = applyOverlayModifications(target, overlays, options);
-  return mergeOverlayResultIntoFields(fields, merged);
-}
-
-// src/runtime/overlay-signer.ts
-import {
-  signOverlay,
-  verifyOverlaySignature
-} from "@contractspec/lib.overlay-engine/signer";
-function signWorkspaceOverlay(spec, privateKey, options) {
-  return signOverlay(spec, privateKey, options);
-}
-function verifyWorkspaceOverlay(overlay) {
-  return verifyOverlaySignature(overlay);
-}
-
-// src/runtime/audit-events.ts
-function generateEventId() {
-  return `evt_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
-}
-function emitPatchProposed(audit, args) {
-  audit.emit({
-    eventId: generateEventId(),
-    at: new Date().toISOString(),
-    actorId: args.actorId,
-    source: args.proposal.source === "assistant" ? "assistant" : "user",
-    bundleKey: args.bundleKey,
-    surfaceId: args.surfaceId,
-    eventType: "patch.proposed",
-    payload: {
-      proposalId: args.proposal.proposalId,
-      source: args.proposal.source,
-      opsCount: args.proposal.ops.length
-    }
-  });
-}
-function emitPatchApproved(audit, args) {
-  audit.emit({
-    eventId: generateEventId(),
-    at: new Date().toISOString(),
-    actorId: args.actorId,
-    source: "user",
-    bundleKey: args.bundleKey,
-    surfaceId: args.surfaceId,
-    eventType: "patch.approved",
-    payload: {
-      proposalId: args.proposalId,
-      source: args.source,
-      opsCount: args.opsCount,
-      reason: args.reason
-    }
-  });
-}
-function emitPatchRejected(audit, args) {
-  audit.emit({
-    eventId: generateEventId(),
-    at: new Date().toISOString(),
-    actorId: args.actorId,
-    source: "user",
-    bundleKey: args.bundleKey,
-    surfaceId: args.surfaceId,
-    eventType: "patch.rejected",
-    payload: {
-      proposalId: args.proposalId,
-      source: args.source,
-      opsCount: args.opsCount,
-      reason: args.reason
-    }
-  });
-}
-function emitOverlaySaved(audit, args) {
-  audit.emit({
-    eventId: generateEventId(),
-    at: new Date().toISOString(),
-    actorId: args.actorId,
-    source: "user",
-    bundleKey: args.bundleKey,
-    eventType: "overlay.saved",
-    payload: {
-      overlayId: args.overlayId,
-      scope: args.scope,
-      opsCount: args.opsCount
-    }
-  });
-}
-function emitOverlayApplied(audit, args) {
-  audit.emit({
-    eventId: generateEventId(),
-    at: new Date().toISOString(),
-    source: "system",
-    bundleKey: args.bundleKey,
-    surfaceId: args.surfaceId,
-    eventType: "overlay.applied",
-    payload: {
-      overlayId: args.overlayId,
-      opsCount: args.opsCount
-    }
-  });
-}
-function emitOverlayFailed(audit, args) {
-  audit.emit({
-    eventId: generateEventId(),
-    at: new Date().toISOString(),
-    source: "system",
-    bundleKey: args.bundleKey,
-    surfaceId: args.surfaceId,
-    eventType: "overlay.failed",
-    payload: {
-      overlayId: args.overlayId,
-      error: args.error
-    }
-  });
-}
-function emitPolicyDenied(audit, args) {
-  audit.emit({
-    eventId: generateEventId(),
-    at: new Date().toISOString(),
-    actorId: args.actorId,
-    source: "policy",
-    bundleKey: args.bundleKey,
-    surfaceId: args.surfaceId,
-    eventType: "policy.denied",
-    payload: {
-      targetId: args.targetId,
-      reason: args.reason
-    }
-  });
-}
-function emitPolicyRedacted(audit, args) {
-  audit.emit({
-    eventId: generateEventId(),
-    at: new Date().toISOString(),
-    actorId: args.actorId,
-    source: "policy",
-    bundleKey: args.bundleKey,
-    surfaceId: args.surfaceId,
-    eventType: "policy.redacted",
-    payload: {
-      targetId: args.targetId,
-      redactions: args.redactions
-    }
-  });
-}
-
-// src/runtime/rollback.ts
-function rollbackSurfacePatches(plan, approvalStack, count = 1) {
-  if (count <= 0 || approvalStack.length === 0) {
-    return { plan, revertedCount: 0, remainingStack: approvalStack };
-  }
-  const toRevert = approvalStack.slice(-count);
-  const remaining = approvalStack.slice(0, -count);
-  const currentPlan = plan;
-  const allInverseOps = [];
-  for (const meta of toRevert) {
-    if (meta.inverseOps.length > 0) {
-      allInverseOps.push(...meta.inverseOps);
-    }
-  }
-  if (allInverseOps.length === 0) {
-    return { plan, revertedCount: 0, remainingStack: approvalStack };
-  }
-  const result = applySurfacePatch(currentPlan, allInverseOps);
-  return {
-    plan: result.plan,
-    revertedCount: toRevert.length,
-    remainingStack: remaining
-  };
-}
-
-// src/runtime/policy-eval.ts
-function evaluatePatchProposalPolicy(ops, ctx, policy) {
-  const evaluate = policy?.evaluatePatchProposal;
-  if (!evaluate)
-    return "allow";
-  return evaluate(ops, ctx);
-}
-function evaluateAndEmitPatchPolicy(ops, ctx, args) {
-  const effect = evaluatePatchProposalPolicy(ops, ctx, args.policy);
-  if (effect === "deny") {
-    if (args.audit) {
-      emitPolicyDenied(args.audit, {
-        bundleKey: args.bundleKey,
-        surfaceId: args.surfaceId,
-        targetId: args.targetId ?? "patch-proposal",
-        reason: "Policy denied patch proposal",
-        actorId: ctx.actorId
-      });
-    }
-    return false;
-  }
-  return true;
-}
+export { buildContext } from "./build-context";
+export { resolvePreferenceProfile } from "./resolve-preferences";
+export { defaultPreferenceAdapter } from "./preference-adapter";
+export {
+  resolveBundle
+} from "./resolve-bundle";
+export {
+  applySurfacePatch
+} from "./apply-surface-patch";
+export {
+  compilePlannerPrompt
+} from "./planner-prompt";
+export {
+  proposePatchToolConfig,
+  PROPOSE_PATCH_TOOL_SCHEMA,
+  buildSurfacePatchProposal
+} from "./planner-tools";
+export {
+  createFieldRendererRegistry,
+  createMutableFieldRendererRegistry,
+  FALLBACK_FIELD_KIND
+} from "./field-renderer-registry";
+export {
+  createWidgetRegistry
+} from "./widget-registry";
+export {
+  createActionRegistry,
+  createCommandRegistry,
+  createBundleExtensionRegistry
+} from "./extension-registry";
+export {
+  createInMemoryOverrideStore,
+  createOverrideStoreWithApprovalGate,
+  buildOverrideTargetKey
+} from "./override-store";
 export {
-  verifyWorkspaceOverlay,
-  toOverlayTargetRef,
   toOverlayScopeContext,
+  toOverlayTargetRef,
   toOverlayRenderableField,
+  fromOverlayRenderableField,
   toOverlayRenderable,
-  signWorkspaceOverlay,
-  rollbackSurfacePatches,
-  resolvePreferenceProfile,
-  resolveBundle,
-  proposePatchToolConfig,
   mergeOverlayResultIntoFields,
-  fromOverlayRenderableField,
-  evaluatePatchProposalPolicy,
-  evaluateAndEmitPatchPolicy,
-  emitPolicyRedacted,
-  emitPolicyDenied,
-  emitPatchRejected,
+  applyEntityFieldOverlays
+} from "./overlay-alignment";
+export {
+  signWorkspaceOverlay,
+  verifyWorkspaceOverlay
+} from "./overlay-signer";
+export {
   emitPatchProposed,
   emitPatchApproved,
+  emitPatchRejected,
   emitOverlaySaved,
-  emitOverlayFailed,
   emitOverlayApplied,
-  defaultPreferenceAdapter,
-  createWidgetRegistry,
-  createOverrideStoreWithApprovalGate,
-  createMutableFieldRendererRegistry,
-  createInMemoryOverrideStore,
-  createFieldRendererRegistry,
-  createCommandRegistry,
-  createBundleExtensionRegistry,
-  createActionRegistry,
-  compilePlannerPrompt,
-  buildSurfacePatchProposal,
-  buildOverrideTargetKey,
-  buildContext,
-  applySurfacePatch,
-  applyEntityFieldOverlays,
-  PROPOSE_PATCH_TOOL_SCHEMA,
-  FALLBACK_FIELD_KIND
-};
+  emitOverlayFailed,
+  emitPolicyDenied,
+  emitPolicyRedacted
+} from "./audit-events";
+export { rollbackSurfacePatches } from "./rollback";
+export {
+  evaluatePatchProposalPolicy,
+  evaluateAndEmitPatchPolicy
+} from "./policy-eval";