@withpotter/components 0.13.0-next.101

package/dist/business-setup/step-template.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Which site they start from, asked in onboarding because the dashboard does
+ * not make sense until it is answered.
+ *
+ * A business is provisioned with a template whether or not anyone chose one,
+ * derived from the archetype in silence. That silence was the problem: the
+ * template decides what the storefront IS, and the merchant met it for the
+ * first time after setup was over, on a site they had never seen.
+ *
+ * IT RENDERS THE GALLERY, not a copy of it. The first version drew its own grid
+ * of tiles, which meant clicking a template set some invisible state and did
+ * nothing else — no preview, no filters, no search — while the tile's own hover
+ * label promised "View template". Three template surfaces in one codebase, in a
+ * repo whose recurring failure is exactly that.
+ *
+ * SELECTING IS PREVIEWING. On the dashboard, choosing a template is a switch
+ * with consequences, so it is confirmed in the panel. Here nothing exists yet:
+ * there is no live site to disturb and no content to carry over. So a tap opens
+ * the preview AND marks the choice, and the flow's own Continue is the only
+ * commit. Making someone tap a tile, then a button in a panel, then Continue
+ * would be three confirmations of a decision that costs nothing to change.
+ *
+ * ---------------------------------------------------------------------------
+ *
+ * IT READS THE REGISTRY, not the templates table. The first version read the
+ * table on the argument that the registry 502s when the renderer is down and
+ * would leave this step empty. True, and backwards: the table is the stale
+ * source. A padel club that had just said "take bookings" was shown seven
+ * ecommerce storefronts — a restaurant, a cosmetics shop, two fashion labels —
+ * because the three bookings templates that exist are in the registry and not in
+ * the table. Two of the seven were dead rows and rendered as broken images.
+ * `fetchRegistry` already falls back to the table when the renderer is
+ * unreachable, so nothing is lost by asking it in the right order.
+ */
+export declare function StepTemplate({ initial, initialBrief, intents, onChange, onConfirm, busy, }: {
+    initial?: string;
+    /** A brief the merchant already typed, restored from the draft. */
+    initialBrief?: string;
+    /**
+     * The archetype, so a starting point can be recommended against the shelf
+     * that is really on screen. It used to take a resolved `recommended` id from
+     * a hardcoded map, and that map named templates no catalogue serves: the step
+     * preselected `services-pro`, no tile matched so nothing looked chosen, and
+     * Continue sat enabled ready to provision onto a template that does not
+     * exist. A recommendation the merchant cannot see is the choice being made
+     * behind their back, which is the thing this screen exists to stop.
+     */
+    intents: string[];
+    onChange: (patch: {
+        templateId: string;
+        /** The id to provision with if the merchant skips instead of choosing. */
+        skipTemplateId: string;
+        /** Their own words, carried so an interrupted merchant does not retype it. */
+        brief: string;
+        valid: boolean;
+        /** One template open on its own surface, so the shell can drop the
+         *  offer to choose from a shelf that is not on screen. */
+        previewOpen: boolean;
+        /**
+         * WHETHER A HAND CHOSE THIS, as against the recommendation standing in for
+         * one. `templateId` cannot answer that — it carries the fallback too, which
+         * is why the shell must not read it to decide whether there is anything to
+         * continue WITH.
+         */
+        chosen: boolean;
+    }) => void;
+    /** Confirming from inside the preview moves the flow on, so the panel's
+     *  action is the same commit as Continue rather than a second way to choose
+     *  what has already been chosen. */
+    onConfirm?: () => void;
+    /**
+     * Provisioning is in flight. The panel's action is the only commit on this
+     * step, so it has to be the thing that shows the wait — otherwise removing
+     * the duplicate footer button would take the progress indicator with it.
+     */
+    busy?: boolean;
+}): import("react").JSX.Element;

package/dist/business-setup/step-template.js

@@ -0,0 +1,132 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import {
+  fetchRegistry,
+  fetchProvisionableTemplateIds
+} from "@withpotter/lib/template-context";
+import {
+  recommendTemplate
+} from "@withpotter/lib/intents/archetype-flow";
+import { TemplateGallery } from "@withpotter/components/templates/template-gallery";
+function StepTemplate({
+  initial,
+  initialBrief,
+  intents,
+  onChange,
+  onConfirm,
+  busy
+}) {
+  const [templates, setTemplates] = useState([]);
+  const [registryCategories, setRegistryCategories] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [provisionable, setProvisionable] = useState(null);
+  const [chosen, setChosen] = useState(initial || "");
+  const [touched, setTouched] = useState(false);
+  const choose = (id) => {
+    setTouched(true);
+    setChosen(id);
+  };
+  const closePreview = () => setTouched(false);
+  const brief = initialBrief ?? "";
+  useEffect(() => {
+    let cancelled = false;
+    Promise.all([fetchRegistry(), fetchProvisionableTemplateIds()]).then(([reg, allowed]) => {
+      if (cancelled) return;
+      setTemplates(reg.templates);
+      setRegistryCategories(reg.categories ?? []);
+      setProvisionable(allowed);
+    }).catch(() => {
+    }).finally(() => {
+      if (!cancelled) setLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const shelf = templates;
+  const narrowed = false;
+  const recommended = useMemo(
+    () => recommendTemplate(intents, shelf),
+    [intents, shelf]
+  );
+  const selected = chosen || recommended || "";
+  const canProvision = (id) => !provisionable || provisionable.has(id);
+  const selectedBlocked = !!selected && !canProvision(selected);
+  const skipTemplateId = (canProvision(selected) ? selected : "") || shelf.find((t) => canProvision(t.id))?.id || shelf[0]?.id || "";
+  useEffect(() => {
+    onChange({
+      templateId: selected,
+      skipTemplateId,
+      brief,
+      previewOpen: touched && !!chosen,
+      chosen: !!chosen,
+      // Nothing is valid until the shelf has answered. Reporting valid while
+      // `templates` was still the initial empty array is what let Continue go
+      // bright before a single tile had rendered.
+      //
+      // A template provisioning cannot accept is not a valid choice either.
+      // Both commits — the panel's "Start with this" and the modal's "Create
+      // business" — read this flag, so blocking here closes the one door that
+      // ends in `Unknown template` with the form gone.
+      valid: loading ? false : selectedBlocked ? false : !!selected || templates.length === 0
+    });
+  }, [
+    selected,
+    skipTemplateId,
+    brief,
+    loading,
+    selectedBlocked,
+    templates.length,
+    touched,
+    chosen,
+    onChange
+  ]);
+  const categories = useMemo(() => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const t of shelf) {
+      if (!t.category) continue;
+      counts.set(t.category, (counts.get(t.category) ?? 0) + 1);
+    }
+    const nameById = new Map(registryCategories.map((c) => [c.id, c.name]));
+    return [...counts.entries()].map(([id, count]) => ({
+      id,
+      // A slug is still better than an empty chip if the registry ever serves a
+      // category it did not describe, but it is now the last resort rather than
+      // the outcome for two of five.
+      name: nameById.get(id) ?? id,
+      count
+    }));
+  }, [shelf, registryCategories]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    selectedBlocked && /* @__PURE__ */ jsx("p", { className: "mb-3 text-sm text-[var(--text-secondary)]", children: "This template is not ready on this server yet. Pick another to continue, or try again shortly." }),
+    /* @__PURE__ */ jsx(
+      TemplateGallery,
+      {
+        templates: shelf,
+        categories,
+        loading,
+        recommendedId: recommended,
+        intents,
+        selectedId: chosen || null,
+        previewId: touched ? chosen : null,
+        onSelect: choose,
+        onUse: (t) => {
+          choose(t.id);
+          if (canProvision(t.id)) onConfirm?.();
+        },
+        using: busy,
+        useLabel: "Use this template",
+        useIsPrimary: true,
+        controlsLayout: "stacked",
+        previewMode: "stage",
+        onClosePreview: closePreview,
+        emptyNote: narrowed ? "Nothing here matches that search. Clear it to see the rest." : "No templates available right now. You can pick one later."
+      }
+    )
+  ] });
+}
+export {
+  StepTemplate
+};
+//# sourceMappingURL=step-template.js.map

package/dist/business-setup/step-template.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/business-setup/step-template.tsx"],"sourcesContent":["'use client';\n\nimport { useEffect, useMemo, useState } from 'react';\nimport {\n  fetchRegistry,\n  fetchProvisionableTemplateIds,\n  type RegistryCategory,\n  type RegistryTemplate,\n} from '@withpotter/lib/template-context';\nimport {\n  recommendTemplate,\n  shelfForIntents,\n} from '@withpotter/lib/intents/archetype-flow';\nimport { TemplateGallery } from '@withpotter/components/templates/template-gallery';\n\n/**\n * Which site they start from, asked in onboarding because the dashboard does\n * not make sense until it is answered.\n *\n * A business is provisioned with a template whether or not anyone chose one,\n * derived from the archetype in silence. That silence was the problem: the\n * template decides what the storefront IS, and the merchant met it for the\n * first time after setup was over, on a site they had never seen.\n *\n * IT RENDERS THE GALLERY, not a copy of it. The first version drew its own grid\n * of tiles, which meant clicking a template set some invisible state and did\n * nothing else — no preview, no filters, no search — while the tile's own hover\n * label promised \"View template\". Three template surfaces in one codebase, in a\n * repo whose recurring failure is exactly that.\n *\n * SELECTING IS PREVIEWING. On the dashboard, choosing a template is a switch\n * with consequences, so it is confirmed in the panel. Here nothing exists yet:\n * there is no live site to disturb and no content to carry over. So a tap opens\n * the preview AND marks the choice, and the flow's own Continue is the only\n * commit. Making someone tap a tile, then a button in a panel, then Continue\n * would be three confirmations of a decision that costs nothing to change.\n *\n * ---------------------------------------------------------------------------\n *\n * IT READS THE REGISTRY, not the templates table. The first version read the\n * table on the argument that the registry 502s when the renderer is down and\n * would leave this step empty. True, and backwards: the table is the stale\n * source. A padel club that had just said \"take bookings\" was shown seven\n * ecommerce storefronts — a restaurant, a cosmetics shop, two fashion labels —\n * because the three bookings templates that exist are in the registry and not in\n * the table. Two of the seven were dead rows and rendered as broken images.\n * `fetchRegistry` already falls back to the table when the renderer is\n * unreachable, so nothing is lost by asking it in the right order.\n */\nexport function StepTemplate({\n  initial,\n  initialBrief,\n  intents,\n  onChange,\n  onConfirm,\n  busy,\n}: {\n  initial?: string;\n  /** A brief the merchant already typed, restored from the draft. */\n  initialBrief?: string;\n  /**\n   * The archetype, so a starting point can be recommended against the shelf\n   * that is really on screen. It used to take a resolved `recommended` id from\n   * a hardcoded map, and that map named templates no catalogue serves: the step\n   * preselected `services-pro`, no tile matched so nothing looked chosen, and\n   * Continue sat enabled ready to provision onto a template that does not\n   * exist. A recommendation the merchant cannot see is the choice being made\n   * behind their back, which is the thing this screen exists to stop.\n   */\n  intents: string[];\n  onChange: (patch: {\n    templateId: string;\n    /** The id to provision with if the merchant skips instead of choosing. */\n    skipTemplateId: string;\n    /** Their own words, carried so an interrupted merchant does not retype it. */\n    brief: string;\n    valid: boolean;\n    /** One template open on its own surface, so the shell can drop the\n     *  offer to choose from a shelf that is not on screen. */\n    previewOpen: boolean;\n    /**\n     * WHETHER A HAND CHOSE THIS, as against the recommendation standing in for\n     * one. `templateId` cannot answer that — it carries the fallback too, which\n     * is why the shell must not read it to decide whether there is anything to\n     * continue WITH.\n     */\n    chosen: boolean;\n  }) => void;\n  /** Confirming from inside the preview moves the flow on, so the panel's\n   *  action is the same commit as Continue rather than a second way to choose\n   *  what has already been chosen. */\n  onConfirm?: () => void;\n  /**\n   * Provisioning is in flight. The panel's action is the only commit on this\n   * step, so it has to be the thing that shows the wait — otherwise removing\n   * the duplicate footer button would take the progress indicator with it.\n   */\n  busy?: boolean;\n}) {\n  const [templates, setTemplates] = useState<RegistryTemplate[]>([]);\n  /**\n   * The registry's own category names, kept rather than re-derived.\n   *\n   * This step used to build the filter chips from `t.category` and translate\n   * them through a three-entry map of its own, which named ecommerce, booking\n   * and creative and nothing else. The registry serves five: `events` and\n   * `hospitality` fell through to their raw slugs, so the shelf read\n   * \"Shops · events · Bookings · Portfolios · hospitality\" — two lowercase\n   * database values sitting between three proper labels, on the two smallest\n   * categories. A merchant who had just said \"Sell tickets to events\" landed on\n   * a chip called `events` holding one template and concluded that was the\n   * whole shelf.\n   *\n   * The registry already ships \"E-Commerce\", \"Events\", \"Booking\", \"Creative\"\n   * and \"Hospitality & Rentals\". Nothing here needed naming; it needed reading.\n   */\n  const [registryCategories, setRegistryCategories] = useState<\n    RegistryCategory[]\n  >([]);\n  const [loading, setLoading] = useState(true);\n  /**\n   * What provisioning will accept today. `null` means the list could not be\n   * read, which is treated as \"accepts everything\" — a lookup that failed must\n   * not become a second way to block the flow.\n   */\n  const [provisionable, setProvisionable] = useState<Set<string> | null>(null);\n  /** What the merchant has actually touched. Empty until they do. */\n  const [chosen, setChosen] = useState(initial || '');\n  /**\n   * Whether they touched it IN THIS VISIT, which is the only thing that opens a\n   * preview.\n   *\n   * `initial` comes back from the persisted draft, and the draft holds whatever\n   * would be provisioned — including a recommendation nobody confirmed. Seeding\n   * \"has chosen\" from it meant coming back to this step opened the panel on a\n   * template the merchant had never picked, which is the silent choice again,\n   * one reload later.\n   */\n  const [touched, setTouched] = useState(false);\n  const choose = (id: string) => {\n    setTouched(true);\n    setChosen(id);\n  };\n  /**\n   * Back to the shelf, keeping the pick.\n   *\n   * Only `touched` is dropped, never `chosen`: the stage opens off `touched`,\n   * and the tile's mark and everything downstream read `chosen`. Clearing both\n   * would make backing out of a preview also un-answer the question, which is\n   * not what a way back means.\n   */\n  const closePreview = () => setTouched(false);\n\n  /**\n   * NO BRIEF FIELD. Removed on John's call, 2026-08-07.\n   *\n   * It asked the merchant to \"describe the site you want\" and then only\n   * reordered the shelf by keyword match. The arrow next to it did not generate\n   * anything, because nothing generates yet — so the largest control on the\n   * screen was the one doing the least, sitting above the tiles that were\n   * actually the decision. When there is a builder to read it, it belongs to the\n   * builder, not to a step whose only job is picking a starting point.\n   *\n   * The draft field survives so nothing downstream has to change shape.\n   */\n  const brief = initialBrief ?? '';\n\n  useEffect(() => {\n    let cancelled = false;\n    // THE REGISTRY IS THE SHELF. Every template the renderer serves is offered,\n    // however many that is.\n    //\n    // This used to intersect the registry with the API's templates table, so\n    // that provisioning could not reject the choice on the last press. The\n    // guard was real but it was aimed at the wrong thing: the table is a cache\n    // of the registry, and a cache that has fallen behind became a ceiling on\n    // what anyone could pick. On staging it held 8 rows against a registry of\n    // 14, so the shelf showed SIX — every booking template, the dining\n    // template, the portfolio and the standard store all filtered out of\n    // existence. A merchant who wanted to take bookings was shown five\n    // ecommerce storefronts and an events one, and no message explained why.\n    //\n    // Provisioning re-syncs on a miss instead of rejecting (see\n    // `ensureTemplateExists` in potter-api), so the case this filter defended\n    // against repairs itself rather than needing to be hidden.\n    //\n    // The acceptance list is still read, but it no longer decides what is on\n    // the shelf — only whether a choice can be COMMITTED right now. Until an API\n    // carrying `ensureTemplateExists` is live, a table that has fallen behind\n    // will still refuse ids the renderer serves, and the merchant meets that as\n    // `Unknown template \"lagoon-house-01\"` on the last press with the form gone.\n    // Blocking here instead means the tile is visible and explained rather than\n    // deleted from the catalogue, and the block disappears on its own the moment\n    // the API can accept everything.\n    Promise.all([fetchRegistry(), fetchProvisionableTemplateIds()])\n      .then(([reg, allowed]) => {\n        if (cancelled) return;\n        setTemplates(reg.templates);\n        setRegistryCategories(reg.categories ?? []);\n        setProvisionable(allowed);\n      })\n      .catch(() => {\n        // `fetchRegistry` already falls back to the templates table when the\n        // renderer is unreachable, so arriving here means both are gone.\n        // Reported valid below so nobody is trapped behind a shelf that failed\n        // to load.\n      })\n      .finally(() => {\n        if (!cancelled) setLoading(false);\n      });\n    return () => {\n      cancelled = true;\n    };\n  }, []);\n\n  /**\n   * THE SHELF IS THE ANSWER TO THE PREVIOUS QUESTION.\n   *\n   * A merchant who has just said \"I take bookings\" and is then shown seven\n   * fashion storefronts has been asked a question the product ignored. See\n   * `shelfForIntents` for why it narrows on `behaviors` and why it stops\n   * narrowing when there is less than a row left.\n   */\n  /**\n   * THE WHOLE CATALOGUE (John, 2026-09-10: *\"also show all the templates there\n   * not just a few, just show all\"*).\n   *\n   * REVERSAL, ON PURPOSE, and the argument it reverses is above and worth\n   * keeping. What the narrowing produced in practice was seven cards out of\n   * twenty-six, each carrying the same generic sentence — so it never read as a\n   * narrowing, only as a short catalogue. A look is the one decision on this\n   * screen that can be changed later, and it is made by eye: browsing wants\n   * everything. The archetype still does real work — `recommendTemplate` floats\n   * its match to the front, so the answer to the previous question is the FIRST\n   * thing on the shelf rather than the only thing on it.\n   */\n  const shelf = templates;\n  const narrowed = false;\n\n  /** Only ever an id that is on screen, or nothing. */\n  const recommended = useMemo(\n    () => recommendTemplate(intents, shelf),\n    [intents, shelf],\n  );\n\n  /**\n   * The recommendation IS the selection until the merchant picks otherwise, so\n   * the tile shows as chosen rather than the choice living invisibly in a draft.\n   *\n   * Derived rather than synced into state on an effect: a `setChosen` inside an\n   * effect would fight the merchant's own click for a frame, and it is the\n   * cascading-render shape the linter rejects. There is nothing to store — the\n   * answer is a function of what they touched and what loaded.\n   */\n  const selected = chosen || recommended || '';\n\n  /** Whether the API will accept this id right now. */\n  const canProvision = (id: string) => !provisionable || provisionable.has(id);\n  const selectedBlocked = !!selected && !canProvision(selected);\n\n  /**\n   * What Skip commits to. Falls past the recommendation to the first template on\n   * the shelf, because \"choose for me\" still has to produce something real:\n   * provisioning validates the id and rejects anything it does not know. It\n   * skips to one the API will actually take, so the one path that does not\n   * involve a merchant choosing cannot be the one that fails.\n   */\n  // Off the SHELF, not the whole registry. \"Surprise me\" on a bookings\n  // business must not reach past the narrowing and hand back a fashion shop.\n  const skipTemplateId =\n    (canProvision(selected) ? selected : '') ||\n    shelf.find((t) => canProvision(t.id))?.id ||\n    shelf[0]?.id ||\n    '';\n\n  useEffect(() => {\n    onChange({\n      templateId: selected,\n      skipTemplateId,\n      brief,\n      previewOpen: touched && !!chosen,\n      chosen: !!chosen,\n      // Nothing is valid until the shelf has answered. Reporting valid while\n      // `templates` was still the initial empty array is what let Continue go\n      // bright before a single tile had rendered.\n      //\n      // A template provisioning cannot accept is not a valid choice either.\n      // Both commits — the panel's \"Start with this\" and the modal's \"Create\n      // business\" — read this flag, so blocking here closes the one door that\n      // ends in `Unknown template` with the form gone.\n      valid: loading\n        ? false\n        : selectedBlocked\n          ? false\n          : !!selected || templates.length === 0,\n    });\n  }, [\n    selected,\n    skipTemplateId,\n    brief,\n    loading,\n    selectedBlocked,\n    templates.length,\n    touched,\n    chosen,\n    onChange,\n  ]);\n\n  /**\n   * Counts come from the templates actually on the shelf, names come from the\n   * registry. The registry's own `count` is the whole catalogue's, and this\n   * step can filter it down to what provisioning will accept, so trusting that\n   * figure would put a chip reading \"7\" above four tiles.\n   */\n  // COUNTED OFF THE SHELF, not the registry. A chip that says \"Bookings 3\"\n  // above a shelf narrowed to shops is a filter offering to show you templates\n  // that are not there — press it and the grid empties. The tabs have to\n  // describe the list under them.\n  const categories = useMemo(() => {\n    const counts = new Map<string, number>();\n    for (const t of shelf) {\n      if (!t.category) continue;\n      counts.set(t.category, (counts.get(t.category) ?? 0) + 1);\n    }\n    const nameById = new Map(registryCategories.map((c) => [c.id, c.name]));\n    return [...counts.entries()].map(([id, count]) => ({\n      id,\n      // A slug is still better than an empty chip if the registry ever serves a\n      // category it did not describe, but it is now the last resort rather than\n      // the outcome for two of five.\n      name: nameById.get(id) ?? id,\n      count,\n    }));\n  }, [shelf, registryCategories]);\n\n  return (\n    <>\n      {/* Says WHY the commit is dark, next to the thing that is dark. A\n          disabled primary with no explanation is the same dead end as the\n          error it replaces, just quieter. */}\n      {selectedBlocked && (\n        <p className=\"mb-3 text-sm text-[var(--text-secondary)]\">\n          This template is not ready on this server yet. Pick another to\n          continue, or try again shortly.\n        </p>\n      )}\n      <TemplateGallery\n        templates={shelf}\n        categories={categories}\n        loading={loading}\n        recommendedId={recommended}\n        // So a tile can say what it cannot show this business.\n        intents={intents}\n        // Only a real tap counts as chosen, and only a real tap opens a preview.\n        // Preselecting drove both, so the step opened on one template's detail\n        // panel — a full-bleed storefront with its palette and typefaces — under\n        // a heading that says \"Pick a starting point\", with the shelf pushed off\n        // the bottom of the screen. Being shown one template you did not ask for\n        // is the same failure as being given one silently, just louder.\n        selectedId={chosen || null}\n        previewId={touched ? chosen : null}\n        onSelect={choose}\n        /**\n         * The panel's action COMMITS; it does not re-choose.\n         *\n         * Opening the preview already selected the template, so a button that\n         * only called setSelected was setting state to the value it already held\n         * — it looked broken because it did nothing. Someone who has opened a\n         * preview and pressed the button has decided, so this is the same move as\n         * Continue, reached from where they were actually looking.\n         */\n        onUse={(t) => {\n          choose(t.id);\n          // Never commit an id provisioning will refuse. The tap still selects,\n          // so the panel stays open on it and the note above explains why the\n          // flow did not move.\n          if (canProvision(t.id)) onConfirm?.();\n        }}\n        using={busy}\n        /* PLAIN, BECAUSE THE NAME MADE IT WORSE.\n           It read `Build ${businessName}` — the merchant's own words handed\n           back at the commit — and on a real business called \"John\" that is\n           \"Build John\", which is an instruction to build a person. The idea was\n           that naming the thing you are making beats naming the category; what\n           it actually does is put a proper noun where a verb's object should\n           be, and every name that is not a shop-sounding phrase reads as\n           nonsense. John: *\"build john is the wrong button and its so\n           conufsing\"*.\n\n           \"Use this template\" says the act and the object, is what the rest of\n           the catalogue says, and cannot be broken by anybody's business\n           name. */\n        useLabel=\"Use this template\"\n        // Primary now. It was quiet because the flow carried a Continue doing\n        // the same thing, and two bright buttons committing one choice is worse\n        // than one. That bar is gone, so this is the only way forward and has to\n        // look like it.\n        useIsPrimary\n        // Search over the shelf, then the filters, both centred under the\n        // centred title rather than pushed to opposite ends of a toolbar.\n        controlsLayout=\"stacked\"\n        // ONE CLICK IS THE WHOLE VIEW. The panel-above-the-grid put the thing\n        // being judged in a 46vh strip with eleven competitors under it, and\n        // the merchant had to scroll past the decision to get back to the\n        // shelf. Here the tile opens into the screen and \"All templates\" is\n        // the way back.\n        previewMode=\"stage\"\n        onClosePreview={closePreview}\n        // Nothing exists yet to build your own site with.\n        emptyNote={\n          narrowed\n            ? 'Nothing here matches that search. Clear it to see the rest.'\n            : 'No templates available right now. You can pick one later.'\n        }\n      />\n    </>\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/business-setup/types.d.ts

@@ -0,0 +1,55 @@
+/** The evolving business being established, filled step by step. */
+export interface BusinessDraft {
+    businessName: string;
+    /**
+     * The URL slug, decoupled from the display name. Auto-derived from the name
+     * until the merchant edits it (e.g. because their first choice was taken), so
+     * "Lekki Padel Club" can live at `lekki-padel` while the name keeps its case
+     * and spacing. Reserved against the real availability check before provision.
+     */
+    slug: string;
+    /** Monetization patterns — how they make money. Routes tools + later steps. */
+    intents: string[];
+    /** Customer-facing offers selected during setup. */
+    offerIds: string[];
+    /** Merchant-provided explanation when Other / not listed is selected. */
+    offerNote: string;
+    /** Chosen storefront template id. Empty = use the intent-derived default. */
+    templateId: string;
+    /** What the merchant said the site should be, in their own words. */
+    brief: string;
+    /**
+     * Plain country NAME, the shape lib/countries stores. Guessed from the
+     * browser on screen one and confirmable there; currency, tax and delivery
+     * defaults all hang off it.
+     */
+    country: string;
+    /**
+     * What trade the business is in, from BUSINESS_CATEGORIES. Optional: it is
+     * asked on screen one and never gates creation. Persisted as the tenant's
+     * `industryKey`, which nothing else can fill — provisioning only infers one
+     * from legacy template ids, so a business created without this stays
+     * uncategorised until somebody sets it from the workspace card.
+     */
+    category: string;
+    /**
+     * How customers reach the business. Part of the provision contract, stored
+     * canonically on tenant.phone AND settings.phone, and for the merchants this
+     * is built for it is usually a WhatsApp number — which is how orders and
+     * bookings actually arrive. Optional: a business can be created without it.
+     */
+    phone: string;
+    /**
+     * Whether the merchant wants to start paying now or start free.
+     *
+     * Deliberately an INTENT, not a plan id. Nothing is charged during setup and
+     * no subscription is created here: the business is provisioned either way,
+     * and `paid` only changes where the merchant lands afterwards — on the plans
+     * screen instead of the dashboard. Taking a card inside onboarding would mean
+     * asking for money before the merchant has seen a single screen of the thing
+     * they are buying, and it would put a Paystack redirect in the middle of a
+     * flow whose failure mode is a half-created business.
+     */
+    billingIntent: 'free' | 'paid';
+}
+export declare const EMPTY_DRAFT: BusinessDraft;

package/dist/business-setup/types.js

@@ -0,0 +1,17 @@
+const EMPTY_DRAFT = {
+  businessName: "",
+  slug: "",
+  intents: [],
+  offerIds: [],
+  offerNote: "",
+  templateId: "",
+  brief: "",
+  country: "",
+  phone: "",
+  category: "",
+  billingIntent: "free"
+};
+export {
+  EMPTY_DRAFT
+};
+//# sourceMappingURL=types.js.map

package/dist/business-setup/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/business-setup/types.ts"],"sourcesContent":["/** The evolving business being established, filled step by step. */\nexport interface BusinessDraft {\n  businessName: string;\n  /**\n   * The URL slug, decoupled from the display name. Auto-derived from the name\n   * until the merchant edits it (e.g. because their first choice was taken), so\n   * \"Lekki Padel Club\" can live at `lekki-padel` while the name keeps its case\n   * and spacing. Reserved against the real availability check before provision.\n   */\n  slug: string;\n  /** Monetization patterns — how they make money. Routes tools + later steps. */\n  intents: string[];\n  /** Customer-facing offers selected during setup. */\n  offerIds: string[];\n  /** Merchant-provided explanation when Other / not listed is selected. */\n  offerNote: string;\n  /** Chosen storefront template id. Empty = use the intent-derived default. */\n  templateId: string;\n  /** What the merchant said the site should be, in their own words. */\n  brief: string;\n  /**\n   * Plain country NAME, the shape lib/countries stores. Guessed from the\n   * browser on screen one and confirmable there; currency, tax and delivery\n   * defaults all hang off it.\n   */\n  country: string;\n  /**\n   * What trade the business is in, from BUSINESS_CATEGORIES. Optional: it is\n   * asked on screen one and never gates creation. Persisted as the tenant's\n   * `industryKey`, which nothing else can fill — provisioning only infers one\n   * from legacy template ids, so a business created without this stays\n   * uncategorised until somebody sets it from the workspace card.\n   */\n  category: string;\n  /**\n   * How customers reach the business. Part of the provision contract, stored\n   * canonically on tenant.phone AND settings.phone, and for the merchants this\n   * is built for it is usually a WhatsApp number — which is how orders and\n   * bookings actually arrive. Optional: a business can be created without it.\n   */\n  phone: string;\n  /**\n   * Whether the merchant wants to start paying now or start free.\n   *\n   * Deliberately an INTENT, not a plan id. Nothing is charged during setup and\n   * no subscription is created here: the business is provisioned either way,\n   * and `paid` only changes where the merchant lands afterwards — on the plans\n   * screen instead of the dashboard. Taking a card inside onboarding would mean\n   * asking for money before the merchant has seen a single screen of the thing\n   * they are buying, and it would put a Paystack redirect in the middle of a\n   * flow whose failure mode is a half-created business.\n   */\n  billingIntent: 'free' | 'paid';\n}\n\nexport const EMPTY_DRAFT: BusinessDraft = {\n  businessName: '',\n  slug: '',\n  intents: [],\n  offerIds: [],\n  offerNote: '',\n  templateId: '',\n  brief: '',\n  country: '',\n  phone: '',\n  category: '',\n  billingIntent: 'free',\n};\n"],"mappings":"AAuDO,MAAM,cAA6B;AAAA,EACxC,cAAc;AAAA,EACd,MAAM;AAAA,EACN,SAAS,CAAC;AAAA,EACV,UAAU,CAAC;AAAA,EACX,WAAW;AAAA,EACX,YAAY;AAAA,EACZ,OAAO;AAAA,EACP,SAAS;AAAA,EACT,OAAO;AAAA,EACP,UAAU;AAAA,EACV,eAAe;AACjB;","names":[]}

package/dist/business-setup/use-business-setup.d.ts

@@ -0,0 +1,102 @@
+import { type BusinessDraft } from './types';
+import type { StepDirection } from '@withpotter/lib/motion';
+/**
+ * `brief` is the new first step and the only open question in the flow: one
+ * sentence, from which the archetype, template and category are read. `shape`
+ * survives as a correction surface rather than an interrogation — it is reached
+ * by tapping the chip on the name screen, not by walking through it.
+ */
+/** Identity, what the business does, where it sells, and what it looks like.
+ *  Template is last because the shelf can only be ordered sensibly once the
+ *  archetype is known. */
+import { type SetupStep } from './step-gate';
+export type { SetupStep };
+interface Options {
+    /**
+     * Keep an in-progress draft across a reload. First-run onboarding wants this
+     * (losing a half-filled form after a refresh is the whole reason it exists);
+     * the in-app modal does not, because closing it is a deliberate cancel and a
+     * restored draft would reappear the next time it opened.
+     */
+    persist?: boolean;
+    /** Handed the created business, so the caller can take the merchant to it
+     *  rather than guessing the slug from the draft (provisioning may adjust it
+     *  to keep addresses unique).
+     *
+     *  The draft comes with it because the answers decide where the merchant
+     *  goes next, and the caller cannot read them any other way: this fires from
+     *  inside `provision`, so a caller reaching for its own `setup.draft` would
+     *  be reading the value captured when the callback was constructed. */
+    onCreated: (slug: string, draft: BusinessDraft) => void;
+    /**
+     * Ask how they want to start paying, as the last screen before the business
+     * is created.
+     *
+     * Off by default, and deliberately its own flag rather than a read of
+     * `persist`. The two callers differ in more than one way, and an owner
+     * adding their SECOND workspace already has a plan — asking them to choose
+     * one again would be asking a question whose answer is already on file.
+     */
+    askPlan?: boolean;
+    /** Ask new-business onboarding for an explicit category. */
+    askCategory?: boolean;
+}
+/**
+ * Establishing a business: the state, the questions and the provision call.
+ *
+ * There is one flow and two shells. Full-screen `/onboarding` is first-run,
+ * where there is no app to stay inside; the modal is every other time, because
+ * a merchant who is already in the dashboard should not be thrown out of it to
+ * add a second business.
+ *
+ * They used to be two implementations. The modal asked a thinner set of
+ * questions, skipped the slug check and the country, and carried its own
+ * intent→template map that had drifted onto five template ids which no longer
+ * existed — so every business created from the switcher failed provisioning
+ * with `Unknown template`, exactly the way onboarding did. Two forms for one
+ * job is how that happens twice.
+ */
+export declare function useBusinessSetup({ persist, onCreated, askPlan, askCategory, }: Options): {
+    draft: BusinessDraft;
+    step: SetupStep;
+    direction: StepDirection;
+    hydrated: boolean;
+    provisioning: boolean;
+    created: boolean;
+    error: string | null;
+    busy: boolean;
+    logoFile: File | null;
+    onLogoChange: import("react").Dispatch<import("react").SetStateAction<File | null>>;
+    onIdentityChange: (p: {
+        businessName: string;
+        slug: string;
+        country: string;
+        phone: string;
+        category: string;
+        valid: boolean;
+    }) => void;
+    onCategoryChange: (p: {
+        category: string;
+        valid: boolean;
+    }) => void;
+    onIntentsChange: (p: {
+        intents: string[];
+        offerIds?: string[];
+        offerNote?: string;
+        valid: boolean;
+    }) => void;
+    onBillingIntentChange: (billingIntent: "free" | "paid") => void;
+    canContinue: boolean;
+    blockReason: string | null;
+    isLastStep: boolean;
+    next: () => void;
+    back: () => void;
+    canGoBack: boolean;
+    /** Any step by name, for the progress rail. The four helpers below predate
+     *  it and stay because their call sites read better. */
+    goTo: (s: SetupStep) => void;
+    goToIdentity: () => void;
+    goToCategory: () => void;
+    goToShape: () => void;
+    reset: () => void;
+};

package/dist/business-setup/use-business-setup.js

@@ -0,0 +1,222 @@
+"use client";
+import { useCallback, useEffect, useState } from "react";
+import { useAuth } from "@withpotter/lib/auth-context";
+import { useToast } from "@withpotter/ui-kit/use-toast";
+import { currencyForCountry } from "@withpotter/lib/countries";
+import {
+  ONBOARDING_DRAFT_KEY,
+  clearOnboardingDraft,
+  markBusinessJustCreated
+} from "@withpotter/lib/onboarding-draft";
+import { EMPTY_DRAFT } from "./types";
+import { resolveProvisionableTemplate } from "./provisionable-template";
+import { suggestBusinessCategory } from "@withpotter/lib/business-categories";
+import { blockReasonAt, canContinueAt } from "./step-gate";
+function useBusinessSetup({
+  persist = false,
+  onCreated,
+  askPlan = false,
+  askCategory = false
+}) {
+  const { createWorkspace } = useAuth();
+  const { toast } = useToast();
+  const [draft, setDraft] = useState(EMPTY_DRAFT);
+  const [step, setStep] = useState("identity");
+  const [direction, setDirection] = useState("forward");
+  const [identityValid, setIdentityValid] = useState(false);
+  const [categoryValid, setCategoryValid] = useState(false);
+  const [intentsValid, setIntentsValid] = useState(false);
+  const validity = {
+    identity: identityValid,
+    category: categoryValid,
+    intents: intentsValid
+  };
+  const [logoFile, setLogoFile] = useState(null);
+  const [provisioning, setProvisioning] = useState(false);
+  const [created, setCreated] = useState(false);
+  const [error, setError] = useState(null);
+  const [hydrated, setHydrated] = useState(!persist);
+  useEffect(() => {
+    if (!persist) return;
+    try {
+      const raw = sessionStorage.getItem(ONBOARDING_DRAFT_KEY);
+      if (raw)
+        setDraft((d) => ({
+          ...d,
+          ...JSON.parse(raw)
+        }));
+    } catch {
+    }
+    setHydrated(true);
+  }, [persist]);
+  useEffect(() => {
+    if (!persist || !hydrated) return;
+    if (created) return clearOnboardingDraft();
+    try {
+      sessionStorage.setItem(ONBOARDING_DRAFT_KEY, JSON.stringify(draft));
+    } catch {
+    }
+  }, [draft, created, hydrated, persist]);
+  const onIdentityChange = useCallback(
+    (p) => {
+      const { valid, category, ...fields } = p;
+      setIdentityValid(valid);
+      setDraft((d) => {
+        const same = d.businessName === fields.businessName && d.slug === fields.slug && d.country === fields.country && d.phone === fields.phone && d.category === (askCategory ? d.category : category);
+        if (same) return d;
+        const next2 = askCategory ? d.category : category;
+        const categoryChanged = d.category !== "" && d.category !== next2;
+        return {
+          ...d,
+          ...fields,
+          category: next2,
+          ...categoryChanged ? { intents: [], offerIds: [] } : {}
+        };
+      });
+    },
+    [askCategory]
+  );
+  const onIntentsChange = useCallback(
+    (p) => {
+      const offerIds = p.offerIds ?? [];
+      const offerNote = p.offerNote ?? "";
+      setIntentsValid(p.valid);
+      setDraft((d) => {
+        if (d.intents.length === p.intents.length && d.intents.every((v, i) => v === p.intents[i]) && d.offerIds.length === offerIds.length && d.offerIds.every((v, i) => v === offerIds[i]) && d.offerNote === offerNote) {
+          return d;
+        }
+        const category = d.category || (askCategory ? "" : suggestBusinessCategory({
+          businessName: d.businessName,
+          intents: p.intents
+        }));
+        return { ...d, intents: p.intents, offerIds, offerNote, category };
+      });
+    },
+    [askCategory]
+  );
+  const onCategoryChange = useCallback(
+    (p) => {
+      setCategoryValid(p.valid);
+      setDraft(
+        (d) => d.category === p.category ? d : { ...d, category: p.category }
+      );
+    },
+    []
+  );
+  const provision = useCallback(
+    async (d) => {
+      setProvisioning(true);
+      setError(null);
+      try {
+        const tenant = await createWorkspace({
+          businessName: d.businessName.trim(),
+          slug: d.slug || void 0,
+          // 'default' is not a template. Provisioning validates against the
+          // API's templates table, so an id nobody knows blocks creation
+          // outright — which is what shipped when the template step was cut.
+          templateId: await resolveProvisionableTemplate(d),
+          // Omitted when the country is unknown, rather than guessed. The API
+          // answers a missing currency with NGN in one place; sending a
+          // fabricated USD was the dashboard overriding that with something
+          // worse for every merchant who had not reached the country step.
+          ...currencyForCountry(d.country) ? { currency: currencyForCountry(d.country) } : {},
+          country: d.country || void 0,
+          phone: d.phone.trim() || void 0,
+          intents: d.intents.length ? d.intents : void 0,
+          category: d.category || void 0,
+          // Uploaded post-provision by `createWorkspace`, which has done this
+          // since it was written — nothing had ever passed it a file.
+          logoFile
+        });
+        markBusinessJustCreated(tenant.slug);
+        setCreated(true);
+        onCreated(tenant.slug, d);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "We couldn't finish setting up your business. Try again in a moment.";
+        setError(message);
+        const text = message.toLowerCase();
+        if (text.includes("slug") || text.includes("unavailable")) {
+          setStep("identity");
+          setDirection("back");
+        }
+        toast({
+          variant: "destructive",
+          title: message,
+          description: "Nothing you entered is lost.",
+          duration: 1e4
+        });
+      } finally {
+        setProvisioning(false);
+      }
+    },
+    [createWorkspace, onCreated, toast, logoFile]
+  );
+  const onBillingIntentChange = useCallback(
+    (billingIntent) => setDraft(
+      (d) => d.billingIntent === billingIntent ? d : { ...d, billingIntent }
+    ),
+    []
+  );
+  const next = useCallback(() => {
+    setDirection("forward");
+    if (step === "identity") return setStep(askCategory ? "category" : "shape");
+    if (step === "category") return setStep("shape");
+    if (step === "shape")
+      return askPlan ? setStep("plan") : void provision(draft);
+    void provision(draft);
+  }, [step, draft, provision, askPlan, askCategory]);
+  const back = useCallback(() => {
+    setDirection("back");
+    if (step === "plan") return setStep("shape");
+    if (step === "category") return setStep("identity");
+    if (step === "shape") return setStep("identity");
+  }, [step]);
+  const isLastStep = askPlan ? step === "plan" : step === "shape";
+  const reset = useCallback(() => {
+    setDraft(EMPTY_DRAFT);
+    setStep("identity");
+    setDirection("forward");
+    setIdentityValid(false);
+    setCategoryValid(false);
+    setIntentsValid(false);
+    setProvisioning(false);
+    setCreated(false);
+    setError(null);
+  }, []);
+  return {
+    draft,
+    step,
+    direction,
+    hydrated,
+    provisioning,
+    created,
+    error,
+    // Busy covers `created` because the caller's navigation is still in flight
+    // when provisioning clears; without it a second click makes a second
+    // business.
+    busy: provisioning || created,
+    logoFile,
+    onLogoChange: setLogoFile,
+    onIdentityChange,
+    onCategoryChange,
+    onIntentsChange,
+    onBillingIntentChange,
+    canContinue: canContinueAt(step, validity),
+    blockReason: blockReasonAt(step, validity),
+    isLastStep,
+    next,
+    back,
+    canGoBack: step !== "identity",
+    /** Any step by name, for the progress rail. The four helpers below predate
+     *  it and stay because their call sites read better. */
+    goTo: useCallback((s) => setStep(s), []),
+    goToIdentity: useCallback(() => setStep("identity"), []),
+    goToCategory: useCallback(() => setStep("category"), []),
+    goToShape: useCallback(() => setStep("shape"), []),
+    reset
+  };
+}
+export {
+  useBusinessSetup
+};
+//# sourceMappingURL=use-business-setup.js.map