@synap-core/workspace-templates 0.9.1 → 0.9.3

package/dist/index.js

@@ -6841,14 +6841,13 @@ var DATA = {
             "valueType": "string",
             "inputType": "select",
             "enumValues": [
-              "manual",
-              "referral",
+              "cold-outreach",
               "linkedin",
-              "email",
+              "twitter",
+              "landing-page",
+              "inbound-call",
+              "referral",
               "event",
-              "inbound",
-              "partner",
-              "import",
               "other"
             ]
           },
@@ -7218,6 +7217,37 @@ var DATA = {
             "label": "Notes",
             "valueType": "string",
             "inputType": "textarea"
+          },
+          {
+            "slug": "campaign-type",
+            "label": "Type",
+            "valueType": "string",
+            "inputType": "select",
+            "enumValues": [
+              "scoping",
+              "outreach",
+              "live",
+              "partnership",
+              "event",
+              "other"
+            ],
+            "constraints": {
+              "defaultValue": "outreach"
+            }
+          },
+          {
+            "slug": "campaign-color",
+            "label": "Color",
+            "valueType": "string",
+            "inputType": "select",
+            "enumValues": [
+              "indigo",
+              "violet",
+              "amber",
+              "cyan",
+              "pink",
+              "teal"
+            ]
           }
         ]
       }
@@ -8922,6 +8952,37 @@ var DATA = {
             "label": "Notes",
             "valueType": "string",
             "inputType": "textarea"
+          },
+          {
+            "slug": "campaign-type",
+            "label": "Type",
+            "valueType": "string",
+            "inputType": "select",
+            "enumValues": [
+              "scoping",
+              "outreach",
+              "live",
+              "partnership",
+              "event",
+              "other"
+            ],
+            "constraints": {
+              "defaultValue": "outreach"
+            }
+          },
+          {
+            "slug": "campaign-color",
+            "label": "Color",
+            "valueType": "string",
+            "inputType": "select",
+            "enumValues": [
+              "indigo",
+              "violet",
+              "amber",
+              "cyan",
+              "pink",
+              "teal"
+            ]
           }
         ]
       },
@@ -10024,6 +10085,12 @@ var DATA = {
       ],
       "isPublic": true
     },
+    "app": {
+      "kind": "url",
+      "appId": "crm",
+      "url": "https://crm.synap.live",
+      "title": "CRM"
+    },
     "dependencies": [
       {
         "slug": "foundation",
@@ -10094,7 +10161,17 @@ var DATA = {
             "slug": "source",
             "label": "Source",
             "valueType": "string",
-            "inputType": "text"
+            "inputType": "select",
+            "enumValues": [
+              "cold-outreach",
+              "linkedin",
+              "twitter",
+              "landing-page",
+              "inbound-call",
+              "referral",
+              "event",
+              "other"
+            ]
           },
           {
             "slug": "icpScore",
@@ -10183,7 +10260,17 @@ var DATA = {
             "slug": "source",
             "label": "Source",
             "valueType": "string",
-            "inputType": "text"
+            "inputType": "select",
+            "enumValues": [
+              "cold-outreach",
+              "linkedin",
+              "twitter",
+              "landing-page",
+              "inbound-call",
+              "referral",
+              "event",
+              "other"
+            ]
           },
           {
             "slug": "icpScore",
@@ -22039,6 +22126,37 @@ var DATA = {
             "label": "Notes",
             "valueType": "string",
             "inputType": "textarea"
+          },
+          {
+            "slug": "campaign-type",
+            "label": "Type",
+            "valueType": "string",
+            "inputType": "select",
+            "enumValues": [
+              "scoping",
+              "outreach",
+              "live",
+              "partnership",
+              "event",
+              "other"
+            ],
+            "constraints": {
+              "defaultValue": "outreach"
+            }
+          },
+          {
+            "slug": "campaign-color",
+            "label": "Color",
+            "valueType": "string",
+            "inputType": "select",
+            "enumValues": [
+              "indigo",
+              "violet",
+              "amber",
+              "cyan",
+              "pink",
+              "teal"
+            ]
           }
         ]
       },
@@ -28861,6 +28979,339 @@ function groupByDomain(items, domainOf) {
   }));
 }
 
+// src/validate-flow.ts
+var FLOW_NODE_TYPES = [
+  "trigger",
+  "command",
+  "condition",
+  "delay",
+  "output",
+  "loop",
+  "transform",
+  "fetch",
+  "query",
+  "entity_read",
+  "related_entities",
+  "guard",
+  "compute",
+  "select",
+  "claim",
+  "messages_query",
+  "switch",
+  "skill",
+  "capability",
+  "sub_automation",
+  "playbook_run"
+];
+var FLOW_OUTPUT_TYPES = [
+  "notification",
+  "entity_create",
+  "entity_update",
+  "facet_attach",
+  "facet_update",
+  "facet_detach",
+  "relation_create",
+  "webhook",
+  "channel_message",
+  "session_update",
+  "set_state"
+];
+var CHANNEL_MESSAGE_CHANNEL_TYPES = [
+  "personal_thread",
+  "proactive",
+  "subjectEntity"
+];
+var NODE_TYPE_SET = new Set(FLOW_NODE_TYPES);
+var OUTPUT_TYPE_SET = new Set(FLOW_OUTPUT_TYPES);
+var CHANNEL_TYPE_SET = new Set(CHANNEL_MESSAGE_CHANNEL_TYPES);
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function nonEmptyString(v) {
+  return typeof v === "string" && v.trim().length > 0;
+}
+function validateFlowDefinition(flow, resolvers) {
+  const errors = [];
+  if (!isRecord(flow)) {
+    return {
+      valid: false,
+      errors: [
+        {
+          code: "flow_not_object",
+          message: "flowDefinition must be an object with `nodes` and `edges` arrays."
+        }
+      ]
+    };
+  }
+  const f = flow;
+  if (!Array.isArray(f.nodes)) {
+    errors.push({
+      code: "nodes_not_array",
+      message: "flowDefinition.nodes must be an array."
+    });
+  }
+  if (!Array.isArray(f.edges)) {
+    errors.push({
+      code: "edges_not_array",
+      message: "flowDefinition.edges must be an array."
+    });
+  }
+  if (errors.length > 0) return { valid: false, errors };
+  const nodes = f.nodes.map(
+    (n) => isRecord(n) ? n : {}
+  );
+  const edges = f.edges.map(
+    (e) => isRecord(e) ? e : {}
+  );
+  const nodeIds = /* @__PURE__ */ new Set();
+  const seenIds = /* @__PURE__ */ new Set();
+  nodes.forEach((node, idx) => {
+    if (!nonEmptyString(node.id)) {
+      errors.push({
+        code: "node_missing_id",
+        message: `Node at index ${idx} is missing a non-empty string \`id\`.`
+      });
+      return;
+    }
+    if (seenIds.has(node.id)) {
+      errors.push({
+        nodeId: node.id,
+        code: "duplicate_node_id",
+        message: `Duplicate node id "${node.id}" \u2014 every node id must be unique.`
+      });
+      return;
+    }
+    seenIds.add(node.id);
+    nodeIds.add(node.id);
+  });
+  const nodesById = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (nonEmptyString(node.id)) nodesById.set(node.id, node);
+    const nodeId = nonEmptyString(node.id) ? node.id : void 0;
+    if (!nonEmptyString(node.type) || !NODE_TYPE_SET.has(node.type)) {
+      errors.push({
+        nodeId,
+        code: "unknown_node_type",
+        message: `Node ${nodeId ? `"${nodeId}"` : `at index ?`} has ${nonEmptyString(node.type) ? `unknown type "${node.type}"` : "no type"}. Must be one of: ${FLOW_NODE_TYPES.join(", ")}.`
+      });
+      continue;
+    }
+    const type = node.type;
+    const data = isRecord(node.data) ? node.data : {};
+    switch (type) {
+      case "capability": {
+        if (!nonEmptyString(data.verbId)) {
+          errors.push({
+            nodeId,
+            code: "capability_missing_verbId",
+            message: `Capability node "${nodeId}" has no \`verbId\`. Pick a verb on the selected tool.`
+          });
+        } else if (resolvers?.verbExists && !resolvers.verbExists(data.verbId)) {
+          errors.push({
+            nodeId,
+            code: "capability_unknown_verbId",
+            message: `Capability node "${nodeId}" references verb "${data.verbId}", which is not in the capability catalog.`
+          });
+        }
+        break;
+      }
+      case "skill": {
+        const skillId = nonEmptyString(data.skillId) ? data.skillId : void 0;
+        const skillName = nonEmptyString(data.skillName) ? data.skillName : void 0;
+        if (!skillId && !skillName) {
+          errors.push({
+            nodeId,
+            code: "skill_missing_ref",
+            message: `Skill node "${nodeId}" has neither \`skillId\` nor \`skillName\`. One is required.`
+          });
+        } else if (resolvers?.skillExists && !resolvers.skillExists({ skillId, skillName })) {
+          errors.push({
+            nodeId,
+            code: "skill_unknown_ref",
+            message: `Skill node "${nodeId}" references a skill (${skillId ? `id "${skillId}"` : `name "${skillName}"`}) that does not exist.`
+          });
+        }
+        break;
+      }
+      case "playbook_run": {
+        const playbookId = nonEmptyString(data.playbookId) ? data.playbookId : void 0;
+        const playbookName = nonEmptyString(data.playbookName) ? data.playbookName : void 0;
+        if (!playbookId && !playbookName) {
+          errors.push({
+            nodeId,
+            code: "playbook_run_missing_ref",
+            message: `Playbook-run node "${nodeId}" has neither \`playbookId\` nor \`playbookName\`. One is required.`
+          });
+        } else if (resolvers?.playbookExists && !resolvers.playbookExists({ playbookId, playbookName })) {
+          errors.push({
+            nodeId,
+            code: "playbook_run_unknown_ref",
+            message: `Playbook-run node "${nodeId}" references a playbook (${playbookId ? `id "${playbookId}"` : `name "${playbookName}"`}) that does not exist.`
+          });
+        }
+        break;
+      }
+      case "output": {
+        const outputType = data.outputType;
+        if (!nonEmptyString(outputType) || !OUTPUT_TYPE_SET.has(outputType)) {
+          errors.push({
+            nodeId,
+            code: "output_bad_outputType",
+            message: `Output node "${nodeId}" has ${nonEmptyString(outputType) ? `unknown outputType "${outputType}"` : "no outputType"}. Must be one of: ${FLOW_OUTPUT_TYPES.join(", ")}.`
+          });
+          break;
+        }
+        if (outputType === "channel_message") {
+          const config = isRecord(data.config) ? data.config : {};
+          const channelType = config.channelType;
+          if (channelType !== void 0 && channelType !== null) {
+            if (!nonEmptyString(channelType) || !CHANNEL_TYPE_SET.has(channelType)) {
+              errors.push({
+                nodeId,
+                code: "channel_message_unknown_channelType",
+                message: `Channel-message output "${nodeId}" has unknown channelType ${nonEmptyString(channelType) ? `"${channelType}"` : JSON.stringify(channelType)}. Use one of: ${CHANNEL_MESSAGE_CHANNEL_TYPES.join(
+                  ", "
+                )}, or set \`config.channelEntityRef\`/\`config.channelId\`, or omit the target to post to the automation's own run channel.`
+              });
+            }
+          }
+        }
+        break;
+      }
+      case "loop": {
+        if (!nonEmptyString(data.iteratorExpression)) {
+          errors.push({
+            nodeId,
+            code: "loop_missing_iterator",
+            message: `Loop node "${nodeId}" has no \`iteratorExpression\` (the items to iterate, e.g. "steps.query.output.entities").`
+          });
+        }
+        break;
+      }
+      case "condition": {
+        if (!nonEmptyString(data.expression)) {
+          errors.push({
+            nodeId,
+            code: "condition_missing_expression",
+            message: `Condition node "${nodeId}" has no \`expression\` (the predicate to evaluate).`
+          });
+        }
+        break;
+      }
+      case "switch": {
+        if (!nonEmptyString(data.expression)) {
+          errors.push({
+            nodeId,
+            code: "switch_missing_expression",
+            message: `Switch node "${nodeId}" has no \`expression\` (the value to match against cases).`
+          });
+        }
+        if (!Array.isArray(data.cases) || data.cases.length === 0) {
+          errors.push({
+            nodeId,
+            code: "switch_missing_cases",
+            message: `Switch node "${nodeId}" has no \`cases\`. Add at least one case with a \`value\`.`
+          });
+        }
+        break;
+      }
+    }
+  }
+  edges.forEach((edge, idx) => {
+    const edgeId = nonEmptyString(edge.id) ? edge.id : void 0;
+    const label = edgeId ? `"${edgeId}"` : `at index ${idx}`;
+    if (!nonEmptyString(edge.source) || !nodeIds.has(edge.source)) {
+      errors.push({
+        edgeId,
+        code: "edge_bad_source",
+        message: `Edge ${label} has ${nonEmptyString(edge.source) ? `source "${edge.source}" which is not a node in this flow` : "no source node"}.`
+      });
+    }
+    if (!nonEmptyString(edge.target) || !nodeIds.has(edge.target)) {
+      errors.push({
+        edgeId,
+        code: "edge_bad_target",
+        message: `Edge ${label} has ${nonEmptyString(edge.target) ? `target "${edge.target}" which is not a node in this flow` : "no target node"}.`
+      });
+    }
+  });
+  for (const edge of edges) {
+    if (!nonEmptyString(edge.source) || !nodesById.has(edge.source)) continue;
+    if (edge.sourceHandle === void 0 || edge.sourceHandle === null) continue;
+    if (!nonEmptyString(edge.sourceHandle)) continue;
+    const src = nodesById.get(edge.source);
+    const edgeId = nonEmptyString(edge.id) ? edge.id : void 0;
+    if (src.type === "condition") {
+      if (edge.sourceHandle !== "yes" && edge.sourceHandle !== "no") {
+        errors.push({
+          edgeId,
+          nodeId: edge.source,
+          code: "condition_bad_handle",
+          message: `Edge from condition "${edge.source}" has sourceHandle "${edge.sourceHandle}" \u2014 must be "yes" or "no".`
+        });
+      }
+    } else if (src.type === "switch") {
+      const data = isRecord(src.data) ? src.data : {};
+      const caseValues = Array.isArray(data.cases) ? data.cases.map((c) => isRecord(c) ? c.value : void 0).filter((v) => typeof v === "string") : [];
+      if (!caseValues.includes(edge.sourceHandle)) {
+        errors.push({
+          edgeId,
+          nodeId: edge.source,
+          code: "switch_bad_handle",
+          message: `Edge from switch "${edge.source}" has sourceHandle "${edge.sourceHandle}", which matches no declared case value (${caseValues.length ? caseValues.join(", ") : "none declared"}).`
+        });
+      }
+    }
+  }
+  const cyclic = detectCycle(nodeIds, edges);
+  if (cyclic.length > 0) {
+    errors.push({
+      code: "flow_has_cycle",
+      message: `Flow has a cycle \u2014 these nodes cannot be ordered and would never run: ${cyclic.join(
+        ", "
+      )}. Remove the back-edge(s) so the graph is acyclic.`
+    });
+  }
+  return { valid: errors.length === 0, errors };
+}
+function detectCycle(nodeIds, edges) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    inDegree.set(id, 0);
+    adjacency.set(id, []);
+  }
+  for (const edge of edges) {
+    const source = nonEmptyString(edge.source) ? edge.source : void 0;
+    const target = nonEmptyString(edge.target) ? edge.target : void 0;
+    if (!source || !target) continue;
+    if (!nodeIds.has(source) || !nodeIds.has(target)) continue;
+    adjacency.get(source).push(target);
+    inDegree.set(target, (inDegree.get(target) ?? 0) + 1);
+  }
+  const queue = [];
+  for (const [id, degree] of inDegree) if (degree === 0) queue.push(id);
+  let visited = 0;
+  while (queue.length > 0) {
+    const id = queue.shift();
+    visited++;
+    for (const target of adjacency.get(id) ?? []) {
+      const next = (inDegree.get(target) ?? 1) - 1;
+      inDegree.set(target, next);
+      if (next === 0) queue.push(target);
+    }
+  }
+  if (visited === nodeIds.size) return [];
+  const cyclic = [];
+  for (const [id, degree] of inDegree) if (degree > 0) cyclic.push(id);
+  return cyclic;
+}
+function flowValidationErrorMessage(flow, resolvers) {
+  const result = validateFlowDefinition(flow, resolvers);
+  if (result.valid) return null;
+  return "Invalid automation flow: " + result.errors.map((e) => e.nodeId ? `[${e.nodeId}] ${e.message}` : e.message).join(" ");
+}
+
 // src/validate.ts
 var REQUIRED_META_FIELDS = [
   "slug",
@@ -28955,12 +29406,80 @@ function validateTemplate(tpl, opts = {}) {
   else {
     for (const f of REQUIRED_WORKSPACE_FIELDS) {
       if (!tpl.workspace[f])
-        add("workspace-field-required", `workspace.${f}`, `workspace.${f} is required`);
+        add(
+          "workspace-field-required",
+          `workspace.${f}`,
+          `workspace.${f} is required`
+        );
     }
   }
   if (!tpl.profiles || tpl.profiles.length === 0) {
     add("profiles-required", "profiles", "At least one profile is required");
   }
+  if (tpl.app && tpl.layout && Object.prototype.hasOwnProperty.call(tpl.layout, "primarySurface")) {
+    add(
+      "primary-surface-authoring-conflict",
+      "layout.primarySurface",
+      "Declare either top-level app or layout.primarySurface, not both"
+    );
+  }
+  if (tpl.app?.kind === "native" && !tpl.app.appId) {
+    add(
+      "app-native-id-required",
+      "app.appId",
+      "A native workspace app requires appId"
+    );
+  }
+  if (tpl.app?.kind === "url" && (!tpl.app.appId || !tpl.app.url)) {
+    add(
+      "app-url-identity-required",
+      "app",
+      "A hosted workspace app requires both appId and url"
+    );
+  }
+  if (tpl.app?.kind === "stored" && !tpl.app.cellKey) {
+    add(
+      "app-cell-key-required",
+      "app.cellKey",
+      "A stored workspace app requires cellKey"
+    );
+  }
+  const authoredPrimary = tpl.layout?.primarySurface;
+  if (authoredPrimary?.kind === "view" && !("viewId" in authoredPrimary)) {
+    const viewName = authoredPrimary.viewName;
+    const viewSlug = authoredPrimary.viewSlug;
+    if (!viewName && !viewSlug) {
+      add(
+        "primary-view-reference-required",
+        "layout.primarySurface",
+        "A view primary surface requires viewName or viewSlug"
+      );
+    } else {
+      const declaredViews = [
+        ...(tpl.views ?? []).map((view) => ({
+          name: view.name,
+          slug: view.slug
+        })),
+        ...tpl.bento?.viewName ? [{ name: tpl.bento.viewName, slug: void 0 }] : []
+      ];
+      const matches = declaredViews.filter(
+        (view) => (!viewName || view.name === viewName) && (!viewSlug || view.slug === viewSlug)
+      );
+      if (matches.length === 0) {
+        add(
+          "primary-view-reference-unknown",
+          "layout.primarySurface",
+          `Primary surface references an unknown view (${viewName ?? viewSlug})`
+        );
+      } else if (matches.length > 1) {
+        add(
+          "primary-view-reference-ambiguous",
+          "layout.primarySurface",
+          `Primary surface view reference matches ${matches.length} authored views; add a unique viewSlug`
+        );
+      }
+    }
+  }
   const baseProfileSlugs = collectBaseProfileSlugs(tpl, resolveDepFrom(opts));
   const slugs = new Set((tpl.profiles || []).map((p) => p.slug));
   const known = (s) => slugs.has(s) || SYSTEM_PROFILES.has(s) || baseProfileSlugs.has(s);
@@ -29038,11 +29557,29 @@ function validateTemplate(tpl, opts = {}) {
   }
   for (const a of tpl.automations || []) {
     const refs = [];
-    collectProfileSlugRefs(a.triggerConfig, `automation "${a.name}".triggerConfig`, refs);
+    collectProfileSlugRefs(
+      a.triggerConfig,
+      `automation "${a.name}".triggerConfig`,
+      refs
+    );
     collectProfileSlugRefs(a.flow, `automation "${a.name}".flow`, refs);
     for (const r of refs)
       if (!known(r.slug))
-        add("automation-ref-unknown", r.where, `${r.where} references unknown profile "${r.slug}"`);
+        add(
+          "automation-ref-unknown",
+          r.where,
+          `${r.where} references unknown profile "${r.slug}"`
+        );
+    const flow = a.flow ?? a.flowDefinition;
+    if (flow != null) {
+      const {
+        errors: flowErrors
+      } = validateFlowDefinition(flow);
+      for (const fe of flowErrors) {
+        const loc = fe.nodeId ? `automation "${a.name}".flow.node "${fe.nodeId}"` : fe.edgeId ? `automation "${a.name}".flow.edge "${fe.edgeId}"` : `automation "${a.name}".flow`;
+        add(`automation-flow-${fe.code}`, loc, `${loc}: ${fe.message}`);
+      }
+    }
   }
   for (const pb of tpl.playbooks || []) {
     const ps = pb.subjectProfile?.profileSlug;
@@ -29088,7 +29625,9 @@ function validateTemplate(tpl, opts = {}) {
         `profileEntityBentoTemplates has an entry for unknown profile "${key}"`
       );
   }
-  const composeDeps = (tpl.dependencies || []).filter((d) => d.relation === "compose");
+  const composeDeps = (tpl.dependencies || []).filter(
+    (d) => d.relation === "compose"
+  );
   for (const dep of composeDeps) {
     if (tpl.workspace?.visibility !== void 0) {
       add(
@@ -29108,7 +29647,9 @@ function validateTemplate(tpl, opts = {}) {
   const blocks = tpl.bento?.blocks ?? [];
   const authoredWidgets = blocks.filter((b) => b.kind === "widget");
   const authoredViews = blocks.filter((b) => b.kind === "view");
-  const unknownKind = blocks.filter((b) => b.kind !== "widget" && b.kind !== "view");
+  const unknownKind = blocks.filter(
+    (b) => b.kind !== "widget" && b.kind !== "view"
+  );
   if (unknownKind.length) {
     add(
       "bento-unknown-kind",
@@ -29140,7 +29681,11 @@ function validateTemplate(tpl, opts = {}) {
       const expectW = authoredWidgets.length - badWidgets.length;
       const expectV = authoredViews.length - badViews.length;
       const doors = [
-        ["tRPC createFromDefinition", definition.bentoLayout ?? [], definition.bentoViewBlocks ?? []],
+        [
+          "tRPC createFromDefinition",
+          definition.bentoLayout ?? [],
+          definition.bentoViewBlocks ?? []
+        ],
         ["CP packages/apply", pkg.bentoLayout ?? [], pkg.bentoViewBlocks ?? []]
       ];
       for (const [door, layout, viewBlocks] of doors) {
@@ -29151,7 +29696,9 @@ function validateTemplate(tpl, opts = {}) {
             `[${door}]: authored ${expectW} widget/${expectV} view \u2192 got ${layout.length} bentoLayout/${viewBlocks.length} bentoViewBlocks`
           );
         }
-        const layoutBad = layout.filter((b) => typeof b.widgetType !== "string");
+        const layoutBad = layout.filter(
+          (b) => typeof b.widgetType !== "string"
+        );
         const viewsBad = viewBlocks.filter(
           (b) => typeof b.viewName !== "string" || b.kind !== "view"
         );
@@ -29221,6 +29768,79 @@ function toAutomationWire(automations) {
     status: a.status
   }));
 }
+var hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+function appRefToPrimarySurface(app) {
+  if (!app) return void 0;
+  if (app.kind === "native") {
+    if (!app.appId) {
+      throw new Error("Workspace template native app is missing appId");
+    }
+    return {
+      kind: "app",
+      appId: app.appId,
+      rendererType: "native",
+      ...app.title ? { title: app.title } : {},
+      ...app.props ? { props: app.props } : {}
+    };
+  }
+  if (app.kind === "url") {
+    if (!app.appId || !app.url) {
+      throw new Error(
+        "Workspace template URL app requires both appId and url"
+      );
+    }
+    return {
+      kind: "app",
+      appId: app.appId,
+      rendererType: "external",
+      url: app.url,
+      ...app.title ? { title: app.title } : {},
+      ...app.props ? { props: app.props } : {}
+    };
+  }
+  if (app.kind === "stored") {
+    if (!app.cellKey) {
+      throw new Error("Workspace template stored app is missing cellKey");
+    }
+    if (app.cellKey === "entity-detail" && !app.props?.entityId) {
+      return void 0;
+    }
+    return {
+      kind: "cell",
+      cellKey: app.cellKey,
+      ...app.title ? { title: app.title } : {},
+      ...app.props ? { props: app.props } : {}
+    };
+  }
+  return void 0;
+}
+function normalizeTemplateLayout(layout, app) {
+  if (app && layout && hasOwn(layout, "primarySurface")) {
+    throw new Error(
+      "Workspace template declares both top-level app and layout.primarySurface; choose one authoring source"
+    );
+  }
+  const primarySurface = (() => {
+    if (layout && hasOwn(layout, "primarySurface")) {
+      return layout.primarySurface;
+    }
+    const fromApp = appRefToPrimarySurface(app);
+    if (fromApp) return fromApp;
+    if (layout && hasOwn(layout, "defaultApp")) {
+      return layout.defaultApp ? {
+        kind: "app",
+        appId: layout.defaultApp,
+        rendererType: "native"
+      } : null;
+    }
+    return void 0;
+  })();
+  if (!layout && primarySurface === void 0) return void 0;
+  return {
+    ...layout,
+    ...primarySurface !== void 0 || layout && hasOwn(layout, "primarySurface") ? { primarySurface } : {}
+  };
+}
 function resolveBlockKind(block) {
   if (block.kind === "widget" || block.kind === "view") return block.kind;
   if (block.widgetType) return "widget";
@@ -29281,7 +29901,7 @@ function toWorkspaceDefinition(slugOrYaml, nameOverride) {
     seedEntities: tpl.seedEntities ?? [],
     suggestedRelations: tpl.suggestedRelations,
     displayTemplates: tpl.displayTemplates,
-    layoutConfig: tpl.layout,
+    layoutConfig: normalizeTemplateLayout(tpl.layout, tpl.app),
     bentoViewName: tpl.bento?.viewName,
     bentoLayout: bento.bentoLayout,
     bentoViewBlocks: bento.bentoViewBlocks,
@@ -29355,7 +29975,7 @@ function toPackageDefinition(slugOrYaml) {
     bentoViewBlocks: bento.bentoViewBlocks,
     bentoViewName: tpl.bento?.viewName,
     profileEntityBentoTemplates: tpl.profileEntityBentoTemplates,
-    layoutConfig: tpl.layout,
+    layoutConfig: normalizeTemplateLayout(tpl.layout, tpl.app),
     capabilities: tpl.integrations,
     playbooks: tpl.playbooks,
     automations: toAutomationWire(tpl.automations),
@@ -29365,7 +29985,10 @@ function toPackageDefinition(slugOrYaml) {
   };
 }
 export {
+  CHANNEL_MESSAGE_CHANNEL_TYPES,
   DECLARED_DIVERGENCES,
+  FLOW_NODE_TYPES,
+  FLOW_OUTPUT_TYPES,
   OTHER_DOMAIN_ID,
   OTHER_DOMAIN_LABEL,
   PACKAGE_DEPENDENCY_KINDS,
@@ -29381,6 +30004,7 @@ export {
   conceptTerm,
   domainLabel,
   findConceptViolations,
+  flowValidationErrorMessage,
   formatConceptViolations,
   getWorkspaceTemplate,
   groupByDomain,
@@ -29390,10 +30014,12 @@ export {
   listPublicTemplates,
   listWorkspaceTemplates,
   mergeCatalog,
+  normalizeTemplateLayout,
   rowToRemoteEntry,
   splitBentoBlocks,
   toPackageDefinition,
   toWorkspaceDefinition,
+  validateFlowDefinition,
   validateTemplate
 };
 //# sourceMappingURL=index.js.map