@withpotter/lib 0.13.0-next.101

package/dist/intents/use-intent-config.js

@@ -0,0 +1,91 @@
+"use client";
+import { useMemo } from "react";
+import { useSearchParams } from "next/navigation";
+import { useAuth } from "../auth-context";
+import { defaultCommerceConfig, getIntentConfig } from "./registry";
+import { useIntentScope } from "./intent-scope";
+import { resolveScopedConfig } from "./scoped-config";
+import { resolveTenantIntentConfigs } from "./resolve-tenant-intents";
+import {
+  applyOrderShellOverrides,
+  getOrderShellOverrides
+} from "./operating-shell";
+const INTENT_STORAGE_KEY = "potter:activeIntent";
+function useIntentConfig() {
+  const { tenant } = useAuth();
+  const searchParams = useSearchParams();
+  const scope = useIntentScope();
+  return useMemo(() => {
+    const settings = tenant?.settings;
+    const overrides = getOrderShellOverrides(settings);
+    const configs = resolveTenantIntentConfigs(settings).map(
+      (c) => applyOrderShellOverrides(c, overrides)
+    );
+    if (scope) {
+      const registry = getIntentConfig(scope);
+      const scoped2 = resolveScopedConfig(
+        configs,
+        scope,
+        registry && applyOrderShellOverrides(registry, overrides)
+      );
+      if (scoped2) return scoped2;
+    }
+    if (configs.length === 0) {
+      return {
+        mode: "single",
+        primary: applyOrderShellOverrides(defaultCommerceConfig, overrides),
+        all: [applyOrderShellOverrides(defaultCommerceConfig, overrides)],
+        activeKeys: [defaultCommerceConfig.key],
+        active: [applyOrderShellOverrides(defaultCommerceConfig, overrides)],
+        hasArchetype: false,
+        isAllIntents: false
+      };
+    }
+    if (configs.length === 1) {
+      return {
+        mode: "single",
+        primary: configs[0],
+        all: configs,
+        // A single-archetype business is always "scoped" to its one archetype.
+        // Saying otherwise would strip the intent filter from its queries and
+        // pull in content it never assigned an intent to.
+        activeKeys: [configs[0].key],
+        active: configs,
+        hasArchetype: configs[0].key !== defaultCommerceConfig.key,
+        isAllIntents: false
+      };
+    }
+    const intentParam = searchParams.get("intent");
+    const requested = (intentParam ?? "").split(",").map((key) => key.trim()).filter(Boolean);
+    const scoped = requested.map((key) => configs.find((c) => c.key === key)).filter((c) => !!c);
+    let overrideConfig = scoped[0];
+    if (scoped.length) {
+      if (typeof sessionStorage !== "undefined")
+        sessionStorage.setItem(
+          INTENT_STORAGE_KEY,
+          scoped.map((c) => c.key).join(",")
+        );
+    } else if (typeof sessionStorage !== "undefined") {
+      const stored = sessionStorage.getItem(INTENT_STORAGE_KEY);
+      if (stored) {
+        const first = stored.split(",")[0];
+        overrideConfig = configs.find((c) => c.key === first);
+      }
+    }
+    return {
+      mode: "multi",
+      primary: overrideConfig ?? configs[0],
+      all: configs,
+      activeKeys: scoped.length ? scoped.map((c) => c.key) : configs.map((c) => c.key),
+      active: scoped.length ? scoped : configs,
+      // Several configs only ever come from real archetypes; the fallback is a
+      // set of one.
+      hasArchetype: true,
+      isAllIntents: scoped.length === 0
+    };
+  }, [tenant, searchParams, scope]);
+}
+export {
+  useIntentConfig
+};
+//# sourceMappingURL=use-intent-config.js.map

package/dist/intents/use-intent-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/intents/use-intent-config.ts"],"sourcesContent":["'use client';\n\nimport { useMemo } from 'react';\nimport { useSearchParams } from 'next/navigation';\nimport { useAuth } from '../auth-context';\nimport type { IntentConfig, ResolvedIntentConfig } from './types';\nimport { defaultCommerceConfig, getIntentConfig } from './registry';\nimport { useIntentScope } from './intent-scope';\nimport { resolveScopedConfig } from './scoped-config';\nimport { resolveTenantIntentConfigs } from './resolve-tenant-intents';\nimport {\n  applyOrderShellOverrides,\n  getOrderShellOverrides,\n} from './operating-shell';\n\nconst INTENT_STORAGE_KEY = 'potter:activeIntent';\n\n/**\n * Resolves the active intent configuration for the current tenant.\n *\n * Resolution order:\n *   1. tenant.settings.operatingModel profiles → derive active intents\n *   2. tenant.settings.selectedIntents → backward compatibility when no operating model exists\n *   3. If no intents, infer from tenant.settings.enabledBehaviors\n *   4. If still nothing, return defaultCommerceConfig\n *\n * The tenant's operating shell (fulfillment/shipping visibility) is folded\n * onto each config's orderDisplay here, so every consumer reads a single\n * pre-merged config — no separate useOperatingModel hook or per-page merge.\n *\n * In multi-intent mode, the primary config is determined by:\n *   1. ?intent= query param (if present, also persisted to sessionStorage)\n *   2. sessionStorage (set by previous navigation)\n *   3. First config (default)\n */\nexport function useIntentConfig(): ResolvedIntentConfig {\n  const { tenant } = useAuth();\n  const searchParams = useSearchParams();\n  const scope = useIntentScope();\n\n  return useMemo(() => {\n    const settings = tenant?.settings as Record<string, unknown> | undefined;\n    const overrides = getOrderShellOverrides(settings);\n    const configs = resolveTenantIntentConfigs(settings).map((c) =>\n      applyOrderShellOverrides(c, overrides),\n    );\n\n    // A composed route is one intent's screen, whatever the URL or the\n    // business's other archetypes say.\n    if (scope) {\n      const registry = getIntentConfig(scope);\n      const scoped = resolveScopedConfig(\n        configs,\n        scope,\n        registry && applyOrderShellOverrides(registry, overrides),\n      );\n      if (scoped) return scoped;\n    }\n\n    if (configs.length === 0) {\n      return {\n        mode: 'single' as const,\n        primary: applyOrderShellOverrides(defaultCommerceConfig, overrides),\n        all: [applyOrderShellOverrides(defaultCommerceConfig, overrides)],\n        activeKeys: [defaultCommerceConfig.key],\n        active: [applyOrderShellOverrides(defaultCommerceConfig, overrides)],\n        hasArchetype: false,\n        isAllIntents: false,\n      };\n    }\n\n    // Single intent — return directly\n    if (configs.length === 1) {\n      return {\n        mode: 'single' as const,\n        primary: configs[0],\n        all: configs,\n        // A single-archetype business is always \"scoped\" to its one archetype.\n        // Saying otherwise would strip the intent filter from its queries and\n        // pull in content it never assigned an intent to.\n        activeKeys: [configs[0].key],\n        active: configs,\n        hasArchetype: configs[0].key !== defaultCommerceConfig.key,\n        isAllIntents: false,\n      };\n    }\n\n    /**\n     * `?intent=` narrows to a LIST, not to one archetype.\n     *\n     * A row several archetypes share — a restaurant's Menu, fed by dine-in and\n     * takeaway — means \"these two\", which is neither one archetype nor all of\n     * them. It used to be written as no param at all, so the screen had to\n     * reconstruct what the merchant meant from an absence: `/dashboard/catalog`\n     * had to stand for the Menu row AND for the Catalog hub above it that\n     * genuinely means everything. They are different views and the URL could\n     * not tell them apart, so clicking the hub filtered to the menu.\n     *\n     * One key still works and is the common case. Unknown keys are dropped\n     * rather than trusted, so a stale link narrows to what still exists instead\n     * of to nothing.\n     */\n    const intentParam = searchParams.get('intent');\n    const requested = (intentParam ?? '')\n      .split(',')\n      .map((key) => key.trim())\n      .filter(Boolean);\n    const scoped = requested\n      .map((key) => configs.find((c) => c.key === key))\n      .filter((c): c is IntentConfig => !!c);\n\n    let overrideConfig: IntentConfig | undefined = scoped[0];\n\n    if (scoped.length) {\n      // Persist so child pages inherit without needing the param.\n      if (typeof sessionStorage !== 'undefined')\n        sessionStorage.setItem(\n          INTENT_STORAGE_KEY,\n          scoped.map((c) => c.key).join(','),\n        );\n    } else if (typeof sessionStorage !== 'undefined') {\n      const stored = sessionStorage.getItem(INTENT_STORAGE_KEY);\n      if (stored) {\n        // Only the first key steers wording; the rest were the filter, and a\n        // filter must not survive into a page the merchant navigated to fresh.\n        const first = stored.split(',')[0];\n        overrideConfig = configs.find((c) => c.key === first);\n      }\n    }\n\n    // Only an explicit ?intent= narrows the view. sessionStorage still steers\n    // `primary` so a detail page inherits its parent's wording, but it must not\n    // silently filter a list — that reads as data having gone missing.\n    return {\n      mode: 'multi' as const,\n      primary: overrideConfig ?? configs[0],\n      all: configs,\n      activeKeys: scoped.length\n        ? scoped.map((c) => c.key)\n        : configs.map((c) => c.key),\n      active: scoped.length ? scoped : configs,\n      // Several configs only ever come from real archetypes; the fallback is a\n      // set of one.\n      hasArchetype: true,\n      isAllIntents: scoped.length === 0,\n    };\n  }, [tenant, searchParams, scope]);\n}\n"],"mappings":";AAEA,SAAS,eAAe;AACxB,SAAS,uBAAuB;AAChC,SAAS,eAAe;AAExB,SAAS,uBAAuB,uBAAuB;AACvD,SAAS,sBAAsB;AAC/B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAC3C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,MAAM,qBAAqB;AAoBpB,SAAS,kBAAwC;AACtD,QAAM,EAAE,OAAO,IAAI,QAAQ;AAC3B,QAAM,eAAe,gBAAgB;AACrC,QAAM,QAAQ,eAAe;AAE7B,SAAO,QAAQ,MAAM;AACnB,UAAM,WAAW,QAAQ;AACzB,UAAM,YAAY,uBAAuB,QAAQ;AACjD,UAAM,UAAU,2BAA2B,QAAQ,EAAE;AAAA,MAAI,CAAC,MACxD,yBAAyB,GAAG,SAAS;AAAA,IACvC;AAIA,QAAI,OAAO;AACT,YAAM,WAAW,gBAAgB,KAAK;AACtC,YAAMA,UAAS;AAAA,QACb;AAAA,QACA;AAAA,QACA,YAAY,yBAAyB,UAAU,SAAS;AAAA,MAC1D;AACA,UAAIA,QAAQ,QAAOA;AAAA,IACrB;AAEA,QAAI,QAAQ,WAAW,GAAG;AACxB,aAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS,yBAAyB,uBAAuB,SAAS;AAAA,QAClE,KAAK,CAAC,yBAAyB,uBAAuB,SAAS,CAAC;AAAA,QAChE,YAAY,CAAC,sBAAsB,GAAG;AAAA,QACtC,QAAQ,CAAC,yBAAyB,uBAAuB,SAAS,CAAC;AAAA,QACnE,cAAc;AAAA,QACd,cAAc;AAAA,MAChB;AAAA,IACF;AAGA,QAAI,QAAQ,WAAW,GAAG;AACxB,aAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS,QAAQ,CAAC;AAAA,QAClB,KAAK;AAAA;AAAA;AAAA;AAAA,QAIL,YAAY,CAAC,QAAQ,CAAC,EAAE,GAAG;AAAA,QAC3B,QAAQ;AAAA,QACR,cAAc,QAAQ,CAAC,EAAE,QAAQ,sBAAsB;AAAA,QACvD,cAAc;AAAA,MAChB;AAAA,IACF;AAiBA,UAAM,cAAc,aAAa,IAAI,QAAQ;AAC7C,UAAM,aAAa,eAAe,IAC/B,MAAM,GAAG,EACT,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC,EACvB,OAAO,OAAO;AACjB,UAAM,SAAS,UACZ,IAAI,CAAC,QAAQ,QAAQ,KAAK,CAAC,MAAM,EAAE,QAAQ,GAAG,CAAC,EAC/C,OAAO,CAAC,MAAyB,CAAC,CAAC,CAAC;AAEvC,QAAI,iBAA2C,OAAO,CAAC;AAEvD,QAAI,OAAO,QAAQ;AAEjB,UAAI,OAAO,mBAAmB;AAC5B,uBAAe;AAAA,UACb;AAAA,UACA,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,GAAG;AAAA,QACnC;AAAA,IACJ,WAAW,OAAO,mBAAmB,aAAa;AAChD,YAAM,SAAS,eAAe,QAAQ,kBAAkB;AACxD,UAAI,QAAQ;AAGV,cAAM,QAAQ,OAAO,MAAM,GAAG,EAAE,CAAC;AACjC,yBAAiB,QAAQ,KAAK,CAAC,MAAM,EAAE,QAAQ,KAAK;AAAA,MACtD;AAAA,IACF;AAKA,WAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS,kBAAkB,QAAQ,CAAC;AAAA,MACpC,KAAK;AAAA,MACL,YAAY,OAAO,SACf,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,IACvB,QAAQ,IAAI,CAAC,MAAM,EAAE,GAAG;AAAA,MAC5B,QAAQ,OAAO,SAAS,SAAS;AAAA;AAAA;AAAA,MAGjC,cAAc;AAAA,MACd,cAAc,OAAO,WAAW;AAAA,IAClC;AAAA,EACF,GAAG,CAAC,QAAQ,cAAc,KAAK,CAAC;AAClC;","names":["scoped"]}

package/dist/intents/use-intent-nav-rows.d.ts

@@ -0,0 +1,26 @@
+import type { LucideIcon } from 'lucide-react';
+export interface IntentNavRow {
+    id: string;
+    label: string;
+    icon: LucideIcon;
+    href: string;
+    /** The archetype this row is scoped to, or null when it covers them all. */
+    intentKey: string | null;
+}
+/**
+ * The rows this business's sidebar shows for its archetypes, collapsed.
+ *
+ * The sidebar is not the only surface that lists them — the mobile Operations
+ * hub does too, and it was walking each config's `navigation.groups` itself:
+ * deduping on item id so the first archetype's wording won a screen they all
+ * share ("Kitchen Orders" for a restaurant's dine-in covers), skipping each
+ * config's first group by index, and resolving icons through a map that
+ * silently returns a box for any name missing from it. The sidebar stopped
+ * doing all of that when collapsing landed. This is how another surface
+ * inherits it rather than growing a second opinion.
+ *
+ * Permission and behavior gating is deliberately NOT here: it needs the team
+ * membership request, and the sidebar's builder already owns it. Callers that
+ * need gated rows should use the sidebar's groups.
+ */
+export declare function useIntentNavRows(): IntentNavRow[];

package/dist/intents/use-intent-nav-rows.js

@@ -0,0 +1,49 @@
+"use client";
+import { useMemo } from "react";
+import { useIntentConfig } from "./use-intent-config";
+import { INTENT_NAV_DEFINITIONS } from "./intent-nav";
+import { decideSharedNav, navDecisionKey } from "./collapse-shared-nav";
+function hrefOf(config, itemId) {
+  for (const group of config.navigation?.groups ?? []) {
+    const found = group.items.find((item) => item.id === itemId);
+    if (found) return found.href;
+  }
+  return void 0;
+}
+function useIntentNavRows() {
+  const config = useIntentConfig();
+  return useMemo(() => {
+    const isMulti = config.mode === "multi";
+    const configs = isMulti ? config.all : [config.primary];
+    const byKey = new Map(configs.map((c) => [c.key, c]));
+    const definitions = INTENT_NAV_DEFINITIONS.filter((d) => byKey.has(d.key));
+    const decisions = decideSharedNav(
+      definitions,
+      isMulti ? "multi" : "single"
+    );
+    const rows = [];
+    for (const definition of definitions) {
+      const intentConfig = byKey.get(definition.key);
+      if (!intentConfig) continue;
+      for (const item of definition.items) {
+        const decision = decisions.get(navDecisionKey(definition.key, item.id));
+        if (!decision?.emit) continue;
+        const href = hrefOf(intentConfig, item.id);
+        if (!href) continue;
+        const scoped = isMulti && !decision.unscoped;
+        rows.push({
+          id: item.id,
+          label: decision.label,
+          icon: item.icon,
+          href: scoped ? `${href}?intent=${definition.key}` : href.split("?")[0],
+          intentKey: scoped ? definition.key : null
+        });
+      }
+    }
+    return rows;
+  }, [config]);
+}
+export {
+  useIntentNavRows
+};
+//# sourceMappingURL=use-intent-nav-rows.js.map

package/dist/intents/use-intent-nav-rows.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/intents/use-intent-nav-rows.ts"],"sourcesContent":["'use client';\n\nimport { useMemo } from 'react';\nimport type { LucideIcon } from 'lucide-react';\nimport { useIntentConfig } from './use-intent-config';\nimport { INTENT_NAV_DEFINITIONS } from './intent-nav';\nimport { decideSharedNav, navDecisionKey } from './collapse-shared-nav';\nimport type { IntentConfig } from './types';\n\nexport interface IntentNavRow {\n  id: string;\n  label: string;\n  icon: LucideIcon;\n  href: string;\n  /** The archetype this row is scoped to, or null when it covers them all. */\n  intentKey: string | null;\n}\n\nfunction hrefOf(config: IntentConfig, itemId: string): string | undefined {\n  for (const group of config.navigation?.groups ?? []) {\n    const found = group.items.find((item) => item.id === itemId);\n    if (found) return found.href;\n  }\n  return undefined;\n}\n\n/**\n * The rows this business's sidebar shows for its archetypes, collapsed.\n *\n * The sidebar is not the only surface that lists them — the mobile Operations\n * hub does too, and it was walking each config's `navigation.groups` itself:\n * deduping on item id so the first archetype's wording won a screen they all\n * share (\"Kitchen Orders\" for a restaurant's dine-in covers), skipping each\n * config's first group by index, and resolving icons through a map that\n * silently returns a box for any name missing from it. The sidebar stopped\n * doing all of that when collapsing landed. This is how another surface\n * inherits it rather than growing a second opinion.\n *\n * Permission and behavior gating is deliberately NOT here: it needs the team\n * membership request, and the sidebar's builder already owns it. Callers that\n * need gated rows should use the sidebar's groups.\n */\nexport function useIntentNavRows(): IntentNavRow[] {\n  const config = useIntentConfig();\n\n  return useMemo(() => {\n    const isMulti = config.mode === 'multi';\n    const configs = isMulti ? config.all : [config.primary];\n    const byKey = new Map(configs.map((c) => [c.key, c]));\n    const definitions = INTENT_NAV_DEFINITIONS.filter((d) => byKey.has(d.key));\n    const decisions = decideSharedNav(\n      definitions,\n      isMulti ? 'multi' : 'single',\n    );\n\n    const rows: IntentNavRow[] = [];\n    for (const definition of definitions) {\n      const intentConfig = byKey.get(definition.key);\n      if (!intentConfig) continue;\n\n      for (const item of definition.items) {\n        const decision = decisions.get(navDecisionKey(definition.key, item.id));\n        if (!decision?.emit) continue;\n\n        const href = hrefOf(intentConfig, item.id);\n        if (!href) continue;\n        // Unscoped means \"all of them\", so it must not carry one archetype's\n        // ?intent= — that is what makes the screen it opens narrow itself.\n        const scoped = isMulti && !decision.unscoped;\n        rows.push({\n          id: item.id,\n          label: decision.label,\n          icon: item.icon,\n          href: scoped\n            ? `${href}?intent=${definition.key}`\n            : href.split('?')[0],\n          intentKey: scoped ? definition.key : null,\n        });\n      }\n    }\n\n    return rows;\n  }, [config]);\n}\n"],"mappings":";AAEA,SAAS,eAAe;AAExB,SAAS,uBAAuB;AAChC,SAAS,8BAA8B;AACvC,SAAS,iBAAiB,sBAAsB;AAYhD,SAAS,OAAO,QAAsB,QAAoC;AACxE,aAAW,SAAS,OAAO,YAAY,UAAU,CAAC,GAAG;AACnD,UAAM,QAAQ,MAAM,MAAM,KAAK,CAAC,SAAS,KAAK,OAAO,MAAM;AAC3D,QAAI,MAAO,QAAO,MAAM;AAAA,EAC1B;AACA,SAAO;AACT;AAkBO,SAAS,mBAAmC;AACjD,QAAM,SAAS,gBAAgB;AAE/B,SAAO,QAAQ,MAAM;AACnB,UAAM,UAAU,OAAO,SAAS;AAChC,UAAM,UAAU,UAAU,OAAO,MAAM,CAAC,OAAO,OAAO;AACtD,UAAM,QAAQ,IAAI,IAAI,QAAQ,IAAI,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AACpD,UAAM,cAAc,uBAAuB,OAAO,CAAC,MAAM,MAAM,IAAI,EAAE,GAAG,CAAC;AACzE,UAAM,YAAY;AAAA,MAChB;AAAA,MACA,UAAU,UAAU;AAAA,IACtB;AAEA,UAAM,OAAuB,CAAC;AAC9B,eAAW,cAAc,aAAa;AACpC,YAAM,eAAe,MAAM,IAAI,WAAW,GAAG;AAC7C,UAAI,CAAC,aAAc;AAEnB,iBAAW,QAAQ,WAAW,OAAO;AACnC,cAAM,WAAW,UAAU,IAAI,eAAe,WAAW,KAAK,KAAK,EAAE,CAAC;AACtE,YAAI,CAAC,UAAU,KAAM;AAErB,cAAM,OAAO,OAAO,cAAc,KAAK,EAAE;AACzC,YAAI,CAAC,KAAM;AAGX,cAAM,SAAS,WAAW,CAAC,SAAS;AACpC,aAAK,KAAK;AAAA,UACR,IAAI,KAAK;AAAA,UACT,OAAO,SAAS;AAAA,UAChB,MAAM,KAAK;AAAA,UACX,MAAM,SACF,GAAG,IAAI,WAAW,WAAW,GAAG,KAChC,KAAK,MAAM,GAAG,EAAE,CAAC;AAAA,UACrB,WAAW,SAAS,WAAW,MAAM;AAAA,QACvC,CAAC;AAAA,MACH;AAAA,IACF;AAEA,WAAO;AAAA,EACT,GAAG,CAAC,MAAM,CAAC;AACb;","names":[]}

package/dist/intents/use-resource-label.d.ts

@@ -0,0 +1,10 @@
+import type { EntityLabel } from './types';
+/**
+ * What this business calls the thing a booking occupies: a court, a table, a
+ * room, a stylist, a property.
+ *
+ * The resolution lives in `useEntityLabel` now, which does the same job for all
+ * four renameable nouns. This stays because "resource" is the slot most surfaces
+ * name, and reading `useResourceLabel()` at the call site says what it means.
+ */
+export declare function useResourceLabel(): EntityLabel;

package/dist/intents/use-resource-label.js

@@ -0,0 +1,9 @@
+"use client";
+import { useEntityLabel } from "./use-entity-label";
+function useResourceLabel() {
+  return useEntityLabel("resource");
+}
+export {
+  useResourceLabel
+};
+//# sourceMappingURL=use-resource-label.js.map

package/dist/intents/use-resource-label.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/intents/use-resource-label.ts"],"sourcesContent":["'use client';\n\nimport { useEntityLabel } from './use-entity-label';\nimport type { EntityLabel } from './types';\n\n/**\n * What this business calls the thing a booking occupies: a court, a table, a\n * room, a stylist, a property.\n *\n * The resolution lives in `useEntityLabel` now, which does the same job for all\n * four renameable nouns. This stays because \"resource\" is the slot most surfaces\n * name, and reading `useResourceLabel()` at the call site says what it means.\n */\nexport function useResourceLabel(): EntityLabel {\n  return useEntityLabel('resource');\n}\n"],"mappings":";AAEA,SAAS,sBAAsB;AAWxB,SAAS,mBAAgC;AAC9C,SAAO,eAAe,UAAU;AAClC;","names":[]}

package/dist/intents/use-row-noun.d.ts

@@ -0,0 +1,19 @@
+import { useIntentConfig } from './use-intent-config';
+/**
+ * The two facts every caller of `resolveRowNoun` needs, read once.
+ *
+ * The resolvers stay pure so the combinations can be asserted without
+ * rendering, and they take `renamed` as an argument rather than reaching for
+ * it. That is right for testing and wrong for call sites: three screens each
+ * reading `tenant.settings.moduleLabels.inventory` is three chances to forget,
+ * and forgetting means the merchant's own word loses to the archetype's on
+ * exactly the screens this feature touches.
+ *
+ * `inventory` is the key an item rename is stored under — see `MODULE_KEY` in
+ * `use-entity-label.ts`, and the long note there on why a rename is keyed to
+ * the SCREEN rather than the nav item id.
+ */
+export declare function useRowNounContext(): {
+    configs: ReturnType<typeof useIntentConfig>['all'];
+    renamed: boolean;
+};

package/dist/intents/use-row-noun.js

@@ -0,0 +1,13 @@
+"use client";
+import { useAuth } from "../auth-context";
+import { useIntentConfig } from "./use-intent-config";
+function useRowNounContext() {
+  const { tenant } = useAuth();
+  const { all } = useIntentConfig();
+  const moduleLabels = tenant?.settings?.moduleLabels;
+  return { configs: all, renamed: !!moduleLabels?.inventory };
+}
+export {
+  useRowNounContext
+};
+//# sourceMappingURL=use-row-noun.js.map

package/dist/intents/use-row-noun.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/intents/use-row-noun.ts"],"sourcesContent":["'use client';\n\nimport { useAuth } from '../auth-context';\nimport { useIntentConfig } from './use-intent-config';\n\n/**\n * The two facts every caller of `resolveRowNoun` needs, read once.\n *\n * The resolvers stay pure so the combinations can be asserted without\n * rendering, and they take `renamed` as an argument rather than reaching for\n * it. That is right for testing and wrong for call sites: three screens each\n * reading `tenant.settings.moduleLabels.inventory` is three chances to forget,\n * and forgetting means the merchant's own word loses to the archetype's on\n * exactly the screens this feature touches.\n *\n * `inventory` is the key an item rename is stored under — see `MODULE_KEY` in\n * `use-entity-label.ts`, and the long note there on why a rename is keyed to\n * the SCREEN rather than the nav item id.\n */\nexport function useRowNounContext(): {\n  configs: ReturnType<typeof useIntentConfig>['all'];\n  renamed: boolean;\n} {\n  const { tenant } = useAuth();\n  const { all } = useIntentConfig();\n\n  const moduleLabels = tenant?.settings?.moduleLabels as\n    | Record<string, string>\n    | undefined;\n\n  return { configs: all, renamed: !!moduleLabels?.inventory };\n}\n"],"mappings":";AAEA,SAAS,eAAe;AACxB,SAAS,uBAAuB;AAgBzB,SAAS,oBAGd;AACA,QAAM,EAAE,OAAO,IAAI,QAAQ;AAC3B,QAAM,EAAE,IAAI,IAAI,gBAAgB;AAEhC,QAAM,eAAe,QAAQ,UAAU;AAIvC,SAAO,EAAE,SAAS,KAAK,SAAS,CAAC,CAAC,cAAc,UAAU;AAC5D;","names":[]}

package/dist/intents/use-screen-title.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The name of the screen you are on, taken from the row that opened it.
+ *
+ * Pages should not pass a title to `ListPage` when the nav already names the
+ * destination — omitting it is what makes the two impossible to drift apart.
+ * Pass one only for screens the intent nav never points at (Blog, Discounts,
+ * Settings pages), where there is no row to inherit from.
+ */
+export declare function useScreenTitle(): string | undefined;

package/dist/intents/use-screen-title.js

@@ -0,0 +1,25 @@
+"use client";
+import { usePathname } from "@withpotter/lib/use-pathname";
+import { useMemo } from "react";
+import { useAuth } from "@withpotter/lib/auth-context";
+import { useIntentConfig } from "./use-intent-config";
+import { resolveScreenTitle } from "./screen-title";
+function useScreenTitle() {
+  const pathname = usePathname();
+  const { tenant } = useAuth();
+  const config = useIntentConfig();
+  const moduleLabels = tenant?.settings?.moduleLabels;
+  return useMemo(
+    () => resolveScreenTitle({
+      configs: config.all,
+      mode: config.mode,
+      pathname: pathname ?? "",
+      moduleLabels
+    }),
+    [config.all, config.mode, pathname, moduleLabels]
+  );
+}
+export {
+  useScreenTitle
+};
+//# sourceMappingURL=use-screen-title.js.map

package/dist/intents/use-screen-title.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/intents/use-screen-title.ts"],"sourcesContent":["'use client';\n\nimport { usePathname } from '@withpotter/lib/use-pathname';\nimport { useMemo } from 'react';\nimport { useAuth } from '@withpotter/lib/auth-context';\nimport { useIntentConfig } from './use-intent-config';\nimport { resolveScreenTitle } from './screen-title';\n\n/**\n * The name of the screen you are on, taken from the row that opened it.\n *\n * Pages should not pass a title to `ListPage` when the nav already names the\n * destination — omitting it is what makes the two impossible to drift apart.\n * Pass one only for screens the intent nav never points at (Blog, Discounts,\n * Settings pages), where there is no row to inherit from.\n */\nexport function useScreenTitle(): string | undefined {\n  const pathname = usePathname();\n  const { tenant } = useAuth();\n  const config = useIntentConfig();\n\n  const moduleLabels = tenant?.settings?.moduleLabels as\n    Record<string, string> | undefined;\n\n  return useMemo(\n    () =>\n      resolveScreenTitle({\n        configs: config.all,\n        mode: config.mode,\n        pathname: pathname ?? '',\n        moduleLabels,\n      }),\n    [config.all, config.mode, pathname, moduleLabels],\n  );\n}\n"],"mappings":";AAEA,SAAS,mBAAmB;AAC5B,SAAS,eAAe;AACxB,SAAS,eAAe;AACxB,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AAU5B,SAAS,iBAAqC;AACnD,QAAM,WAAW,YAAY;AAC7B,QAAM,EAAE,OAAO,IAAI,QAAQ;AAC3B,QAAM,SAAS,gBAAgB;AAE/B,QAAM,eAAe,QAAQ,UAAU;AAGvC,SAAO;AAAA,IACL,MACE,mBAAmB;AAAA,MACjB,SAAS,OAAO;AAAA,MAChB,MAAM,OAAO;AAAA,MACb,UAAU,YAAY;AAAA,MACtB;AAAA,IACF,CAAC;AAAA,IACH,CAAC,OAAO,KAAK,OAAO,MAAM,UAAU,YAAY;AAAA,EAClD;AACF;","names":[]}

package/dist/intents/what-it-adds.d.ts

@@ -0,0 +1,70 @@
+/**
+ * What a business model puts in the sidebar — asked before it is switched on,
+ * not after.
+ *
+ * Adding was the one direction on this page with nothing between the press and
+ * the consequence. Removing has carried a confirm naming the cost since the
+ * settings screen this page replaced, on the argument that dropping a model
+ * takes modules out of the sidebar. That argument is symmetric and only half
+ * of it was written down: adding PUTS modules in, and a merchant curious
+ * enough to press a card is entitled to know what their nav will look like
+ * afterwards.
+ *
+ * A LINE ON THE CARD, NOT A SECOND CONFIRM. A dialog between "I want this" and
+ * having it is the shape that makes an app store feel like a procurement
+ * system, and the panel that fires afterwards already exists to say what you
+ * can now do. This is the same information a beat earlier, where it can change
+ * a decision rather than explain one.
+ *
+ * ── WHAT IT COUNTS ──
+ *
+ * The rows an archetype declares, which is the honest answer to "what appears":
+ * `build-nav-groups` reads exactly these labels. Minus whatever the business
+ * already has from the models it is running, because "Adds Orders" is a lie to
+ * a shop that has had an Orders row since the day it signed up — and it is the
+ * shared rows (Orders, Collections, Invoices, Loyalty) that repeat across
+ * archetypes, so without the subtraction most cards would list the same four
+ * things and none of them would be news.
+ *
+ * That makes the line a function of the merchant's current selection, which is
+ * why it is computed here rather than baked into `business-intents` beside the
+ * descriptions.
+ *
+ * IN `lib/intents` RATHER THAN BESIDE THE PAGE, because the search panel asks
+ * the same question from `components/` — a route folder importing into a
+ * shared component is a layering inversion, and this is registry logic either
+ * way: it reads the archetype configs and nothing about a screen.
+ */
+export declare function navRowsFor(intentKey: string, 
+/**
+ * Drop the rows every archetype declares — Collections, Invoices, Loyalty,
+ * Hours. `generic` is the configs' own word for "shared platform capability
+ * rather than something this model brings", and it is the difference
+ * between a row that identifies a business model and one that cannot.
+ *
+ * It matters wherever the rows are used to MATCH rather than to describe:
+ * searching "invoice" offered a shop Take bookings and Rent out a property,
+ * because both configs list an Invoices row, as does everything else. A
+ * suggestion that fires on a word shared by every archetype is noise with a
+ * heading on it.
+ */
+{ includeGeneric }?: {
+    includeGeneric?: boolean;
+}): string[];
+/** The rows this model would add that the current selection does not already carry. */
+export declare function rowsAddedBy(intentKey: string, current: string[]): string[];
+/**
+ * Everything about a model a search should be able to find it by.
+ *
+ * "table" has to find Run a dine-in service. It did not, and could not: the
+ * cards were matched on their own three strings — name, description, verb
+ * phrase — none of which say table, while the archetype has carried a nav row
+ * called Tables the whole time. A merchant searching a library of capabilities
+ * types the noun they have in their head, and that noun is far more often the
+ * screen they want than our name for the business model that owns it.
+ *
+ * The group heading goes in for the same reason: somebody typing "book" should
+ * land on the three cards filed under "Let people book your time or your
+ * space", including the two whose own names never say book.
+ */
+export declare function searchTextFor(intentKey: string, groupLabel: string): string;

package/dist/intents/what-it-adds.js

@@ -0,0 +1,29 @@
+import { intentRegistry } from "./registry";
+function navRowsFor(intentKey, { includeGeneric = true } = {}) {
+  const config = intentRegistry[intentKey];
+  if (!config) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const group of config.navigation.groups) {
+    for (const item of group.items) {
+      if (!includeGeneric && item.generic) continue;
+      if (seen.has(item.label)) continue;
+      seen.add(item.label);
+      out.push(item.label);
+    }
+  }
+  return out;
+}
+function rowsAddedBy(intentKey, current) {
+  const have = new Set(current.flatMap((key) => navRowsFor(key)));
+  return navRowsFor(intentKey).filter((label) => !have.has(label));
+}
+function searchTextFor(intentKey, groupLabel) {
+  return [groupLabel, ...navRowsFor(intentKey, { includeGeneric: false })].join(" ").toLowerCase();
+}
+export {
+  navRowsFor,
+  rowsAddedBy,
+  searchTextFor
+};
+//# sourceMappingURL=what-it-adds.js.map

package/dist/intents/what-it-adds.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/intents/what-it-adds.ts"],"sourcesContent":["import { intentRegistry } from './registry';\n\n/**\n * What a business model puts in the sidebar — asked before it is switched on,\n * not after.\n *\n * Adding was the one direction on this page with nothing between the press and\n * the consequence. Removing has carried a confirm naming the cost since the\n * settings screen this page replaced, on the argument that dropping a model\n * takes modules out of the sidebar. That argument is symmetric and only half\n * of it was written down: adding PUTS modules in, and a merchant curious\n * enough to press a card is entitled to know what their nav will look like\n * afterwards.\n *\n * A LINE ON THE CARD, NOT A SECOND CONFIRM. A dialog between \"I want this\" and\n * having it is the shape that makes an app store feel like a procurement\n * system, and the panel that fires afterwards already exists to say what you\n * can now do. This is the same information a beat earlier, where it can change\n * a decision rather than explain one.\n *\n * ── WHAT IT COUNTS ──\n *\n * The rows an archetype declares, which is the honest answer to \"what appears\":\n * `build-nav-groups` reads exactly these labels. Minus whatever the business\n * already has from the models it is running, because \"Adds Orders\" is a lie to\n * a shop that has had an Orders row since the day it signed up — and it is the\n * shared rows (Orders, Collections, Invoices, Loyalty) that repeat across\n * archetypes, so without the subtraction most cards would list the same four\n * things and none of them would be news.\n *\n * That makes the line a function of the merchant's current selection, which is\n * why it is computed here rather than baked into `business-intents` beside the\n * descriptions.\n *\n * IN `lib/intents` RATHER THAN BESIDE THE PAGE, because the search panel asks\n * the same question from `components/` — a route folder importing into a\n * shared component is a layering inversion, and this is registry logic either\n * way: it reads the archetype configs and nothing about a screen.\n */\nexport function navRowsFor(\n  intentKey: string,\n  /**\n   * Drop the rows every archetype declares — Collections, Invoices, Loyalty,\n   * Hours. `generic` is the configs' own word for \"shared platform capability\n   * rather than something this model brings\", and it is the difference\n   * between a row that identifies a business model and one that cannot.\n   *\n   * It matters wherever the rows are used to MATCH rather than to describe:\n   * searching \"invoice\" offered a shop Take bookings and Rent out a property,\n   * because both configs list an Invoices row, as does everything else. A\n   * suggestion that fires on a word shared by every archetype is noise with a\n   * heading on it.\n   */\n  { includeGeneric = true }: { includeGeneric?: boolean } = {},\n): string[] {\n  const config = intentRegistry[intentKey];\n  if (!config) return [];\n  const seen = new Set<string>();\n  const out: string[] = [];\n  for (const group of config.navigation.groups) {\n    for (const item of group.items) {\n      if (!includeGeneric && item.generic) continue;\n      if (seen.has(item.label)) continue;\n      seen.add(item.label);\n      out.push(item.label);\n    }\n  }\n  return out;\n}\n\n/** The rows this model would add that the current selection does not already carry. */\nexport function rowsAddedBy(intentKey: string, current: string[]): string[] {\n  const have = new Set(current.flatMap((key) => navRowsFor(key)));\n  return navRowsFor(intentKey).filter((label) => !have.has(label));\n}\n\n/**\n * Everything about a model a search should be able to find it by.\n *\n * \"table\" has to find Run a dine-in service. It did not, and could not: the\n * cards were matched on their own three strings — name, description, verb\n * phrase — none of which say table, while the archetype has carried a nav row\n * called Tables the whole time. A merchant searching a library of capabilities\n * types the noun they have in their head, and that noun is far more often the\n * screen they want than our name for the business model that owns it.\n *\n * The group heading goes in for the same reason: somebody typing \"book\" should\n * land on the three cards filed under \"Let people book your time or your\n * space\", including the two whose own names never say book.\n */\nexport function searchTextFor(intentKey: string, groupLabel: string): string {\n  return [groupLabel, ...navRowsFor(intentKey, { includeGeneric: false })]\n    .join(' ')\n    .toLowerCase();\n}\n"],"mappings":"AAAA,SAAS,sBAAsB;AAuCxB,SAAS,WACd,WAaA,EAAE,iBAAiB,KAAK,IAAkC,CAAC,GACjD;AACV,QAAM,SAAS,eAAe,SAAS;AACvC,MAAI,CAAC,OAAQ,QAAO,CAAC;AACrB,QAAM,OAAO,oBAAI,IAAY;AAC7B,QAAM,MAAgB,CAAC;AACvB,aAAW,SAAS,OAAO,WAAW,QAAQ;AAC5C,eAAW,QAAQ,MAAM,OAAO;AAC9B,UAAI,CAAC,kBAAkB,KAAK,QAAS;AACrC,UAAI,KAAK,IAAI,KAAK,KAAK,EAAG;AAC1B,WAAK,IAAI,KAAK,KAAK;AACnB,UAAI,KAAK,KAAK,KAAK;AAAA,IACrB;AAAA,EACF;AACA,SAAO;AACT;AAGO,SAAS,YAAY,WAAmB,SAA6B;AAC1E,QAAM,OAAO,IAAI,IAAI,QAAQ,QAAQ,CAAC,QAAQ,WAAW,GAAG,CAAC,CAAC;AAC9D,SAAO,WAAW,SAAS,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,KAAK,CAAC;AACjE;AAgBO,SAAS,cAAc,WAAmB,YAA4B;AAC3E,SAAO,CAAC,YAAY,GAAG,WAAW,WAAW,EAAE,gBAAgB,MAAM,CAAC,CAAC,EACpE,KAAK,GAAG,EACR,YAAY;AACjB;","names":[]}

package/dist/intents/workflow-shape.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The whole path an archetype runs, with nothing marked current.
+ *
+ * THE ONE PIECE OF NEW LOGIC. `order-progress.ts` answers "where is THIS
+ * order" — it walks a path and marks one step `current`, which is the right
+ * question on an order detail screen and the wrong one here. A workflow view
+ * has no order in hand; it needs the same paths with no state on them.
+ *
+ * So this is a SPECIMEN, and everything about it is borrowed. The money lane
+ * comes from `resolveMoneyAxis`, the fulfilment lane from `resolveDeliveryAxis`
+ * — both handed the first state on their path purely so they will emit the
+ * whole walk. The status graph comes from `getAllowedOrderTransitions`, the
+ * words on the arrows from `resolveNextAction`, and every label from the
+ * archetype's own `orderDisplay`. Nothing here decides anything a live order
+ * does not already decide the same way, which is the point: if the drawing and
+ * the order ever disagree, the drawing is lying.
+ *
+ * IT REPORTS WHAT IT COULD NOT DRAW rather than drawing it wrong. Three
+ * archetypes carry status vocabularies that are not `OrderStatus` at all —
+ * `send-invoices` (draft/sent/overdue/void), `capture-leads`
+ * (new/converted/spam) and `subscriptions` (active/non_renewing/attention).
+ * `getAllowedOrderTransitions` has no entry for any of them, so they fall to
+ * `DEFAULT_TRANSITIONS`, which shares ZERO keys with what they actually use.
+ * Walking it anyway would produce a confident graph of five stages none of
+ * which that archetype has ever been in. `notes` carries the reason instead and
+ * the lane is simply absent — the same argument as the tile that told every
+ * storefront it had no page for products.
+ */
+export type StageTone = 'start' | 'live' | 'good' | 'end' | 'exit';
+export interface WorkflowStage {
+    /** The status key, which is also the node id within its lane. */
+    key: string;
+    /** The archetype's own word for it. */
+    label: string;
+    tone: StageTone;
+}
+export interface WorkflowEdge {
+    from: string;
+    to: string;
+    /** The button a merchant actually presses to make this move, when there is
+     *  one. Absent where the move is the customer's or the clock's. */
+    verb?: string;
+    /** An escape hatch — cancelled, refunded. Drawn quieter and downward. */
+    exit?: boolean;
+}
+export interface WorkflowLane {
+    key: 'status' | 'money' | 'fulfilment';
+    /** The lane's own heading, in the archetype's words where it has one. */
+    label: string;
+    stages: WorkflowStage[];
+    edges: WorkflowEdge[];
+}
+export interface WorkflowShape {
+    intentKey: string;
+    lanes: WorkflowLane[];
+    /** The first real object, so the drawing can say where it starts. */
+    start: {
+        noun: string;
+        cta: string;
+        blurb: string;
+        href: string;
+    };
+    /** What could not be drawn, and why. Rendered, never swallowed. */
+    notes: string[];
+}
+export declare function resolveWorkflowShape(intentKey: string): WorkflowShape | null;

package/dist/intents/workflow-shape.js

@@ -0,0 +1,151 @@
+import { getIntentConfig } from "./registry";
+import { getAllowedOrderTransitions } from "./order-transitions";
+import {
+  resolveDeliveryAxis,
+  resolveMoneyAxis,
+  resolveNextAction
+} from "./order-progress";
+import { resolveOrderStatusLabel } from "./order-display";
+import { firstObjectFor } from "./archetype-flow";
+const EXITS = ["cancelled", "refunded"];
+const NOT_ORDER_SHAPED = /* @__PURE__ */ new Set([
+  "send-invoices",
+  "capture-leads",
+  "subscriptions"
+]);
+function toneFor(key, index, lastIndex) {
+  if (EXITS.includes(key)) return "exit";
+  if (index === 0) return "start";
+  if (index === lastIndex) return "end";
+  return "live";
+}
+function statusLane(intentKey, orderDisplay, canFulfill) {
+  const seen = /* @__PURE__ */ new Set();
+  const order = [];
+  const exitsSeen = /* @__PURE__ */ new Set();
+  const edges = [];
+  const queue = ["pending"];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (seen.has(current)) continue;
+    seen.add(current);
+    order.push(current);
+    for (const next of getAllowedOrderTransitions(current, intentKey)) {
+      if (seen.has(next) && !EXITS.includes(next)) continue;
+      const exit = EXITS.includes(next);
+      const action = resolveNextAction({
+        status: current,
+        paymentStatus: "paid",
+        fulfillmentStatus: "fulfilled",
+        orderDisplay,
+        intentKey,
+        canFulfill
+      });
+      edges.push({
+        from: current,
+        to: next,
+        exit,
+        // Only when the suggested next action IS this transition; otherwise the
+        // arrow would wear a verb belonging to a different move.
+        verb: !exit && action.key === "advance-status" && action.status === next ? action.label : void 0
+      });
+      if (exit) exitsSeen.add(next);
+      else queue.push(next);
+    }
+  }
+  const forward = order.filter((s) => !EXITS.includes(s));
+  const exits = [...exitsSeen];
+  const stages = [...forward, ...exits].map((key) => ({
+    key,
+    label: resolveOrderStatusLabel(orderDisplay, key),
+    tone: toneFor(key, forward.indexOf(key), forward.length - 1)
+  }));
+  return {
+    key: "status",
+    label: orderDisplay?.statusLabels ? "Order" : "Status",
+    stages,
+    edges
+  };
+}
+function resolveWorkflowShape(intentKey) {
+  const config = getIntentConfig(intentKey);
+  if (!config) return null;
+  const orderDisplay = config.orderDisplay;
+  const notes = [];
+  const lanes = [];
+  if (NOT_ORDER_SHAPED.has(intentKey)) {
+    notes.push(
+      `This one runs on its own states \u2014 ${Object.keys(
+        orderDisplay?.statusLabels ?? {}
+      ).slice(0, 3).join(
+        ", "
+      )} \u2014 which the shared transition map does not describe yet, so its stages are not drawn.`
+    );
+  } else {
+    const canFulfill = !orderDisplay?.hideFulfillment;
+    lanes.push(statusLane(intentKey, orderDisplay, canFulfill));
+  }
+  const money = resolveMoneyAxis("unpaid");
+  lanes.push({
+    key: "money",
+    label: money.label,
+    stages: money.steps.map((s, i) => ({
+      key: s.key,
+      label: s.label,
+      tone: i === 0 ? "start" : i === money.steps.length - 1 ? "good" : "live"
+    })),
+    edges: money.steps.slice(0, -1).map((s, i) => ({
+      from: s.key,
+      to: money.steps[i + 1].key,
+      // The only move on this lane a merchant makes. The first is the
+      // customer's; nothing on our side advances it.
+      verb: money.steps[i + 1].key === "paid" ? "Confirm payment" : void 0
+    }))
+  });
+  if (!orderDisplay?.hideFulfillment) {
+    const delivery = resolveDeliveryAxis(orderDisplay, "unfulfilled");
+    if (delivery.steps.length > 1) {
+      lanes.push({
+        key: "fulfilment",
+        label: delivery.label,
+        stages: delivery.steps.map((s, i) => ({
+          key: s.key,
+          label: s.label,
+          tone: i === 0 ? "start" : i === delivery.steps.length - 1 ? "good" : "live"
+        })),
+        edges: delivery.steps.slice(0, -1).map((s, i) => {
+          const next = delivery.steps[i + 1];
+          const action = resolveNextAction({
+            status: "confirmed",
+            paymentStatus: "paid",
+            fulfillmentStatus: s.key,
+            orderDisplay,
+            intentKey,
+            canFulfill: true
+          });
+          return {
+            from: s.key,
+            to: next.key,
+            verb: action.key === "fulfill" && action.fulfillmentStatus === next.key ? action.label : void 0
+          };
+        })
+      });
+    }
+  }
+  const first = firstObjectFor(intentKey);
+  return {
+    intentKey,
+    lanes,
+    start: {
+      noun: first.noun,
+      cta: first.cta,
+      blurb: first.blurb,
+      href: first.href
+    },
+    notes
+  };
+}
+export {
+  resolveWorkflowShape
+};
+//# sourceMappingURL=workflow-shape.js.map