@contractspec/lib.surface-runtime 0.2.3 → 0.3.2

package/dist/runtime/rollback.js

@@ -1,326 +1,5 @@
-// @bun
-// 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/rollback.ts
-function rollbackSurfacePatches(plan, approvalStack, count = 1) {
+import { applySurfacePatch } from "./apply-surface-patch";
+export function rollbackSurfacePatches(plan, approvalStack, count = 1) {
   if (count <= 0 || approvalStack.length === 0) {
     return { plan, revertedCount: 0, remainingStack: approvalStack };
   }
@@ -343,6 +22,3 @@ function rollbackSurfacePatches(plan, approvalStack, count = 1) {
     remainingStack: remaining
   };
 }
-export {
-  rollbackSurfacePatches
-};

package/dist/runtime/widget-registry.js

@@ -1,5 +1,3 @@
-// @bun
-// 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.");
@@ -8,7 +6,7 @@ function validateTrust(trust) {
     throw new Error(`Invalid widget trust: ${trust}`);
   }
 }
-function createWidgetRegistry() {
+export function createWidgetRegistry() {
   const entries = new Map;
   return {
     register(entry) {
@@ -32,6 +30,3 @@ function createWidgetRegistry() {
     }
   };
 }
-export {
-  createWidgetRegistry
-};

package/dist/spec/define-module-bundle.js

@@ -1,68 +1,5 @@
-// @bun
-// 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) {
+import { validateLayoutSlots } from "./validate-bundle";
+export 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");
   }
@@ -109,6 +46,3 @@ function defineModuleBundle(spec) {
   }
   return spec;
 }
-export {
-  defineModuleBundle
-};