@contractspec/lib.surface-runtime 0.2.0

package/dist/node/index.js

@@ -0,0 +1,2466 @@
+// src/adapters/ai-sdk-stub.ts
+var aiSdkAdapterStub = {
+  startThread(_args) {
+    return null;
+  },
+  async requestPatches(_args) {
+    return [];
+  }
+};
+
+// src/adapters/blocknote-stub.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+var blocknoteAdapterStub = {
+  supportsNode(_kind) {
+    return false;
+  },
+  createSchema(_registry) {
+    return {};
+  },
+  renderNode(node, _ctx) {
+    return /* @__PURE__ */ jsxDEV("div", {
+      "data-blocknote-stub": true,
+      "data-node-id": node.nodeId,
+      children: node.title ?? node.kind
+    }, undefined, false, undefined, this);
+  },
+  async serialize(node) {
+    return { nodeId: node.nodeId, kind: node.kind };
+  },
+  async deserialize(input) {
+    const o = input;
+    return {
+      nodeId: o?.nodeId ?? "stub",
+      kind: o?.kind ?? "custom-widget"
+    };
+  }
+};
+
+// src/adapters/dnd-kit-adapter.tsx
+import {
+  DndContext,
+  PointerSensor,
+  useSensor,
+  useSensors
+} from "@dnd-kit/core";
+import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
+"use client";
+var noop = () => {
+  return;
+};
+var _onPatch = noop;
+function handleDragEnd(event) {
+  const { active, over } = event;
+  if (!over)
+    return;
+  const fromId = active.id;
+  const toSlotId = over.id;
+  if (fromId && toSlotId) {
+    _onPatch([{ op: "move-node", nodeId: fromId, toSlotId }]);
+  }
+}
+function DndWrapperComponent({ children, onPatch }) {
+  _onPatch = onPatch;
+  const sensors = useSensors(useSensor(PointerSensor, {
+    activationConstraint: { distance: 8 }
+  }));
+  return /* @__PURE__ */ jsxDEV2(DndContext, {
+    sensors,
+    onDragEnd: handleDragEnd,
+    children
+  }, undefined, false, undefined, this);
+}
+var dndKitAdapter = {
+  enableSurfaceEditing(args) {
+    _onPatch = args.onPatch;
+  },
+  DndWrapper: DndWrapperComponent
+};
+
+// src/adapters/dnd-kit-stub.ts
+var dndKitAdapterStub = {
+  enableSurfaceEditing(_args) {}
+};
+
+// src/adapters/floating-ui-stub.tsx
+import { jsxDEV as jsxDEV3 } from "react/jsx-dev-runtime";
+var floatingUiAdapterStub = {
+  renderAnchoredMenu({ anchorId, items }) {
+    return /* @__PURE__ */ jsxDEV3("div", {
+      "data-floating-stub": true,
+      "data-anchor-id": anchorId,
+      role: "menu",
+      children: items.map((a) => /* @__PURE__ */ jsxDEV3("div", {
+        role: "menuitem",
+        children: a.title
+      }, a.actionId, false, undefined, this))
+    }, undefined, false, undefined, this);
+  }
+};
+
+// src/adapters/motion-stub.ts
+var PACE_TOKENS = {
+  deliberate: {
+    durationMs: 300,
+    enableEntrance: true,
+    layout: true
+  },
+  balanced: {
+    durationMs: 150,
+    enableEntrance: true,
+    layout: true
+  },
+  rapid: {
+    durationMs: 50,
+    enableEntrance: false,
+    layout: false
+  }
+};
+var motionAdapterStub = {
+  getTokens(pace) {
+    return PACE_TOKENS[pace] ?? PACE_TOKENS.balanced;
+  }
+};
+
+// src/adapters/resizable-panels-stub.tsx
+import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
+var LAYOUT_STORAGE_KEY = "surface-runtime:panel-layout:";
+var resizablePanelsAdapterStub = {
+  renderPanelGroup(region, ctx, renderChild) {
+    const direction = region.direction === "horizontal" ? "row" : "column";
+    return /* @__PURE__ */ jsxDEV4("div", {
+      "data-panel-group": true,
+      "data-persist-key": region.persistKey,
+      style: {
+        display: "flex",
+        flexDirection: direction,
+        flex: 1,
+        minHeight: 0
+      },
+      children: region.children.map((child, i) => /* @__PURE__ */ jsxDEV4("div", {
+        style: { flex: 1, minWidth: 0, minHeight: 0 },
+        children: renderChild(child, ctx)
+      }, i, false, undefined, this))
+    }, undefined, false, undefined, this);
+  },
+  async restoreLayout(persistKey) {
+    if (typeof localStorage === "undefined")
+      return null;
+    try {
+      const raw = localStorage.getItem(LAYOUT_STORAGE_KEY + persistKey);
+      if (!raw)
+        return null;
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : null;
+    } catch {
+      return null;
+    }
+  },
+  async saveLayout(persistKey, sizes) {
+    if (typeof localStorage === "undefined")
+      return;
+    try {
+      localStorage.setItem(LAYOUT_STORAGE_KEY + persistKey, JSON.stringify(sizes));
+    } catch {}
+  }
+};
+// 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/spec/validate-bundle.ts
+var KNOWN_NODE_KIND_RENDERERS = new Set([
+  "entity-section",
+  "entity-field",
+  "action-bar",
+  "table",
+  "timeline",
+  "rich-doc",
+  "chat-thread",
+  "assistant-panel",
+  "entity-card",
+  "entity-header",
+  "entity-summary",
+  "entity-activity",
+  "entity-relations",
+  "relation-graph",
+  "custom-widget"
+]);
+function collectSlotIdsFromRegion(node) {
+  const ids = [];
+  if (node.type === "slot") {
+    ids.push(node.slotId);
+  }
+  if (node.type === "panel-group" || node.type === "stack") {
+    for (const child of node.children) {
+      ids.push(...collectSlotIdsFromRegion(child));
+    }
+  }
+  if (node.type === "tabs") {
+    for (const tab of node.tabs) {
+      ids.push(...collectSlotIdsFromRegion(tab.child));
+    }
+  }
+  if (node.type === "floating") {
+    ids.push(node.anchorSlotId);
+    ids.push(...collectSlotIdsFromRegion(node.child));
+  }
+  return ids;
+}
+function validateLayoutSlots(surface) {
+  const declaredSlotIds = new Set(surface.slots.map((s) => s.slotId));
+  for (const layout of surface.layouts) {
+    const layoutSlotIds = collectSlotIdsFromRegion(layout.root);
+    for (const slotId of layoutSlotIds) {
+      if (!declaredSlotIds.has(slotId)) {
+        throw new Error(`Surface "${surface.surfaceId}" layout "${layout.layoutId}" references undeclared slot "${slotId}". Declared slots: ${[...declaredSlotIds].join(", ")}`);
+      }
+    }
+  }
+}
+function validateBundleNodeKinds(surface) {
+  const warnings = [];
+  for (const slot of surface.slots) {
+    for (const kind of slot.accepts) {
+      if (!KNOWN_NODE_KIND_RENDERERS.has(kind)) {
+        warnings.push(`Surface "${surface.surfaceId}" slot "${slot.slotId}" accepts "${kind}" which has no dedicated renderer (generic fallback used)`);
+      }
+    }
+  }
+  return { warnings };
+}
+
+// src/spec/define-module-bundle.ts
+function defineModuleBundle(spec) {
+  if (!spec.meta?.key || !spec.meta?.version || !spec.meta?.title) {
+    throw new Error("ModuleBundleSpec must have meta.key, meta.version, and meta.title");
+  }
+  if (!spec.routes?.length) {
+    throw new Error("ModuleBundleSpec must have at least one route");
+  }
+  if (!spec.surfaces || Object.keys(spec.surfaces).length === 0) {
+    throw new Error("ModuleBundleSpec must have at least one surface");
+  }
+  if (spec.entities) {
+    if (!spec.entities.entityTypes || typeof spec.entities.entityTypes !== "object") {
+      throw new Error("ModuleBundleSpec.entities must have entityTypes object when present");
+    }
+    if (!spec.entities.fieldKinds || typeof spec.entities.fieldKinds !== "object") {
+      throw new Error("ModuleBundleSpec.entities must have fieldKinds object when present");
+    }
+  }
+  const REQUIRED_DIMENSIONS = [
+    "guidance",
+    "density",
+    "dataDepth",
+    "control",
+    "media",
+    "pace",
+    "narrative"
+  ];
+  const MIN_DESCRIPTION_LENGTH = 10;
+  for (const surface of Object.values(spec.surfaces)) {
+    if (!surface.verification?.dimensions) {
+      throw new Error(`Surface "${surface.surfaceId}" must have verification.dimensions for all 7 preference dimensions`);
+    }
+    const dims = surface.verification.dimensions;
+    for (const d of REQUIRED_DIMENSIONS) {
+      const val = dims[d];
+      if (!val || typeof val !== "string") {
+        throw new Error(`Surface "${surface.surfaceId}" verification.dimensions.${d} must be a non-empty string`);
+      }
+      const trimmed = val.trim();
+      if (trimmed.length < MIN_DESCRIPTION_LENGTH) {
+        throw new Error(`Surface "${surface.surfaceId}" verification.dimensions.${d} must be at least ${MIN_DESCRIPTION_LENGTH} characters (got ${trimmed.length})`);
+      }
+    }
+    validateLayoutSlots(surface);
+  }
+  return spec;
+}
+// src/i18n/catalogs/en.ts
+import { defineTranslation } from "@contractspec/lib.contracts-spec/translations";
+var enMessages = defineTranslation({
+  meta: {
+    key: "surface-runtime.messages",
+    version: "1.0.0",
+    domain: "surface-runtime",
+    description: "User-facing strings for surface-runtime UI components",
+    owners: ["platform"],
+    stability: "experimental"
+  },
+  locale: "en",
+  fallback: "en",
+  messages: {
+    "overlay.conflicts.title": {
+      value: "Overlay conflicts",
+      description: "Title for overlay conflict resolution banner"
+    },
+    "overlay.conflicts.keepScope": {
+      value: "Keep {scope}",
+      description: "Button to keep overlay from scope A or B"
+    },
+    "patch.accept": {
+      value: "Accept",
+      description: "Accept patch proposal button"
+    },
+    "patch.reject": {
+      value: "Reject",
+      description: "Reject patch proposal button"
+    },
+    "patch.addWidget": {
+      value: "Add {title} to {slot}",
+      description: "Insert node proposal summary"
+    },
+    "patch.removeItem": {
+      value: "Remove item",
+      description: "Remove node proposal summary"
+    },
+    "patch.switchLayout": {
+      value: "Switch to {layoutId} layout",
+      description: "Set layout proposal summary"
+    },
+    "patch.showField": {
+      value: "Show field {fieldId}",
+      description: "Reveal field proposal summary"
+    },
+    "patch.hideField": {
+      value: "Hide field {fieldId}",
+      description: "Hide field proposal summary"
+    },
+    "patch.moveTo": {
+      value: "Move to {slot}",
+      description: "Move node proposal summary"
+    },
+    "patch.replaceItem": {
+      value: "Replace item",
+      description: "Replace node proposal summary"
+    },
+    "patch.promote": {
+      value: "Promote {actionId}",
+      description: "Promote action proposal summary"
+    },
+    "patch.changes": {
+      value: "{count} changes",
+      description: "Multiple patch ops summary"
+    }
+  }
+});
+
+// src/i18n/catalogs/es.ts
+import { defineTranslation as defineTranslation2 } from "@contractspec/lib.contracts-spec/translations";
+var esMessages = defineTranslation2({
+  meta: {
+    key: "surface-runtime.messages",
+    version: "1.0.0",
+    domain: "surface-runtime",
+    description: "User-facing strings for surface-runtime UI components",
+    owners: ["platform"],
+    stability: "experimental"
+  },
+  locale: "es",
+  fallback: "en",
+  messages: {
+    "overlay.conflicts.title": { value: "Conflictos de superposición" },
+    "overlay.conflicts.keepScope": { value: "Mantener {scope}" },
+    "patch.accept": { value: "Aceptar" },
+    "patch.reject": { value: "Rechazar" },
+    "patch.addWidget": { value: "Añadir {title} a {slot}" },
+    "patch.removeItem": { value: "Eliminar elemento" },
+    "patch.switchLayout": { value: "Cambiar a disposición {layoutId}" },
+    "patch.showField": { value: "Mostrar campo {fieldId}" },
+    "patch.hideField": { value: "Ocultar campo {fieldId}" },
+    "patch.moveTo": { value: "Mover a {slot}" },
+    "patch.replaceItem": { value: "Reemplazar elemento" },
+    "patch.promote": { value: "Promover {actionId}" },
+    "patch.changes": { value: "{count} cambios" }
+  }
+});
+
+// src/i18n/catalogs/fr.ts
+import { defineTranslation as defineTranslation3 } from "@contractspec/lib.contracts-spec/translations";
+var frMessages = defineTranslation3({
+  meta: {
+    key: "surface-runtime.messages",
+    version: "1.0.0",
+    domain: "surface-runtime",
+    description: "User-facing strings for surface-runtime UI components",
+    owners: ["platform"],
+    stability: "experimental"
+  },
+  locale: "fr",
+  fallback: "en",
+  messages: {
+    "overlay.conflicts.title": { value: "Conflits de superposition" },
+    "overlay.conflicts.keepScope": { value: "Conserver {scope}" },
+    "patch.accept": { value: "Accepter" },
+    "patch.reject": { value: "Rejeter" },
+    "patch.addWidget": { value: "Ajouter {title} à {slot}" },
+    "patch.removeItem": { value: "Supprimer l'élément" },
+    "patch.switchLayout": { value: "Passer à la disposition {layoutId}" },
+    "patch.showField": { value: "Afficher le champ {fieldId}" },
+    "patch.hideField": { value: "Masquer le champ {fieldId}" },
+    "patch.moveTo": { value: "Déplacer vers {slot}" },
+    "patch.replaceItem": { value: "Remplacer l'élément" },
+    "patch.promote": { value: "Promouvoir {actionId}" },
+    "patch.changes": { value: "{count} modifications" }
+  }
+});
+
+// src/i18n/messages.ts
+import {
+  createI18nFactory
+} from "@contractspec/lib.contracts-spec/translations";
+var factory = createI18nFactory({
+  specKey: "surface-runtime.messages",
+  catalogs: [enMessages, frMessages, esMessages]
+});
+var createSurfaceI18n = factory.create;
+var getDefaultSurfaceI18n = factory.getDefault;
+
+// src/i18n/keys.ts
+var SURFACE_KEYS = {
+  "overlay.conflicts.title": "overlay.conflicts.title",
+  "overlay.conflicts.keepScope": "overlay.conflicts.keepScope",
+  "patch.accept": "patch.accept",
+  "patch.reject": "patch.reject",
+  "patch.addWidget": "patch.addWidget",
+  "patch.removeItem": "patch.removeItem",
+  "patch.switchLayout": "patch.switchLayout",
+  "patch.showField": "patch.showField",
+  "patch.hideField": "patch.hideField",
+  "patch.moveTo": "patch.moveTo",
+  "patch.replaceItem": "patch.replaceItem",
+  "patch.promote": "patch.promote",
+  "patch.changes": "patch.changes"
+};
+
+// src/i18n/index.ts
+import {
+  resolveLocale,
+  isSupportedLocale,
+  DEFAULT_LOCALE,
+  SUPPORTED_LOCALES
+} from "@contractspec/lib.contracts-spec/translations";
+
+// 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;
+}
+// src/react/BundleProvider.tsx
+import { createContext, useContext } from "react";
+import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
+"use client";
+var BundlePlanContext = createContext(null);
+var PreferencesContext = createContext(null);
+var EditingContext = createContext(false);
+function BundleProvider({
+  plan,
+  children,
+  isEditing = false
+}) {
+  const preferences = plan.adaptation.appliedDimensions;
+  return /* @__PURE__ */ jsxDEV5(BundlePlanContext.Provider, {
+    value: plan,
+    children: /* @__PURE__ */ jsxDEV5(PreferencesContext.Provider, {
+      value: preferences,
+      children: /* @__PURE__ */ jsxDEV5(EditingContext.Provider, {
+        value: isEditing,
+        children
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function useIsEditing() {
+  return useContext(EditingContext);
+}
+function useBundlePlan() {
+  const value = useContext(BundlePlanContext);
+  if (!value) {
+    throw new Error("useBundlePlan must be used inside BundleProvider.");
+  }
+  return value;
+}
+function useBundlePreferences() {
+  const value = useContext(PreferencesContext);
+  if (!value) {
+    throw new Error("useBundlePreferences must be used inside BundleProvider.");
+  }
+  return value;
+}
+
+// src/react/RegionRenderer.tsx
+import { jsxDEV as jsxDEV6 } from "react/jsx-dev-runtime";
+function RegionRenderer({
+  region,
+  ctx,
+  renderSlot
+}) {
+  const renderChild = (child, childCtx) => /* @__PURE__ */ jsxDEV6(RegionRenderer, {
+    region: child,
+    ctx: childCtx,
+    renderSlot
+  }, undefined, false, undefined, this);
+  switch (region.type) {
+    case "panel-group":
+      return resizablePanelsAdapterStub.renderPanelGroup(region, ctx, renderChild);
+    case "stack": {
+      const direction = region.direction === "horizontal" ? "row" : "column";
+      const gapMap = {
+        none: 0,
+        xs: 4,
+        sm: 8,
+        md: 16,
+        lg: 24
+      };
+      const gap = gapMap[region.gap ?? "md"];
+      return /* @__PURE__ */ jsxDEV6("div", {
+        "data-region": "stack",
+        style: {
+          display: "flex",
+          flexDirection: direction,
+          gap,
+          flex: 1,
+          minHeight: 0
+        },
+        children: region.children.map((child, i) => /* @__PURE__ */ jsxDEV6("div", {
+          style: { flex: 1, minWidth: 0, minHeight: 0 },
+          children: /* @__PURE__ */ jsxDEV6(RegionRenderer, {
+            region: child,
+            ctx,
+            renderSlot
+          }, undefined, false, undefined, this)
+        }, i, false, undefined, this))
+      }, undefined, false, undefined, this);
+    }
+    case "tabs":
+      return /* @__PURE__ */ jsxDEV6("div", {
+        "data-region": "tabs",
+        children: [
+          /* @__PURE__ */ jsxDEV6("div", {
+            role: "tablist",
+            children: region.tabs.map((t) => /* @__PURE__ */ jsxDEV6("button", {
+              type: "button",
+              role: "tab",
+              children: t.title
+            }, t.key, false, undefined, this))
+          }, undefined, false, undefined, this),
+          region.tabs[0] && /* @__PURE__ */ jsxDEV6(RegionRenderer, {
+            region: region.tabs[0].child,
+            ctx,
+            renderSlot
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    case "slot":
+      return /* @__PURE__ */ jsxDEV6("div", {
+        "data-slot": region.slotId,
+        children: renderSlot(region.slotId, ctx)
+      }, undefined, false, undefined, this);
+    case "floating":
+      return /* @__PURE__ */ jsxDEV6("div", {
+        "data-floating": true,
+        "data-anchor": region.anchorSlotId,
+        children: /* @__PURE__ */ jsxDEV6(RegionRenderer, {
+          region: region.child,
+          ctx,
+          renderSlot
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this);
+    default:
+      return null;
+  }
+}
+
+// src/react/SlotRenderer.tsx
+import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
+function SlotRenderer({ slotId, ctx, nodes }) {
+  if (nodes.length === 0) {
+    return /* @__PURE__ */ jsxDEV7("div", {
+      "data-slot-placeholder": true,
+      "data-slot-id": slotId
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsxDEV7("div", {
+    "data-slot": slotId,
+    children: nodes.map((node) => /* @__PURE__ */ jsxDEV7(SlotNodeRenderer, {
+      node,
+      ctx,
+      slotId
+    }, node.nodeId, false, undefined, this))
+  }, undefined, false, undefined, this);
+}
+function SlotNodeRenderer({
+  node,
+  ctx,
+  slotId
+}) {
+  if (blocknoteAdapterStub.supportsNode(node.kind)) {
+    return blocknoteAdapterStub.renderNode(node, ctx);
+  }
+  if (node.kind === "entity-section") {
+    return /* @__PURE__ */ jsxDEV7("section", {
+      "data-node-id": node.nodeId,
+      "data-kind": "entity-section",
+      children: [
+        /* @__PURE__ */ jsxDEV7("header", {
+          "data-entity-section-header": true,
+          children: node.title ?? "Section"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV7("div", {
+          "data-entity-section-content": true,
+          children: node.children?.map((child) => child ? /* @__PURE__ */ jsxDEV7(SlotNodeRenderer, {
+            node: child,
+            ctx,
+            slotId
+          }, child.nodeId, false, undefined, this) : null)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  if (node.kind === "entity-field") {
+    const fieldId = node.sourceBinding?.fieldId;
+    return /* @__PURE__ */ jsxDEV7("div", {
+      "data-node-id": node.nodeId,
+      "data-kind": "entity-field",
+      "data-field-id": fieldId,
+      children: [
+        /* @__PURE__ */ jsxDEV7("span", {
+          "data-entity-field-label": true,
+          children: node.title ?? fieldId ?? "Field"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV7("span", {
+          "data-entity-field-value": true
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  missingRendererCounter.add(1, {
+    nodeKind: node.kind,
+    slotId
+  });
+  return /* @__PURE__ */ jsxDEV7("div", {
+    "data-node-id": node.nodeId,
+    "data-kind": node.kind,
+    "data-renderer-missing": true,
+    children: node.title ?? node.kind
+  }, undefined, false, undefined, this);
+}
+
+// src/react/PatchProposalCard.tsx
+import { useMemo } from "react";
+import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
+"use client";
+function PatchProposalCard({
+  proposal,
+  onAccept,
+  onReject,
+  locale
+}) {
+  const i18n = useMemo(() => createSurfaceI18n(locale), [locale]);
+  const firstOp = proposal.ops[0];
+  const summary = proposal.ops.length === 1 && firstOp ? describeOp(firstOp, i18n) : i18n.t("patch.changes", { count: proposal.ops.length });
+  return /* @__PURE__ */ jsxDEV8("div", {
+    "data-proposal-id": proposal.proposalId,
+    style: {
+      padding: "12px",
+      border: "1px solid var(--border, #e5e7eb)",
+      borderRadius: "8px",
+      marginBottom: "8px",
+      backgroundColor: "var(--muted, #f9fafb)"
+    },
+    children: [
+      /* @__PURE__ */ jsxDEV8("div", {
+        style: { marginBottom: "8px", fontSize: "14px" },
+        children: summary
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV8("div", {
+        style: { display: "flex", gap: "8px" },
+        children: [
+          /* @__PURE__ */ jsxDEV8("button", {
+            type: "button",
+            onClick: () => onAccept(proposal.proposalId),
+            style: {
+              padding: "4px 12px",
+              fontSize: "13px",
+              borderRadius: "4px",
+              border: "none",
+              backgroundColor: "var(--primary, #3b82f6)",
+              color: "white",
+              cursor: "pointer"
+            },
+            children: i18n.t("patch.accept")
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV8("button", {
+            type: "button",
+            onClick: () => onReject(proposal.proposalId),
+            style: {
+              padding: "4px 12px",
+              fontSize: "13px",
+              borderRadius: "4px",
+              border: "1px solid var(--border, #e5e7eb)",
+              backgroundColor: "transparent",
+              cursor: "pointer"
+            },
+            children: i18n.t("patch.reject")
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function describeOp(op, i18n) {
+  switch (op.op) {
+    case "insert-node":
+      return i18n.t("patch.addWidget", {
+        title: op.node?.title ?? op.node?.kind ?? "widget",
+        slot: op.slotId ?? "slot"
+      });
+    case "remove-node":
+      return i18n.t("patch.removeItem");
+    case "set-layout":
+      return i18n.t("patch.switchLayout", { layoutId: op.layoutId });
+    case "reveal-field":
+      return i18n.t("patch.showField", { fieldId: op.fieldId });
+    case "hide-field":
+      return i18n.t("patch.hideField", { fieldId: op.fieldId });
+    case "move-node":
+      return i18n.t("patch.moveTo", { slot: op.toSlotId ?? "slot" });
+    case "replace-node":
+      return i18n.t("patch.replaceItem");
+    case "promote-action":
+      return i18n.t("patch.promote", { actionId: op.actionId });
+    default:
+      return `${op.op}`;
+  }
+}
+
+// src/react/OverlayConflictResolver.tsx
+import { useMemo as useMemo2 } from "react";
+import { jsxDEV as jsxDEV9 } from "react/jsx-dev-runtime";
+"use client";
+function OverlayConflictResolver({
+  conflicts,
+  onResolve,
+  locale
+}) {
+  const i18n = useMemo2(() => createSurfaceI18n(locale), [locale]);
+  return /* @__PURE__ */ jsxDEV9("div", {
+    "data-overlay-conflicts": true,
+    style: {
+      padding: "12px",
+      marginBottom: "12px",
+      border: "1px solid var(--destructive, #ef4444)",
+      borderRadius: "8px",
+      backgroundColor: "var(--destructive/10, #fef2f2)"
+    },
+    children: [
+      /* @__PURE__ */ jsxDEV9("div", {
+        style: {
+          fontSize: "14px",
+          fontWeight: 600,
+          marginBottom: "8px",
+          color: "var(--destructive, #ef4444)"
+        },
+        children: i18n.t("overlay.conflicts.title")
+      }, undefined, false, undefined, this),
+      conflicts.map((c) => /* @__PURE__ */ jsxDEV9("div", {
+        style: {
+          padding: "8px",
+          marginBottom: "8px",
+          backgroundColor: "white",
+          borderRadius: "4px",
+          fontSize: "13px"
+        },
+        children: [
+          /* @__PURE__ */ jsxDEV9("span", {
+            children: c.targetKey
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV9("span", {
+            style: { margin: "0 8px", color: "#9ca3af" },
+            children: [
+              "(",
+              c.scopeA,
+              " vs ",
+              c.scopeB,
+              ")"
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV9("div", {
+            style: { marginTop: "8px", display: "flex", gap: "8px" },
+            children: [
+              /* @__PURE__ */ jsxDEV9("button", {
+                type: "button",
+                onClick: () => onResolve({ targetKey: c.targetKey, chosenScope: "A" }),
+                style: {
+                  padding: "4px 12px",
+                  fontSize: "12px",
+                  borderRadius: "4px",
+                  border: "1px solid #e5e7eb",
+                  backgroundColor: "white",
+                  cursor: "pointer"
+                },
+                children: i18n.t("overlay.conflicts.keepScope", { scope: c.scopeA })
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV9("button", {
+                type: "button",
+                onClick: () => onResolve({ targetKey: c.targetKey, chosenScope: "B" }),
+                style: {
+                  padding: "4px 12px",
+                  fontSize: "12px",
+                  borderRadius: "4px",
+                  border: "1px solid #e5e7eb",
+                  backgroundColor: "white",
+                  cursor: "pointer"
+                },
+                children: i18n.t("overlay.conflicts.keepScope", { scope: c.scopeB })
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, `${c.targetKey}-${c.overlayIdA}-${c.overlayIdB}`, true, undefined, this))
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/react/BundleRenderer.tsx
+import { jsxDEV as jsxDEV10, Fragment } from "react/jsx-dev-runtime";
+"use client";
+function BundleRenderer({
+  assistantSlotId,
+  assistantSlotContent,
+  onPatchAccept,
+  onPatchReject,
+  onOverlayConflictResolve
+} = {}) {
+  const plan = useBundlePlan();
+  const motionTokens = motionAdapterStub.getTokens(plan.adaptation.appliedDimensions.pace);
+  const ctx = {
+    plan,
+    bindings: plan.bindings,
+    preferences: plan.adaptation.appliedDimensions
+  };
+  const proposals = plan.ai?.proposals?.filter((p) => p.approvalState === "proposed");
+  const locale = plan.locale;
+  const renderSlot = (slotId, slotCtx) => {
+    if (assistantSlotId && slotId === assistantSlotId) {
+      return /* @__PURE__ */ jsxDEV10(Fragment, {
+        children: [
+          proposals && proposals.length > 0 && onPatchAccept && onPatchReject && /* @__PURE__ */ jsxDEV10("div", {
+            style: { marginBottom: "12px" },
+            children: proposals.map((p) => /* @__PURE__ */ jsxDEV10(PatchProposalCard, {
+              proposal: p,
+              onAccept: onPatchAccept,
+              onReject: onPatchReject,
+              locale
+            }, p.proposalId, false, undefined, this))
+          }, undefined, false, undefined, this),
+          assistantSlotContent
+        ]
+      }, undefined, true, undefined, this);
+    }
+    const nodes = getNodesForSlot(plan.nodes, slotId);
+    return /* @__PURE__ */ jsxDEV10(SlotRenderer, {
+      slotId,
+      ctx: slotCtx,
+      nodes
+    }, undefined, false, undefined, this);
+  };
+  const conflicts = plan.overlayConflicts ?? [];
+  return /* @__PURE__ */ jsxDEV10("div", {
+    "data-bundle-key": plan.bundleKey,
+    "data-surface-id": plan.surfaceId,
+    "data-layout-id": plan.layoutId,
+    style: {
+      display: "flex",
+      flexDirection: "column",
+      height: "100%",
+      minHeight: 0,
+      transition: motionTokens.layout ? `all ${motionTokens.durationMs}ms ease` : undefined
+    },
+    children: [
+      conflicts.length > 0 && onOverlayConflictResolve && /* @__PURE__ */ jsxDEV10(OverlayConflictResolver, {
+        conflicts,
+        onResolve: onOverlayConflictResolve,
+        locale
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV10(RegionRenderer, {
+        region: plan.layoutRoot,
+        ctx,
+        renderSlot
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function getNodesForSlot(nodes, slotId) {
+  if (slotId === "primary")
+    return nodes;
+  return [];
+}
+
+// src/react/WidgetPalette.tsx
+import { jsxDEV as jsxDEV11 } from "react/jsx-dev-runtime";
+"use client";
+function WidgetPalette({
+  registry,
+  allowedNodeKinds,
+  onInsert
+}) {
+  const widgets = registry.listByTrust("core");
+  const filtered = !allowedNodeKinds || allowedNodeKinds.includes("custom-widget") ? widgets : [];
+  return /* @__PURE__ */ jsxDEV11("div", {
+    "data-widget-palette": true,
+    style: {
+      padding: "12px",
+      minWidth: "180px",
+      borderRight: "1px solid var(--border, #e5e7eb)",
+      backgroundColor: "var(--muted, #f9fafb)"
+    },
+    children: [
+      /* @__PURE__ */ jsxDEV11("div", {
+        style: {
+          fontSize: "12px",
+          fontWeight: 600,
+          marginBottom: "8px",
+          textTransform: "uppercase",
+          color: "var(--muted-foreground, #6b7280)"
+        },
+        children: "Widgets"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV11("ul", {
+        style: { listStyle: "none", margin: 0, padding: 0 },
+        children: filtered.map((w) => /* @__PURE__ */ jsxDEV11("li", {
+          "data-widget-key": w.widgetKey,
+          role: onInsert ? "button" : undefined,
+          tabIndex: onInsert ? 0 : undefined,
+          style: {
+            padding: "8px 12px",
+            marginBottom: "4px",
+            borderRadius: "6px",
+            cursor: onInsert ? "grab" : "default",
+            backgroundColor: "white",
+            border: "1px solid var(--border, #e5e7eb)"
+          },
+          onClick: onInsert ? () => onInsert(w.widgetKey, "primary") : undefined,
+          onKeyDown: onInsert ? (e) => {
+            if (e.key === "Enter" || e.key === " ") {
+              e.preventDefault();
+              onInsert(w.widgetKey, "primary");
+            }
+          } : undefined,
+          children: w.title
+        }, w.widgetKey, false, undefined, this))
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+export {
+  verifyWorkspaceOverlay,
+  validateSurfacePatchOp,
+  validateSurfacePatch,
+  validatePatchProposal,
+  validateLayoutSlots,
+  validateBundleNodeKinds,
+  useIsEditing,
+  useBundlePreferences,
+  useBundlePlan,
+  toOverlayTargetRef,
+  toOverlayScopeContext,
+  toOverlayRenderableField,
+  toOverlayRenderable,
+  signWorkspaceOverlay,
+  rollbackSurfacePatches,
+  resolvePreferenceProfile,
+  resolveBundle,
+  resizablePanelsAdapterStub,
+  proposePatchToolConfig,
+  motionAdapterStub,
+  mergeOverlayResultIntoFields,
+  fromOverlayRenderableField,
+  floatingUiAdapterStub,
+  evaluatePatchProposalPolicy,
+  evaluateAndEmitPatchPolicy,
+  emitPolicyRedacted,
+  emitPolicyDenied,
+  emitPatchRejected,
+  emitPatchProposed,
+  emitPatchApproved,
+  emitOverlaySaved,
+  emitOverlayFailed,
+  emitOverlayApplied,
+  dndKitAdapterStub,
+  dndKitAdapter,
+  defineModuleBundle,
+  defaultPreferenceAdapter,
+  createWidgetRegistry,
+  createOverrideStoreWithApprovalGate,
+  createMutableFieldRendererRegistry,
+  createInMemoryOverrideStore,
+  createFieldRendererRegistry,
+  createCommandRegistry,
+  createBundleExtensionRegistry,
+  createActionRegistry,
+  compilePlannerPrompt,
+  buildSurfacePatchProposal,
+  buildOverrideTargetKey,
+  buildContext,
+  blocknoteAdapterStub,
+  applySurfacePatch,
+  applyEntityFieldOverlays,
+  aiSdkAdapterStub,
+  WidgetPalette,
+  SlotRenderer,
+  RegionRenderer,
+  PatchProposalCard,
+  PROPOSE_PATCH_TOOL_SCHEMA,
+  OverlayConflictResolver,
+  FALLBACK_FIELD_KIND,
+  BundleRenderer,
+  BundleProvider
+};