@synap-core/workspace-templates 0.9.2 → 0.9.4

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",
@@ -10571,6 +10658,66 @@ var DATA = {
         "type": "linked_to_deal"
       }
     ],
+    "onboarding": {
+      "goal": "Turn the user's real commercial motion into a usable pipeline \u2014 the right companies and people, their active opportunities, and an explicit next step for every deal \u2014 so CRM becomes the place sales work moves forward.\n",
+      "framing": "THE REVENUE OPERATOR: Act as a pragmatic sales lead setting up a CRM people will actually maintain. Start from the user's existing motion, vocabulary, and active conversations. Resolve before creating so imported or Pod-wide people are reused rather than duplicated. Push for a concrete next step and date; never invent revenue, probability, or contact details.\n",
+      "expertise": {
+        "starters": [
+          "A useful first pipeline is deliberately small. Start with the few stages that change how the team acts \u2014 contacted, qualifying, proposal, negotiating, won, and lost \u2014 and keep the template's default stages unless the user's real process needs a different view.\n",
+          "Populate the workspace with live work, not a perfect historical archive: propose the three to five opportunities the user is actively trying to move, then add the companies and people needed to understand those deals.\n",
+          'Every active deal needs one observable next step with a date. If the next step is "follow up" or "keep warm", help turn it into a specific action such as "send the revised proposal Thursday" before capturing it.\n'
+        ],
+        "blindSpots": [
+          "A deal without a real person is usually an account-shaped hope. If an opportunity has no stakeholder, surface the gap instead of fabricating a placeholder contact.\n",
+          "Pipelines become fiction when stages describe confidence rather than an event the buyer completed. Ask what evidence moves a deal into its current stage, especially around proposal and negotiation.\n",
+          "More fields do not create better sales hygiene. Prioritize stage, value when known, expected close date, and next step; leave unverifiable fields empty and offer enrichment separately.\n"
+        ],
+        "bar": "A sales lead can open the pipeline and immediately see the few live opportunities, the real company and stakeholder behind each one, its evidence-based stage, and the dated next action \u2014 with no duplicate people and no invented commercial data.\n"
+      },
+      "collect": [
+        {
+          "profileSlug": "company",
+          "what": "The real prospect organisations behind current conversations.",
+          "cardinality": "few",
+          "keyFields": [
+            "website",
+            "industry",
+            "companySize",
+            "source",
+            "nextStep"
+          ]
+        },
+        {
+          "profileSlug": "person",
+          "what": "The known stakeholders for those organisations and opportunities.",
+          "cardinality": "few",
+          "keyFields": [
+            "email",
+            "jobTitle",
+            "company",
+            "source",
+            "nextFollowUpDate"
+          ]
+        },
+        {
+          "profileSlug": "deal",
+          "what": "The live opportunities worth actively moving through the pipeline.",
+          "cardinality": "few",
+          "keyFields": [
+            "dealStage",
+            "value",
+            "closeDate",
+            "nextStep"
+          ]
+        }
+      ],
+      "openingQuestions": [
+        "Which three to five opportunities are you actively trying to move right now?",
+        "For the most important one, which company and real stakeholder are involved?",
+        "What has the buyer actually done so far, and what is the next dated action?"
+      ],
+      "doneWhen": "At least one real opportunity is linked to its company or stakeholder and has an evidence-based stage plus a concrete next step; the user can see how to add or import the rest without duplicating existing people.\n"
+    },
     "playbooks": [
       {
         "name": "Enrich Lead/Company",
@@ -22039,6 +22186,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 +29039,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",
@@ -28947,7 +29458,8 @@ function validateTemplate(tpl, opts = {}) {
   if (!tpl.meta) add("meta-required", "meta", "Missing required field: meta");
   else {
     for (const f of REQUIRED_META_FIELDS) {
-      if (!tpl.meta[f]) add("meta-field-required", `meta.${f}`, `meta.${f} is required`);
+      if (!tpl.meta[f])
+        add("meta-field-required", `meta.${f}`, `meta.${f} is required`);
     }
   }
   if (!tpl.workspace)
@@ -28955,12 +29467,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);
@@ -29020,7 +29600,85 @@ function validateTemplate(tpl, opts = {}) {
       );
     }
   }
-  for (const c of tpl.onboarding?.collect || []) {
+  const onboarding = tpl.onboarding;
+  if (onboarding) {
+    if (typeof onboarding.goal !== "string" || onboarding.goal.trim() === "") {
+      add(
+        "onboarding-goal-empty",
+        "onboarding.goal",
+        "onboarding.goal must be a non-empty string"
+      );
+    }
+    if (typeof onboarding.framing !== "string" || onboarding.framing.trim() === "") {
+      add(
+        "onboarding-framing-empty",
+        "onboarding.framing",
+        "onboarding.framing must be a non-empty string"
+      );
+    }
+    if (!Array.isArray(onboarding.collect) || onboarding.collect.length === 0) {
+      add(
+        "onboarding-collect-empty",
+        "onboarding.collect",
+        "onboarding.collect must contain at least one structured target"
+      );
+    }
+    const expertise = onboarding.expertise;
+    for (const [field, values] of [
+      ["starters", expertise?.starters],
+      ["blindSpots", expertise?.blindSpots]
+    ]) {
+      if (values !== void 0 && (!Array.isArray(values) || values.some(
+        (value) => typeof value !== "string" || value.trim() === ""
+      ))) {
+        add(
+          "onboarding-expertise-invalid",
+          `onboarding.expertise.${field}`,
+          `onboarding.expertise.${field} must contain only non-empty strings`
+        );
+      }
+    }
+    if (expertise?.bar !== void 0 && (typeof expertise.bar !== "string" || expertise.bar.trim() === "")) {
+      add(
+        "onboarding-expertise-invalid",
+        "onboarding.expertise.bar",
+        "onboarding.expertise.bar must be a non-empty string"
+      );
+    }
+    if (onboarding.openingQuestions !== void 0 && (!Array.isArray(onboarding.openingQuestions) || onboarding.openingQuestions.some(
+      (question) => typeof question !== "string" || question.trim() === ""
+    ))) {
+      add(
+        "onboarding-opening-questions-invalid",
+        "onboarding.openingQuestions",
+        "onboarding.openingQuestions must contain only non-empty strings"
+      );
+    }
+    if (onboarding.doneWhen !== void 0 && (typeof onboarding.doneWhen !== "string" || onboarding.doneWhen.trim() === "")) {
+      add(
+        "onboarding-done-when-invalid",
+        "onboarding.doneWhen",
+        "onboarding.doneWhen must be a non-empty string"
+      );
+    }
+  }
+  for (const c of onboarding?.collect || []) {
+    if (typeof c.what !== "string" || c.what.trim() === "") {
+      add(
+        "onboarding-collect-what-empty",
+        `onboarding.collect.${c.profileSlug}.what`,
+        `onboarding.collect target "${c.profileSlug}" must describe what to capture`
+      );
+    }
+    if (c.keyFields !== void 0 && (!Array.isArray(c.keyFields) || c.keyFields.some(
+      (field) => typeof field !== "string" || field.trim() === ""
+    ))) {
+      add(
+        "onboarding-collect-key-fields-invalid",
+        `onboarding.collect.${c.profileSlug}.keyFields`,
+        `onboarding.collect target "${c.profileSlug}" keyFields must contain only non-empty strings`
+      );
+    }
     if (!known(c.profileSlug))
       add(
         "onboarding-ref-unknown",
@@ -29038,11 +29696,27 @@ 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 +29762,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 +29784,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 +29818,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 +29833,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 +29905,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 +30038,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 +30112,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 +30122,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 +30141,7 @@ export {
   conceptTerm,
   domainLabel,
   findConceptViolations,
+  flowValidationErrorMessage,
   formatConceptViolations,
   getWorkspaceTemplate,
   groupByDomain,
@@ -29390,10 +30151,12 @@ export {
   listPublicTemplates,
   listWorkspaceTemplates,
   mergeCatalog,
+  normalizeTemplateLayout,
   rowToRemoteEntry,
   splitBentoBlocks,
   toPackageDefinition,
   toWorkspaceDefinition,
+  validateFlowDefinition,
   validateTemplate
 };
 //# sourceMappingURL=index.js.map