@withpotter/components 0.13.0-next.101

package/dist/potter/use-potter-ask.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/potter/use-potter-ask.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\nimport { useAuth } from '@withpotter/lib/auth-context';\nimport { useCurrentTemplate } from '@withpotter/lib/template-context';\nimport { resolveEnabledBehaviors } from '@withpotter/lib/resolve-enabled-behaviors';\nimport { resolveHelpTopics } from '@withpotter/lib/help-topics';\nimport { useMoneyVisibility } from '@withpotter/lib/use-money-visibility';\nimport { useEntityLabel } from '@withpotter/lib/intents/use-entity-label';\nimport { formatCurrency } from '@withpotter/lib/utils';\nimport {\n  replyLead,\n  replySpoken,\n  routeQuestion,\n  type PotterReply,\n} from './potter-answer';\nimport { usePotter } from './potter-context';\nimport { matchDataIntent, intentAllowed, type DataIntent } from './potter-data';\nimport { potterApi, askPotterStream } from '@withpotter/lib/api/potter';\nimport {\n  bookingsToday,\n  lowStock,\n  moneyOwed,\n  salesCompare,\n  type ToolAnswer,\n} from './potter-tools';\n\n/**\n * Asking, from either door.\n *\n * TWO BRANCHES NOW, AND THE ORDER MATTERS. A question is first offered to\n * `matchDataIntent`, which claims only the handful of sentences the product\n * itself offers and can answer out of the merchant's own rows. Everything it\n * does not claim falls through to `routeQuestion` — the help corpus, the record\n * search, the setup proposal — exactly as before.\n *\n * The data branch goes first because the alternative is what shipped: \"which\n * products are running low\" matched `find` on the noun and came back with a\n * name search for the whole sentence, and \"how many appointments today\" did the\n * same on \"appointments\". A router that owns the widest net cannot be allowed\n * to see a question a narrower one can actually answer.\n *\n * IT IS ASYNC NOW. Routing the corpus never touched the network; reading\n * invoices does. The docblock this replaces predicted the change and said the\n * shape would not have to: it returns a promise, voice mode awaits it, and the\n * `thinking` state that loop already carried is now a state something happens\n * during.\n *\n * The corpus is gated to what this business actually does, and the data tools\n * are gated twice — by the same behaviours, and by `useMoneyVisibility` for the\n * two that name a figure. A Front desk hire who cannot see the month's takings\n * on the home must not be able to ask Box for them either.\n */\n\n/** What a caller gets back. `spoken` is the sentence a voice should read. */\nexport interface PotterAnswer {\n  spoken: string;\n  /** Present only when the answer came from the corpus rather than the rows. */\n  reply?: PotterReply;\n}\n\nexport function usePotterAsk() {\n  const { tenant } = useAuth();\n  const { template } = useCurrentTemplate(tenant?.templateId);\n  const { say, resolve, openPotter, messages } = usePotter();\n\n  /**\n   * The thread, readable without becoming a dependency.\n   *\n   * `ask` must keep a STABLE identity: `PotterSurface` consumes a handed-over\n   * question in an effect keyed on it, and a callback that changes every time\n   * somebody speaks re-fires that effect and asks the seed twice. Synced in an\n   * effect rather than during render, which also means it holds the turns as of\n   * the last commit — so the question just `say`n is not in it, which is\n   * exactly the history the route wants.\n   */\n  const messagesRef = useRef(messages);\n  useEffect(() => {\n    messagesRef.current = messages;\n  }, [messages]);\n  const money = useMoneyVisibility();\n  const bookingLabel = useEntityLabel('booking');\n  const itemLabel = useEntityLabel('item');\n\n  const behaviors = useMemo(\n    () =>\n      resolveEnabledBehaviors(\n        tenant?.settings as Record<string, unknown> | undefined,\n        template,\n      ),\n    [tenant?.settings, template],\n  );\n\n  const topics = useMemo(() => resolveHelpTopics(behaviors), [behaviors]);\n  const behaviorSet = useMemo(() => new Set<string>(behaviors), [behaviors]);\n\n  const slug = tenant?.slug;\n  /* No currency argument: `formatCurrency` reads the workspace's own, set once\n     by `AuthProvider`. Passing one here would be a second answer to a question\n     the app already settled — a Lagos workspace read in dollars for exactly\n     that reason. */\n  const asMoney = useCallback((n: number) => formatCurrency(n), []);\n\n  /** One tool, chosen. */\n  const runOne = useCallback(\n    (intent: DataIntent, slugArg: string): Promise<ToolAnswer> => {\n      switch (intent.tool) {\n        case 'bookings_today':\n          return bookingsToday(slugArg, bookingLabel);\n        case 'low_stock':\n          return lowStock(slugArg, itemLabel);\n        case 'money_owed':\n          return moneyOwed(slugArg, asMoney);\n        case 'sales_compare':\n          return salesCompare(slugArg, asMoney, intent.windowDays);\n      }\n    },\n    [bookingLabel, itemLabel, asMoney],\n  );\n\n  const gate = useMemo(\n    () => ({\n      behaviors: behaviorSet,\n      canSeeAmounts: money.canSeeAmounts,\n      canSeeEarnings: money.canSeeEarnings,\n    }),\n    [behaviorSet, money.canSeeAmounts, money.canSeeEarnings],\n  );\n\n  /**\n   * \"What needs my attention today?\" is three questions.\n   *\n   * It fans out to every tool this tenant is allowed and joins the sentences.\n   * Answering it with one of them would read as a complete reply over a third\n   * of the facts, which is worse than not answering — see `potter-data`.\n   *\n   * A tool that throws is dropped rather than failing the lot: three of four\n   * facts with one missing beats no answer, and the merchant can ask the\n   * missing one directly.\n   */\n  const runAttention = useCallback(\n    async (slugArg: string): Promise<ToolAnswer> => {\n      const wanted: DataIntent[] = (\n        [\n          { tool: 'bookings_today' },\n          { tool: 'money_owed' },\n          { tool: 'low_stock' },\n        ] as DataIntent[]\n      ).filter((i) => intentAllowed(i, gate));\n\n      if (wanted.length === 0) {\n        return {\n          reply: 'Nothing I can check for you on this business yet.',\n          blocks: [],\n        };\n      }\n\n      /* Paired with the intent that produced it, so the trail can name the\n         lookups that actually returned rather than the ones we hoped for. */\n      const results = await Promise.all(\n        wanted.map(async (i) => {\n          try {\n            return { intent: i, answer: await runOne(i, slugArg) };\n          } catch {\n            return null;\n          }\n        }),\n      );\n      const got = results.filter(\n        (r): r is { intent: DataIntent; answer: ToolAnswer } => r !== null,\n      );\n      /* Every one of them failed. `[].join(' ')` is the empty string, so this\n         returned a turn with no text — Box answering by saying nothing,\n         which reads as the app hanging. */\n      if (got.length === 0) {\n        return {\n          reply: 'I could not reach any of that just now. Try again shortly.',\n          blocks: [],\n        };\n      }\n      return {\n        reply: got.map((r) => r.answer.reply).join(' '),\n        blocks: got.flatMap((r) => r.answer.blocks),\n        tools: got.map((r) => r.intent.tool),\n      };\n    },\n    [gate, runOne],\n  );\n\n  return useCallback(\n    async (\n      question: string,\n      /** `signal` aborts the streamed turn — see the Stop control. */\n      opts?: { signal?: AbortSignal },\n    ): Promise<PotterAnswer | null> => {\n      const q = question.trim();\n      if (!q) return null;\n      // Idempotent, and it covers the home where the surface is already up — a\n      // suggestion pressed from the intro must not have to know its door.\n      openPotter();\n      say({ role: 'you', text: q });\n\n      const intent = matchDataIntent(q);\n      const allowed =\n        intent !== null &&\n        (intent === 'attention' || intentAllowed(intent, gate));\n\n      if (intent !== null && allowed && slug) {\n        const pendingId = say({ role: 'potter', text: '', pending: true });\n        try {\n          const answer =\n            intent === 'attention'\n              ? await runAttention(slug)\n              : await runOne(intent, slug);\n          resolve(pendingId, {\n            text: answer.reply,\n            blocks: answer.blocks,\n            // The fan-out reports its own; a single tool is the one we chose.\n            toolsUsed:\n              answer.tools ?? (intent === 'attention' ? [] : [intent.tool]),\n          });\n          return { spoken: answer.reply };\n        } catch {\n          /**\n           * A read that failed is not an answer that does not exist.\n           *\n           * It says so and stops. Falling through to the help corpus here\n           * would hand back a topic about invoices when the invoices call\n           * broke, which reads as an answer and is not one.\n           */\n          const failed =\n            'I could not reach that just now. Try again in a moment.';\n          resolve(pendingId, { text: failed, blocks: [] });\n          return { spoken: failed };\n        }\n      }\n\n      /**\n       * THE MODEL, WHERE THERE IS ONE.\n       *\n       * `POST /potter/ask` decides which question a sentence IS, in whatever\n       * words it arrived in, and answers from the merchant's own rows through\n       * the same usecases the analytics screens read. It is tried BEFORE the\n       * corpus and AFTER the matched data intents above, deliberately: a\n       * sentence the local matcher already claims has a tested answer and a\n       * rendered block, and paying for a model to reach the same number would\n       * be slower and no better.\n       *\n       * `null` means the route is not configured here — every checkout and\n       * staging until the key is deployed — and the corpus below answers\n       * exactly as it did before this existed. A THROWN error is different and\n       * is not caught: a configured route that fails is a real failure, and\n       * the pending turn says so rather than quietly degrading to keywords.\n       */\n      const pendingId = say({ role: 'potter', text: '', pending: true });\n\n      /** The corpus, the record search, the setup proposal — where no model is. */\n      const corpusAnswer = () => {\n        const reply = routeQuestion(q, topics);\n        resolve(pendingId, { text: replyLead(reply), reply });\n        return { spoken: replySpoken(reply), reply };\n      };\n\n      const history = messagesRef.current\n        .filter((m) => !m.pending && m.text)\n        .slice(-10)\n        .map((m) => ({ role: m.role, text: m.text }));\n\n      /**\n       * STREAMED FIRST, whole-turn second.\n       *\n       * The words appear as they are written and the trail fills in as each\n       * lookup starts, which is the difference between waiting and watching.\n       * `false` means the route is not configured here, exactly as `ask`'s\n       * `null` does, and both fall through to the corpus below.\n       */\n      let streamed = '';\n      const toolsSeen: string[] = [];\n      try {\n        const available = await askPotterStream(\n          q,\n          history,\n          (event) => {\n            if (event.type === 'text') {\n              streamed += event.text;\n              /* `pending` stays true: the turn is still being written, and a\n                 thinking indicator that blinks off on the first fragment and\n                 back on for the next reads as a stutter. */\n              resolve(pendingId, {\n                text: streamed,\n                toolsUsed: toolsSeen,\n                pending: true,\n              });\n            } else if (event.type === 'tool') {\n              toolsSeen.push(event.name);\n              resolve(pendingId, { toolsUsed: [...toolsSeen], pending: true });\n            } else if (event.type === 'done') {\n              resolve(pendingId, {\n                text: streamed,\n                toolsUsed: event.toolsUsed,\n              });\n            } else {\n              resolve(pendingId, { text: event.message, blocks: [] });\n            }\n          },\n          opts?.signal,\n          // Names the workspace. Without it the route has no tenant to check a\n          // permission against and answers 401, which is not a 503 and so does\n          // not fall back — it errors.\n          slug,\n        );\n        if (available) return { spoken: streamed };\n        /**\n         * NOT CONFIGURED HERE — and the whole-turn route below is the same\n         * route, so it will say the same thing. Skipping straight to the\n         * corpus saves a second doomed request on every unmatched question,\n         * which on an environment without a key is every one of them.\n         */\n        return corpusAnswer();\n      } catch (err) {\n        /**\n         * STOPPED IS NOT FAILED, and it is the merchant's own doing — so the\n         * turn keeps whatever had arrived rather than replacing it with an\n         * error. An empty one says so, because a turn with no text on screen\n         * reads as a hang.\n         */\n        if ((err as Error)?.name === 'AbortError') {\n          resolve(pendingId, {\n            text: streamed || 'Stopped.',\n            toolsUsed: toolsSeen,\n          });\n          return { spoken: streamed };\n        }\n\n        /**\n         * A STREAM CAN FAIL WHERE THE PLAIN ROUTE WORKS, which is the only\n         * reason the whole-turn call is still here. A proxy that buffers, a\n         * network that drops a long-lived connection, a client that cannot\n         * read a body stream — none of those say the answering route is down,\n         * and falling straight to keyword matching would throw away a working\n         * answer to protect against a transport problem.\n         */\n        try {\n          const answer = await potterApi.ask(q, history, slug);\n          if (answer && typeof answer.text === 'string' && answer.text.trim()) {\n            resolve(pendingId, {\n              text: answer.text,\n              blocks: [],\n              toolsUsed: answer.toolsUsed,\n            });\n            return { spoken: answer.text };\n          }\n        } catch {\n          const failed =\n            'I could not reach that just now. Try again in a moment.';\n          resolve(pendingId, { text: failed, blocks: [] });\n          return { spoken: failed };\n        }\n      }\n\n      return corpusAnswer();\n    },\n    [openPotter, say, resolve, topics, gate, slug, runOne, runAttention],\n  );\n}\n\n/**\n * Whether THIS workspace can even be asked a given question.\n *\n * WHAT THIS FIXES, found by John on a Health & Wellness workspace that sells\n * nothing: the bar offered *\"Which items are running low?\"*, he pressed it, and\n * Box replied *\"Nothing matched\"*. Every part of that worked as written —\n * `matchDataIntent` claimed the sentence, `intentAllowed` correctly refused it\n * because `low_stock` needs the `purchasable` behaviour and a massage studio\n * has no stock, and the refusal fell through to a record search that found no\n * customer by that name. The bug was one step earlier: we OFFERED it.\n *\n * `ask-placeholders` says a placeholder is a promise, and its own guard admits\n * the hole — *\"it still does not know which topics a given tenant has enabled —\n * it runs the full corpus, the most permissive case\"*. That is fine for a build\n * check and useless at runtime, where the tenant is sitting right there. This\n * closes it: the same gate the answer uses now decides what gets suggested, so\n * a question on screen is a question this business can have answered.\n *\n * Anything the data matcher does NOT claim stays askable — the help corpus and\n * the record search are open to everyone, and this must never become a second\n * router deciding what may be typed.\n */\nexport function useCanAsk(): (question: string) => boolean {\n  const money = useMoneyVisibility();\n  const { tenant } = useAuth();\n  const { template } = useCurrentTemplate(tenant?.templateId);\n  const behaviors = useMemo(\n    () =>\n      resolveEnabledBehaviors(\n        tenant?.settings as Record<string, unknown> | undefined,\n        template,\n      ),\n    [tenant?.settings, template],\n  );\n\n  return useCallback(\n    (question: string) => {\n      const intent = matchDataIntent(question);\n      // Not a data question, or the fan-out — which filters itself.\n      if (!intent || intent === 'attention') return true;\n      return intentAllowed(intent, {\n        behaviors: new Set<string>(behaviors),\n        canSeeAmounts: money.canSeeAmounts,\n        canSeeEarnings: money.canSeeEarnings,\n      });\n    },\n    [behaviors, money.canSeeAmounts, money.canSeeEarnings],\n  );\n}\n"],"mappings":"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","names":["pendingId"]}

package/dist/potter/use-potter-turn.d.ts

@@ -0,0 +1,17 @@
+import { type PotterAttachment } from './potter-attach';
+import type { QueuedMessage } from './potter-queue';
+export declare function usePotterTurn(): {
+    draft: string;
+    setDraft: import("react").Dispatch<import("react").SetStateAction<string>>;
+    attachments: PotterAttachment[];
+    attach: (file: File) => Promise<void>;
+    removeAttachment: (file: File) => void;
+    queue: QueuedMessage[];
+    setQueue: import("react").Dispatch<import("react").SetStateAction<QueuedMessage[]>>;
+    queueOpen: boolean;
+    setQueueOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    editQueued: (item: QueuedMessage) => void;
+    submit: (text: string) => void;
+    stop: () => void | undefined;
+    busy: boolean;
+};

package/dist/potter/use-potter-turn.js

@@ -0,0 +1,165 @@
+"use client";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { usePotter } from "./potter-context";
+import { usePotterAsk } from "./use-potter-ask";
+import {
+  describeImages,
+  describeSheet,
+  MAX_ATTACHMENTS,
+  readAttachment
+} from "./potter-attach";
+import { useEntityLabel } from "@withpotter/lib/intents/use-entity-label";
+function summarise(files) {
+  const sheets = files.filter((a) => a.kind === "sheet");
+  if (sheets.length === 1 && files.length === 1) return sheets[0].file.name;
+  const images = files.length - sheets.length;
+  if (!images) return `${sheets.length} files`;
+  return images === 1 ? "A picture" : `${images} pictures`;
+}
+function usePotterTurn() {
+  const {
+    messages,
+    say,
+    resolve,
+    handSheet,
+    handPhotos,
+    seed,
+    seedFiles,
+    clearSeed
+  } = usePotter();
+  const ask = usePotterAsk();
+  const itemLabel = useEntityLabel("item");
+  const [draft, setDraft] = useState("");
+  const [attachments, setAttachments] = useState([]);
+  const [queue, setQueue] = useState([]);
+  const [queueOpen, setQueueOpen] = useState(false);
+  const queueRef = useRef(queue);
+  useEffect(() => {
+    queueRef.current = queue;
+  }, [queue]);
+  const runRef = useRef(null);
+  const busy = messages.some((m) => m.pending);
+  const inFlight = useRef(null);
+  const stop = () => inFlight.current?.abort();
+  const attach = async (file) => {
+    const read = await readAttachment(file);
+    if (!read) return;
+    setAttachments((old) => {
+      if (old.length >= MAX_ATTACHMENTS) {
+        if (read.kind === "image") URL.revokeObjectURL(read.url);
+        return old;
+      }
+      return [...old, read];
+    });
+  };
+  const removeAttachment = (file) => {
+    setAttachments(
+      (old) => old.filter((a) => {
+        if (a.file !== file) return true;
+        if (a.kind === "image") URL.revokeObjectURL(a.url);
+        return false;
+      })
+    );
+  };
+  const clearAttachments = () => setAttachments([]);
+  const run = useCallback(
+    async (text, files) => {
+      if (files.length) {
+        const images = files.filter((a) => a.kind === "image");
+        const sheets = files.filter((a) => a.kind === "sheet");
+        say({
+          role: "you",
+          text: text || summarise(files),
+          attachments: images.map((i) => i.url)
+        });
+        for (const s of sheets) {
+          const id = say({ role: "potter", text: "", pending: true });
+          const usable = !s.sheet.problem && s.sheet.recognised.includes("title");
+          handSheet(usable ? s.file : null);
+          resolve(id, {
+            text: describeSheet(s.sheet, itemLabel.plural.toLowerCase()),
+            reply: { kind: "sheet", rows: s.sheet.rows, usable }
+          });
+        }
+        if (images.length) {
+          handPhotos(images.map((i) => i.file));
+          const id = say({ role: "potter", text: "", pending: true });
+          resolve(id, {
+            text: describeImages(images.length),
+            reply: { kind: "photo", count: images.length }
+          });
+        }
+      } else {
+        const controller = new AbortController();
+        inFlight.current = controller;
+        try {
+          await ask(text, { signal: controller.signal });
+        } finally {
+          if (inFlight.current === controller) inFlight.current = null;
+        }
+      }
+      const [head, ...rest] = queueRef.current;
+      if (head) {
+        setQueue(rest);
+        void runRef.current?.(head.text, head.attachments ?? []);
+      }
+    },
+    [ask, say, resolve, handSheet, handPhotos, itemLabel]
+  );
+  useEffect(() => {
+    runRef.current = run;
+  }, [run]);
+  const nextId = useRef(0);
+  const submit = (text) => {
+    const going = attachments;
+    clearAttachments();
+    if (busy) {
+      setQueue((q) => [
+        ...q,
+        { id: `q${nextId.current++}`, text, attachments: going }
+      ]);
+      return;
+    }
+    void run(text, going);
+  };
+  const seeded = useRef(false);
+  useEffect(() => {
+    if (!seed && !seedFiles.length) {
+      seeded.current = false;
+      return;
+    }
+    if (seeded.current) return;
+    seeded.current = true;
+    const text = seed ?? "";
+    const files = seedFiles;
+    clearSeed();
+    void (async () => {
+      const read = files.length ? (await Promise.all(files.map(readAttachment))).filter((a) => a !== null).slice(0, MAX_ATTACHMENTS) : [];
+      void runRef.current?.(text, read);
+    })();
+  }, [seed, seedFiles, clearSeed]);
+  const editQueued = (item) => {
+    setQueue((q) => q.filter((x) => x.id !== item.id));
+    if (item.attachments?.length) setAttachments(item.attachments);
+    setDraft(item.text);
+  };
+  return {
+    draft,
+    setDraft,
+    attachments,
+    attach,
+    removeAttachment,
+    queue,
+    setQueue,
+    queueOpen,
+    setQueueOpen,
+    editQueued,
+    submit,
+    stop,
+    busy
+  };
+}
+export {
+  usePotterTurn
+};
+//# sourceMappingURL=use-potter-turn.js.map

package/dist/potter/use-potter-turn.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/potter/use-potter-turn.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useRef, useState } from 'react';\nimport { usePotter } from './potter-context';\nimport { usePotterAsk } from './use-potter-ask';\nimport {\n  describeImages,\n  describeSheet,\n  MAX_ATTACHMENTS,\n  readAttachment,\n  type PotterAttachment,\n} from './potter-attach';\nimport type { QueuedMessage } from './potter-queue';\nimport { useEntityLabel } from '@withpotter/lib/intents/use-entity-label';\n\n/**\n * Everything that happens between pressing send and an answer arriving.\n *\n * SPLIT OUT OF `PotterScreen` when that file crossed 500 lines, and the cut\n * follows the house rule rather than the line count: a screen is a frame plus\n * sections, and a hook is one question. The question here is \"what is the state\n * of the turn\" — the draft, the attachment, the queue behind it, the controller\n * that can end it — and none of it is layout. What is left in the screen is the\n * header, the two arrangements of the column, and the composer it hands this.\n *\n * It reads and writes the Box context directly rather than taking callbacks,\n * because every one of these operations is about the SAME conversation the\n * screen is drawing. Threading `say`/`resolve` back through props would have\n * made that look like a coincidence.\n */\n/**\n * What a wordless message says, when all it carries is files.\n *\n * NOT THE FILENAMES. That is the whole of John's complaint — a turn reading\n * `_designerbabe_1718527507_3391577010625190628_15287514660.jpg` is a string\n * from Instagram's CDN taking up two lines of a conversation. A spreadsheet\n * keeps its name because a merchant chose and recognises it; pictures are shown\n * rather than named, and the turn renders their thumbnails above this line.\n */\nfunction summarise(files: PotterAttachment[]): string {\n  const sheets = files.filter((a) => a.kind === 'sheet');\n  if (sheets.length === 1 && files.length === 1) return sheets[0].file.name;\n  const images = files.length - sheets.length;\n  if (!images) return `${sheets.length} files`;\n  return images === 1 ? 'A picture' : `${images} pictures`;\n}\n\nexport function usePotterTurn() {\n  const {\n    messages,\n    say,\n    resolve,\n    handSheet,\n    handPhotos,\n    seed,\n    seedFiles,\n    clearSeed,\n  } = usePotter();\n  const ask = usePotterAsk();\n  const itemLabel = useEntityLabel('item');\n\n  /**\n   * A spreadsheet becomes a turn, the way a question does.\n   *\n   * Pushed as a pending Box turn first and filled when the file has been\n   * read, so the thread never shows a question with nothing under it — the same\n   * shape `usePotterAsk` uses for a tool that has to make a round trip. Reading\n   * a CSV is fast, but \"fast\" is not \"synchronous\" and a box that flickers\n   * between two states is worse than one that says it is working.\n   *\n   * The file goes onto the context BEFORE the turn resolves so the importer\n   * has it the moment the merchant presses the control. Unusable files are not\n   * handed over: `describeSheet` has already said why, and stashing a file\n   * nothing can use would leave it there for the next import to pick up.\n   */\n  /**\n   * THE COMPOSER'S PAYLOAD, held here rather than inside it.\n   *\n   * A queued message carries its attachment, so the sheet has to outlive the\n   * composer's own state — and the screen is the thing that knows whether a\n   * send dispatches or waits.\n   */\n  const [draft, setDraft] = useState('');\n  /**\n   * A LIST, capped at five. John: *\"i should be able to add more images maybe\n   * max is 5\"*.\n   *\n   * The `File` lives on the attachment rather than in a ref beside it, which is\n   * what the single-attachment version did — one file, one ref, and the two\n   * could drift the moment there were two of anything. Whether a file is usable\n   * is decided where it is used, not stashed at pick time.\n   */\n  const [attachments, setAttachments] = useState<PotterAttachment[]>([]);\n  const [queue, setQueue] = useState<QueuedMessage[]>([]);\n  const [queueOpen, setQueueOpen] = useState(false);\n\n  /**\n   * The queue, readable from inside an async turn without being a dependency.\n   *\n   * The drain runs after `ask` resolves, and things can be queued DURING that\n   * await — so reading the state captured when the turn started would silently\n   * drop whatever was typed while Box was answering, which is the one job\n   * this feature has.\n   */\n  const queueRef = useRef(queue);\n  useEffect(() => {\n    queueRef.current = queue;\n  }, [queue]);\n\n  /** The drain calls itself; see the note where it does. */\n  const runRef = useRef<\n    ((text: string, attachments: PotterAttachment[]) => Promise<void>) | null\n  >(null);\n\n  const busy = messages.some((m) => m.pending);\n\n  /**\n   * The turn in flight, so it can be ended.\n   *\n   * One controller per turn rather than one for the screen: a controller that\n   * has been aborted stays aborted, so reusing it would make every turn after\n   * the first Stop abort before it began.\n   */\n  const inFlight = useRef<AbortController | null>(null);\n\n  /**\n   * STOP ENDS THIS TURN AND LETS THE QUEUE CONTINUE.\n   *\n   * The other reading — stop everything, drop what is waiting — treats a queue\n   * as a batch, and it is not one. Those are separate questions the merchant\n   * still wants asked; not wanting THIS answer says nothing about the next.\n   * Anything they have changed their mind about is one × away on the pile.\n   */\n  const stop = () => inFlight.current?.abort();\n\n  /** Read the file now, so the composer can show it before sending. */\n  const attach = async (file: File) => {\n    const read = await readAttachment(file);\n    if (!read) return;\n    setAttachments((old) => {\n      /* Silently at the cap rather than erroring: the picker is already capped\n         and a merchant who drags a sixth in has not done anything wrong. */\n      if (old.length >= MAX_ATTACHMENTS) {\n        if (read.kind === 'image') URL.revokeObjectURL(read.url);\n        return old;\n      }\n      return [...old, read];\n    });\n  };\n\n  /**\n   * One goes. Revoked on the way out, because an object URL is a live handle on\n   * a blob and dropping the reference without revoking leaks the file for the\n   * life of the tab.\n   *\n   * Keyed on the `File` rather than an index: the list can change between the\n   * render that drew the button and the click that presses it, and an index\n   * would then remove whatever had moved into that slot.\n   */\n  const removeAttachment = (file: File) => {\n    setAttachments((old) =>\n      old.filter((a) => {\n        if (a.file !== file) return true;\n        if (a.kind === 'image') URL.revokeObjectURL(a.url);\n        return false;\n      }),\n    );\n  };\n\n  /** All of them, without revoking — a sent turn still renders its pictures. */\n  const clearAttachments = () => setAttachments([]);\n\n  /**\n   * One turn, then whatever was waiting.\n   *\n   * DRAINED HERE RATHER THAN IN AN EFFECT ON THE BUSY EDGE. An effect watching\n   * `busy` go true→false would be a setState in an effect body — the pattern\n   * the lint rule bans and is right to — and it would fire on every unrelated\n   * re-render that happened to land on the same edge. Awaiting the turn is the\n   * edge, exactly, with no watching.\n   */\n  const run = useCallback(\n    async (text: string, files: PotterAttachment[]) => {\n      if (files.length) {\n        /* ONE user turn carrying all of them, not one per file. They were\n           chosen together and sent together, and five separate turns saying the\n           same sentence back is the shape this cap exists to avoid. */\n        const images = files.filter((a) => a.kind === 'image');\n        const sheets = files.filter((a) => a.kind === 'sheet');\n        say({\n          role: 'you',\n          text: text || summarise(files),\n          attachments: images.map((i) => i.url),\n        });\n\n        /* The spreadsheet answers first where there is one: it is the file with\n           somewhere to go and something to decide, and the pictures are an\n           aside beside it. */\n        for (const s of sheets) {\n          const id = say({ role: 'potter', text: '', pending: true });\n          const usable =\n            !s.sheet.problem && s.sheet.recognised.includes('title');\n          handSheet(usable ? s.file : null);\n          resolve(id, {\n            text: describeSheet(s.sheet, itemLabel.plural.toLowerCase()),\n            reply: { kind: 'sheet', rows: s.sheet.rows, usable },\n          });\n        }\n\n        if (images.length) {\n          /* No vision behind this, so the turn says so and then offers the one\n             true thing it can do with a picture — see `describeImages`. */\n          handPhotos(images.map((i) => i.file));\n          const id = say({ role: 'potter', text: '', pending: true });\n          resolve(id, {\n            text: describeImages(images.length),\n            reply: { kind: 'photo', count: images.length },\n          });\n        }\n      } else {\n        const controller = new AbortController();\n        inFlight.current = controller;\n        try {\n          await ask(text, { signal: controller.signal });\n        } finally {\n          /* Only if it is still ours: a Stop that started the next turn has\n             already replaced this, and clearing it then would orphan the\n             controller the new turn is relying on. */\n          if (inFlight.current === controller) inFlight.current = null;\n        }\n      }\n\n      const [head, ...rest] = queueRef.current;\n      if (head) {\n        setQueue(rest);\n        /* Through the ref, because a `useCallback` cannot name itself — the\n           binding does not exist while its own body is being defined. The ref\n           also means the drain always calls the CURRENT run rather than the one\n           captured when this turn started. */\n        void runRef.current?.(head.text, head.attachments ?? []);\n      }\n    },\n    [ask, say, resolve, handSheet, handPhotos, itemLabel],\n  );\n  useEffect(() => {\n    runRef.current = run;\n  }, [run]);\n\n  /**\n   * Send, or wait your turn.\n   *\n   * Queuing rather than disabling the composer: a merchant with a second\n   * question types it whether or not the box is live, and a dead field loses\n   * it. Ids come off a counter rather than the clock — two messages queued in\n   * the same millisecond are perfectly ordinary and would collide on a key.\n   */\n  const nextId = useRef(0);\n  const submit = (text: string) => {\n    const going = attachments;\n    clearAttachments();\n\n    if (busy) {\n      setQueue((q) => [\n        ...q,\n        { id: `q${nextId.current++}`, text, attachments: going },\n      ]);\n      return;\n    }\n    void run(text, going);\n  };\n\n  /**\n   * THE QUESTION THE HOME BAR HANDED OVER, asked once, here.\n   *\n   * The home types and presses send; `handOff` puts the sentence and any files\n   * on the context and navigates. This is the other end of that: read whatever\n   * came with it, then run one turn carrying both.\n   *\n   * IT RUNS HERE RATHER THAN IN `PotterSurface`, which is where a seed used to\n   * be consumed and still is for the launcher's panel. Files changed that: only\n   * this hook knows how to turn a `File` into an attachment and put it in a\n   * turn, and two consumers would ask the same question twice. The screen\n   * passes `consumeSeed={false}` for exactly this reason.\n   *\n   * THE REF GUARD IS LOAD-BEARING and `clearSeed()` alone is not enough — the\n   * ask screen proved that once already. `clearSeed` is a setState, so it takes\n   * effect on a later render, and every run of this effect before that render\n   * still sees the old seed. Two ways in: StrictMode mounts, runs effects,\n   * tears down and runs again (guaranteed double in development), and `run` is\n   * a `useCallback` over the tenant and the entity labels, which resolve a beat\n   * after mount on a cold navigation — that one bites in production too.\n   */\n  const seeded = useRef(false);\n  useEffect(() => {\n    if (!seed && !seedFiles.length) {\n      seeded.current = false;\n      return;\n    }\n    if (seeded.current) return;\n    seeded.current = true;\n\n    const text = seed ?? '';\n    const files = seedFiles;\n    clearSeed();\n\n    void (async () => {\n      const read = files.length\n        ? (await Promise.all(files.map(readAttachment)))\n            .filter((a): a is PotterAttachment => a !== null)\n            .slice(0, MAX_ATTACHMENTS)\n        : [];\n      /* Through the ref for the same reason the queue drains through it: this\n         effect must not list `run` as a dependency, or a re-created `run` would\n         re-fire the whole handoff. */\n      void runRef.current?.(text, read);\n    })();\n  }, [seed, seedFiles, clearSeed]);\n\n  /** Back into the composer, and out of the pile. */\n  const editQueued = (item: QueuedMessage) => {\n    setQueue((q) => q.filter((x) => x.id !== item.id));\n    if (item.attachments?.length) setAttachments(item.attachments);\n    setDraft(item.text);\n  };\n  return {\n    draft,\n    setDraft,\n    attachments,\n    attach,\n    removeAttachment,\n    queue,\n    setQueue,\n    queueOpen,\n    setQueueOpen,\n    editQueued,\n    submit,\n    stop,\n    busy,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/potter.d.ts

@@ -0,0 +1 @@
+export * from './potter/index';

package/dist/potter.js

@@ -0,0 +1 @@
+export * from './potter/index.js';

package/dist/preview-layout/index.d.ts

@@ -0,0 +1,2 @@
+export { PreviewLayout } from './preview-layout';
+export type { PreviewLayoutConfig, PreviewLayoutProps } from './preview-layout';

package/dist/preview-layout/index.js

@@ -0,0 +1,5 @@
+import { PreviewLayout } from "./preview-layout";
+export {
+  PreviewLayout
+};
+//# sourceMappingURL=index.js.map

package/dist/preview-layout/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/preview-layout/index.ts"],"sourcesContent":["export { PreviewLayout } from './preview-layout';\nexport type { PreviewLayoutConfig, PreviewLayoutProps } from './preview-layout';\n"],"mappings":"AAAA,SAAS,qBAAqB;","names":[]}

package/dist/preview-layout/preview-layout.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from 'react';
+export interface PreviewLayoutConfig {
+    storageKey: string;
+    editorWidthMin: number;
+    editorWidthMax: number;
+    previewWidthMin: number;
+    previewWidthMax: number;
+    previewWidthDefault: number;
+}
+export interface PreviewLayoutProps {
+    config: PreviewLayoutConfig;
+    /** When true, resize handle and width math are active */
+    enabled: boolean;
+    /** Re-measure layout when this value changes */
+    layoutKey?: unknown;
+    /** Class applied to the outer flex container */
+    className?: string;
+    /** Class applied to the editor width wrapper */
+    editorClassName?: string;
+    /** Class applied to the preview width wrapper */
+    previewClassName?: string;
+    /** Editor pane content */
+    editor: ReactNode;
+    /** Preview pane content (omit to hide preview) */
+    preview?: ReactNode;
+}
+export declare function PreviewLayout({ config, enabled, layoutKey, className, editorClassName, previewClassName, editor, preview, }: PreviewLayoutProps): import("react").JSX.Element;

package/dist/preview-layout/preview-layout.js

@@ -0,0 +1,180 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import {
+  useEffect,
+  useRef,
+  useState,
+  useCallback
+} from "react";
+import { cn } from "@withpotter/lib/utils";
+const LAYOUT_GAP_PX = 12;
+const RESIZE_HANDLE_PX = 12;
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function PreviewLayout({
+  config,
+  enabled,
+  layoutKey,
+  className,
+  editorClassName,
+  previewClassName,
+  editor,
+  preview
+}) {
+  const [previewWidth, setPreviewWidth] = useState(() => {
+    if (typeof window === "undefined") return config.previewWidthDefault;
+    const raw = window.localStorage.getItem(config.storageKey);
+    if (!raw) return config.previewWidthDefault;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? clamp(parsed, config.previewWidthMin, config.previewWidthMax) : config.previewWidthDefault;
+  });
+  const [layoutMetrics, setLayoutMetrics] = useState({
+    containerWidth: 0,
+    maxPreviewWidth: config.previewWidthDefault,
+    isDesktop: false
+  });
+  const containerRef = useRef(null);
+  useEffect(() => {
+    window.localStorage.setItem(config.storageKey, String(previewWidth));
+  }, [previewWidth, config.storageKey]);
+  useEffect(() => {
+    if (!enabled) return;
+    const container = containerRef.current;
+    if (!container) return;
+    const updateWidth = () => {
+      const containerWidth = container.clientWidth;
+      const isDesktopViewport = window.innerWidth >= 1024;
+      const desktopMinTotal = config.editorWidthMin + config.previewWidthMin + LAYOUT_GAP_PX + RESIZE_HANDLE_PX;
+      const canUseDesktopLayout = isDesktopViewport && containerWidth >= desktopMinTotal;
+      if (!canUseDesktopLayout) {
+        setLayoutMetrics({
+          containerWidth,
+          maxPreviewWidth: Math.min(config.previewWidthMax, containerWidth),
+          isDesktop: false
+        });
+        return;
+      }
+      const maxPreviewWidth = Math.min(
+        config.previewWidthMax,
+        containerWidth - config.editorWidthMin - LAYOUT_GAP_PX - RESIZE_HANDLE_PX
+      );
+      setLayoutMetrics({
+        containerWidth,
+        maxPreviewWidth,
+        isDesktop: true
+      });
+    };
+    updateWidth();
+    const observer = new ResizeObserver(updateWidth);
+    observer.observe(container);
+    window.addEventListener("resize", updateWidth);
+    return () => {
+      observer.disconnect();
+      window.removeEventListener("resize", updateWidth);
+    };
+  }, [
+    enabled,
+    layoutKey,
+    config.editorWidthMin,
+    config.previewWidthMin,
+    config.previewWidthMax
+  ]);
+  const effectivePreviewWidth = layoutMetrics.isDesktop ? clamp(previewWidth, config.previewWidthMin, layoutMetrics.maxPreviewWidth) : Math.min(config.previewWidthMax, layoutMetrics.maxPreviewWidth);
+  const effectiveEditorWidth = layoutMetrics.isDesktop ? clamp(
+    layoutMetrics.containerWidth - effectivePreviewWidth - LAYOUT_GAP_PX - RESIZE_HANDLE_PX,
+    config.editorWidthMin,
+    config.editorWidthMax
+  ) : void 0;
+  const handleResizeStart = useCallback(
+    (event) => {
+      if (!layoutMetrics.isDesktop) return;
+      event.preventDefault();
+      const startX = event.clientX;
+      const startWidth = previewWidth;
+      const onMouseMove = (moveEvent) => {
+        const deltaX = moveEvent.clientX - startX;
+        setPreviewWidth(
+          clamp(
+            startWidth - deltaX,
+            config.previewWidthMin,
+            config.previewWidthMax
+          )
+        );
+      };
+      const onMouseUp = () => {
+        document.body.style.cursor = "";
+        document.body.style.userSelect = "";
+        window.removeEventListener("mousemove", onMouseMove);
+        window.removeEventListener("mouseup", onMouseUp);
+      };
+      document.body.style.cursor = "col-resize";
+      document.body.style.userSelect = "none";
+      window.addEventListener("mousemove", onMouseMove);
+      window.addEventListener("mouseup", onMouseUp);
+    },
+    [
+      layoutMetrics.isDesktop,
+      previewWidth,
+      config.previewWidthMin,
+      config.previewWidthMax
+    ]
+  );
+  const showPreview = preview !== void 0;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: containerRef,
+      className: cn(
+        "flex flex-col lg:flex-row lg:items-start lg:justify-center",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: cn("min-h-0 w-full lg:shrink-0", editorClassName),
+            style: enabled && layoutMetrics.isDesktop && effectiveEditorWidth ? {
+              width: `${effectiveEditorWidth}px`,
+              maxWidth: `${effectiveEditorWidth}px`
+            } : void 0,
+            children: editor
+          }
+        ),
+        enabled && showPreview && /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "hidden lg:flex h-full w-3 shrink-0 items-center justify-center",
+            onMouseDown: handleResizeStart,
+            role: "separator",
+            "aria-orientation": "vertical",
+            "aria-label": "Resize preview panel",
+            children: /* @__PURE__ */ jsx("div", { className: "h-24 w-[3px] rounded-full bg-[var(--border-default)] hover:bg-brand-500 cursor-col-resize" })
+          }
+        ),
+        showPreview && /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: cn(
+              "min-h-0 min-w-0 w-full self-stretch overflow-hidden",
+              previewClassName
+            ),
+            style: enabled && layoutMetrics.isDesktop ? {
+              // Grow to fill leftover width (no dead right-hand gutter that
+              // swallows clicks), but keep the dragged width as the basis so
+              // the resize handle still controls the split. Capped at max.
+              flex: `1 1 ${effectivePreviewWidth}px`,
+              minWidth: 0,
+              maxWidth: `${config.previewWidthMax}px`
+            } : void 0,
+            children: preview
+          }
+        )
+      ]
+    }
+  );
+}
+export {
+  PreviewLayout
+};
+//# sourceMappingURL=preview-layout.js.map

package/dist/preview-layout/preview-layout.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/preview-layout/preview-layout.tsx"],"sourcesContent":["'use client';\n\nimport {\n  useEffect,\n  useRef,\n  useState,\n  useCallback,\n  type ReactNode,\n} from 'react';\nimport { cn } from '@withpotter/lib/utils';\n\nconst LAYOUT_GAP_PX = 12;\nconst RESIZE_HANDLE_PX = 12;\n\nexport interface PreviewLayoutConfig {\n  storageKey: string;\n  editorWidthMin: number;\n  editorWidthMax: number;\n  previewWidthMin: number;\n  previewWidthMax: number;\n  previewWidthDefault: number;\n}\n\ninterface LayoutMetrics {\n  containerWidth: number;\n  maxPreviewWidth: number;\n  isDesktop: boolean;\n}\n\nexport interface PreviewLayoutProps {\n  config: PreviewLayoutConfig;\n  /** When true, resize handle and width math are active */\n  enabled: boolean;\n  /** Re-measure layout when this value changes */\n  layoutKey?: unknown;\n  /** Class applied to the outer flex container */\n  className?: string;\n  /** Class applied to the editor width wrapper */\n  editorClassName?: string;\n  /** Class applied to the preview width wrapper */\n  previewClassName?: string;\n  /** Editor pane content */\n  editor: ReactNode;\n  /** Preview pane content (omit to hide preview) */\n  preview?: ReactNode;\n}\n\nfunction clamp(value: number, min: number, max: number): number {\n  return Math.max(min, Math.min(max, value));\n}\n\nexport function PreviewLayout({\n  config,\n  enabled,\n  layoutKey,\n  className,\n  editorClassName,\n  previewClassName,\n  editor,\n  preview,\n}: PreviewLayoutProps) {\n  const [previewWidth, setPreviewWidth] = useState(() => {\n    if (typeof window === 'undefined') return config.previewWidthDefault;\n    const raw = window.localStorage.getItem(config.storageKey);\n    if (!raw) return config.previewWidthDefault;\n    const parsed = Number(raw);\n    return Number.isFinite(parsed)\n      ? clamp(parsed, config.previewWidthMin, config.previewWidthMax)\n      : config.previewWidthDefault;\n  });\n  const [layoutMetrics, setLayoutMetrics] = useState<LayoutMetrics>({\n    containerWidth: 0,\n    maxPreviewWidth: config.previewWidthDefault,\n    isDesktop: false,\n  });\n  const containerRef = useRef<HTMLDivElement>(null);\n\n  // Persist width\n  useEffect(() => {\n    window.localStorage.setItem(config.storageKey, String(previewWidth));\n  }, [previewWidth, config.storageKey]);\n\n  // Measure container and compute layout metrics\n  useEffect(() => {\n    if (!enabled) return;\n    const container = containerRef.current;\n    if (!container) return;\n\n    const updateWidth = () => {\n      const containerWidth = container.clientWidth;\n      const isDesktopViewport = window.innerWidth >= 1024; // lg breakpoint\n\n      const desktopMinTotal =\n        config.editorWidthMin +\n        config.previewWidthMin +\n        LAYOUT_GAP_PX +\n        RESIZE_HANDLE_PX;\n\n      const canUseDesktopLayout =\n        isDesktopViewport && containerWidth >= desktopMinTotal;\n\n      if (!canUseDesktopLayout) {\n        setLayoutMetrics({\n          containerWidth,\n          maxPreviewWidth: Math.min(config.previewWidthMax, containerWidth),\n          isDesktop: false,\n        });\n        return;\n      }\n\n      const maxPreviewWidth = Math.min(\n        config.previewWidthMax,\n        containerWidth -\n          config.editorWidthMin -\n          LAYOUT_GAP_PX -\n          RESIZE_HANDLE_PX,\n      );\n\n      setLayoutMetrics({\n        containerWidth,\n        maxPreviewWidth,\n        isDesktop: true,\n      });\n    };\n\n    updateWidth();\n\n    const observer = new ResizeObserver(updateWidth);\n    observer.observe(container);\n    window.addEventListener('resize', updateWidth);\n\n    return () => {\n      observer.disconnect();\n      window.removeEventListener('resize', updateWidth);\n    };\n  }, [\n    enabled,\n    layoutKey,\n    config.editorWidthMin,\n    config.previewWidthMin,\n    config.previewWidthMax,\n  ]);\n\n  const effectivePreviewWidth = layoutMetrics.isDesktop\n    ? clamp(previewWidth, config.previewWidthMin, layoutMetrics.maxPreviewWidth)\n    : Math.min(config.previewWidthMax, layoutMetrics.maxPreviewWidth);\n\n  const effectiveEditorWidth = layoutMetrics.isDesktop\n    ? clamp(\n        layoutMetrics.containerWidth -\n          effectivePreviewWidth -\n          LAYOUT_GAP_PX -\n          RESIZE_HANDLE_PX,\n        config.editorWidthMin,\n        config.editorWidthMax,\n      )\n    : undefined;\n\n  const handleResizeStart = useCallback(\n    (event: React.MouseEvent<HTMLDivElement>) => {\n      if (!layoutMetrics.isDesktop) return;\n      event.preventDefault();\n      const startX = event.clientX;\n      const startWidth = previewWidth;\n\n      const onMouseMove = (moveEvent: MouseEvent) => {\n        const deltaX = moveEvent.clientX - startX;\n        setPreviewWidth(\n          clamp(\n            startWidth - deltaX,\n            config.previewWidthMin,\n            config.previewWidthMax,\n          ),\n        );\n      };\n\n      const onMouseUp = () => {\n        document.body.style.cursor = '';\n        document.body.style.userSelect = '';\n        window.removeEventListener('mousemove', onMouseMove);\n        window.removeEventListener('mouseup', onMouseUp);\n      };\n\n      document.body.style.cursor = 'col-resize';\n      document.body.style.userSelect = 'none';\n      window.addEventListener('mousemove', onMouseMove);\n      window.addEventListener('mouseup', onMouseUp);\n    },\n    [\n      layoutMetrics.isDesktop,\n      previewWidth,\n      config.previewWidthMin,\n      config.previewWidthMax,\n    ],\n  );\n\n  const showPreview = preview !== undefined;\n\n  return (\n    <div\n      ref={containerRef}\n      className={cn(\n        'flex flex-col lg:flex-row lg:items-start lg:justify-center',\n        className,\n      )}\n    >\n      {/* Editor pane */}\n      <div\n        className={cn('min-h-0 w-full lg:shrink-0', editorClassName)}\n        style={\n          enabled && layoutMetrics.isDesktop && effectiveEditorWidth\n            ? {\n                width: `${effectiveEditorWidth}px`,\n                maxWidth: `${effectiveEditorWidth}px`,\n              }\n            : undefined\n        }\n      >\n        {editor}\n      </div>\n\n      {/* Resize handle */}\n      {enabled && showPreview && (\n        <div\n          className=\"hidden lg:flex h-full w-3 shrink-0 items-center justify-center\"\n          onMouseDown={handleResizeStart}\n          role=\"separator\"\n          aria-orientation=\"vertical\"\n          aria-label=\"Resize preview panel\"\n        >\n          <div className=\"h-24 w-[3px] rounded-full bg-[var(--border-default)] hover:bg-brand-500 cursor-col-resize\" />\n        </div>\n      )}\n\n      {/* Preview pane */}\n      {showPreview && (\n        <div\n          className={cn(\n            'min-h-0 min-w-0 w-full self-stretch overflow-hidden',\n            previewClassName,\n          )}\n          style={\n            enabled && layoutMetrics.isDesktop\n              ? {\n                  // Grow to fill leftover width (no dead right-hand gutter that\n                  // swallows clicks), but keep the dragged width as the basis so\n                  // the resize handle still controls the split. Capped at max.\n                  flex: `1 1 ${effectivePreviewWidth}px`,\n                  minWidth: 0,\n                  maxWidth: `${config.previewWidthMax}px`,\n                }\n              : undefined\n          }\n        >\n          {preview}\n        </div>\n      )}\n    </div>\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/preview-layout.d.ts

@@ -0,0 +1 @@
+export * from './preview-layout/index';

package/dist/preview-layout.js

@@ -0,0 +1 @@
+export * from './preview-layout/index.js';

package/dist/product-editor/camera/apply-product-scan.d.ts

@@ -0,0 +1,17 @@
+import type { ProductScanPatch } from './product-qr';
+/** The parts of the editor state a scan writes to. */
+export interface ScanTarget {
+    setTitle: (v: string) => void;
+    setDescription: (v: string) => void;
+    setPrice: (v: number | undefined) => void;
+    setCompareAtPrice: (v: number | undefined) => void;
+    formValues: Record<string, unknown>;
+    setFormValues: (v: Record<string, unknown>) => void;
+}
+/**
+ * Writes a scan's details into the editor. Fields the code did not carry
+ * keep what the merchant typed; pictures are handled by the Media card.
+ * Title and description go into the form values too, the same way typing
+ * them does, so the save sees them.
+ */
+export declare function applyProductScan(patch: ProductScanPatch, t: ScanTarget): void;

package/dist/product-editor/camera/apply-product-scan.js

@@ -0,0 +1,17 @@
+function applyProductScan(patch, t) {
+  if (patch.title !== void 0) t.setTitle(patch.title);
+  if (patch.description !== void 0) t.setDescription(patch.description);
+  if (patch.price !== void 0) t.setPrice(patch.price);
+  if (patch.compareAtPrice !== void 0)
+    t.setCompareAtPrice(patch.compareAtPrice);
+  const next = { ...t.formValues };
+  if (patch.title !== void 0) next.title = patch.title;
+  if (patch.description !== void 0) next.description = patch.description;
+  if (patch.sku !== void 0) next.sku = patch.sku;
+  if (patch.title !== void 0 || patch.description !== void 0 || patch.sku !== void 0)
+    t.setFormValues(next);
+}
+export {
+  applyProductScan
+};
+//# sourceMappingURL=apply-product-scan.js.map

package/dist/product-editor/camera/apply-product-scan.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/product-editor/camera/apply-product-scan.ts"],"sourcesContent":["import type { ProductScanPatch } from './product-qr';\n\n/** The parts of the editor state a scan writes to. */\nexport interface ScanTarget {\n  setTitle: (v: string) => void;\n  setDescription: (v: string) => void;\n  setPrice: (v: number | undefined) => void;\n  setCompareAtPrice: (v: number | undefined) => void;\n  formValues: Record<string, unknown>;\n  setFormValues: (v: Record<string, unknown>) => void;\n}\n\n/**\n * Writes a scan's details into the editor. Fields the code did not carry\n * keep what the merchant typed; pictures are handled by the Media card.\n * Title and description go into the form values too, the same way typing\n * them does, so the save sees them.\n */\nexport function applyProductScan(patch: ProductScanPatch, t: ScanTarget) {\n  if (patch.title !== undefined) t.setTitle(patch.title);\n  if (patch.description !== undefined) t.setDescription(patch.description);\n  if (patch.price !== undefined) t.setPrice(patch.price);\n  if (patch.compareAtPrice !== undefined)\n    t.setCompareAtPrice(patch.compareAtPrice);\n\n  const next = { ...t.formValues };\n  if (patch.title !== undefined) next.title = patch.title;\n  if (patch.description !== undefined) next.description = patch.description;\n  if (patch.sku !== undefined) next.sku = patch.sku;\n  if (\n    patch.title !== undefined ||\n    patch.description !== undefined ||\n    patch.sku !== undefined\n  )\n    t.setFormValues(next);\n}\n"],"mappings":"AAkBO,SAAS,iBAAiB,OAAyB,GAAe;AACvE,MAAI,MAAM,UAAU,OAAW,GAAE,SAAS,MAAM,KAAK;AACrD,MAAI,MAAM,gBAAgB,OAAW,GAAE,eAAe,MAAM,WAAW;AACvE,MAAI,MAAM,UAAU,OAAW,GAAE,SAAS,MAAM,KAAK;AACrD,MAAI,MAAM,mBAAmB;AAC3B,MAAE,kBAAkB,MAAM,cAAc;AAE1C,QAAM,OAAO,EAAE,GAAG,EAAE,WAAW;AAC/B,MAAI,MAAM,UAAU,OAAW,MAAK,QAAQ,MAAM;AAClD,MAAI,MAAM,gBAAgB,OAAW,MAAK,cAAc,MAAM;AAC9D,MAAI,MAAM,QAAQ,OAAW,MAAK,MAAM,MAAM;AAC9C,MACE,MAAM,UAAU,UAChB,MAAM,gBAAgB,UACtB,MAAM,QAAQ;AAEd,MAAE,cAAc,IAAI;AACxB;","names":[]}

package/dist/product-editor/camera/camera-capture.d.ts

@@ -0,0 +1,23 @@
+export interface ScanOutcome {
+    ok: boolean;
+    message: string;
+}
+interface CameraCaptureProps {
+    open: boolean;
+    onClose: () => void;
+    /** A photo from the shutter, or files chosen instead. */
+    onPhotos: (files: File[]) => void;
+    /** A QR code was read. Resolves with what to tell the merchant. */
+    onScan: (text: string) => Promise<ScanOutcome>;
+}
+/**
+ * ONE VIEW, TWO WAYS IN.
+ *
+ * Like the phone's own camera: hold it over a product QR code and the code
+ * is read on its own; press the shutter and it is a photo. There is no mode
+ * switch to find first. A code that is read fills the item and the view
+ * closes on its own so the merchant sees what changed; a photo stays and
+ * the view stays open for the next one.
+ */
+export declare function CameraCapture({ open, onClose, onPhotos, onScan, }: CameraCaptureProps): import("react").ReactPortal | null;
+export {};