@drawnagency/primitives 0.1.118 → 0.1.119

package/src/deck-builder/DeckLibrary.tsx

@@ -1,195 +0,0 @@
-import { LayoutGridIcon, MoreVerticalIcon, PlusIcon } from "lucide-react";
-import { useRef, useState } from "react";
-import { Button } from "../components/shared/Button";
-import { IconButton } from "../components/shared/IconButton";
-import { Popover } from "../components/shared/Popover";
-import { PopoverItem } from "../components/shared/PopoverItem";
-import { cn } from "../lib/cn";
-import { formatTimestamp } from "../lib/timestamp";
-import type { DeckMediaAsset } from "../schemas/deck";
-import { DeckSlideSurface } from "./DeckSlideSurface";
-import type { DeckGridEntry } from "./types";
-
-/**
- * Builder mode's landing view (prototype variant A): a responsive grid of the
- * caller's own decks, each a 16:9 thumbnail with a status chip and a kebab, and
- * a designed empty state in place of the grid when there are none.
- *
- * Only "Private" exists as a status today — audience grants (#36) and Public
- * Links (#37) are what make the chip worth its space, and inventing their
- * labels now would be inventing their semantics.
- */
-interface Props {
-  entries: DeckGridEntry[];
-  mediaAssets: Record<string, DeckMediaAsset>;
-  canCreate: boolean;
-  onOpen: (id: string) => void;
-  onCreate: () => void;
-  onDelete: (id: string) => void;
-}
-
-export function DeckLibrary({ entries, mediaAssets, canCreate, onOpen, onCreate, onDelete }: Props) {
-  return (
-    <div className="mx-auto w-full max-w-screen-xl px-4 pt-8 pb-16">
-      {entries.length === 0 ? (
-        <DeckLibraryEmpty canCreate={canCreate} onCreate={onCreate} />
-      ) : (
-        <>
-          <div className="mb-5 flex flex-wrap items-center gap-3">
-            <h1 className="font-body text-lg font-semibold text-base-contrast">Your decks</h1>
-          </div>
-          <ul className="grid grid-cols-[repeat(auto-fill,minmax(16rem,1fr))] gap-x-4 gap-y-5">
-            {entries.map((entry) => (
-              <DeckCard
-                key={entry.id}
-                entry={entry}
-                mediaAssets={mediaAssets}
-                onOpen={() => onOpen(entry.id)}
-                onDelete={() => onDelete(entry.id)}
-              />
-            ))}
-          </ul>
-        </>
-      )}
-    </div>
-  );
-}
-
-function DeckLibraryEmpty({ canCreate, onCreate }: { canCreate: boolean; onCreate: () => void }) {
-  return (
-    <div className="grid min-h-[55vh] place-items-center px-4 py-12 text-center">
-      <div className="grid max-w-md justify-items-center gap-4">
-        <div className="grid aspect-video w-44 place-items-center rounded border border-dashed border-base-300 bg-base-accent">
-          <LayoutGridIcon size={16} className="text-base-300" aria-hidden="true" />
-        </div>
-        <h1 className="font-body text-lg font-semibold text-base-contrast">No decks yet</h1>
-        <p className="text-sm leading-relaxed text-base-contrast-light">
-          Decks are 16:9 presentations built from your brand's layouts. Start one and it stays on this device until you
-          publish it.
-        </p>
-        {canCreate && (
-          <Button size="md" onClick={onCreate}>
-            <PlusIcon size={16} className="mr-1.5" aria-hidden="true" />
-            New deck
-          </Button>
-        )}
-      </div>
-    </div>
-  );
-}
-
-function DeckCard({
-  entry,
-  mediaAssets,
-  onOpen,
-  onDelete,
-}: {
-  entry: DeckGridEntry;
-  mediaAssets: Record<string, DeckMediaAsset>;
-  onOpen: () => void;
-  onDelete: () => void;
-}) {
-  const [menuOpen, setMenuOpen] = useState(false);
-  const [confirming, setConfirming] = useState(false);
-  const kebabRef = useRef<HTMLButtonElement>(null);
-  const firstSlide = entry.draft?.deck.slides[0] ?? null;
-
-  return (
-    <li className="group relative">
-      {/* aria-hidden and unfocusable ON PURPOSE: a rendered slide can contain
-          real <button>s (the image grid's tiles are buttons), so the thumbnail
-          cannot BE a button, and duplicating the title control in the
-          accessibility tree would put two "Open …" targets on every card. The
-          title below is the announced control; this is its click target. */}
-      <div
-        aria-hidden="true"
-        onClick={onOpen}
-        className="w-full cursor-pointer overflow-hidden rounded border border-base-200 bg-base-accent transition-colors group-hover:border-primary"
-      >
-        {/* The real first slide when this browser has the deck staged; a plain
-            plate otherwise. Fetching every published deck's body just to draw a
-            grid of thumbnails would be a read per card — the listing route
-            deliberately reads only the meta sidecars. */}
-        <div className="pointer-events-none aspect-video w-full">
-          {firstSlide ? (
-            <DeckSlideSurface slide={firstSlide} mediaAssets={mediaAssets} className="h-full" />
-          ) : (
-            <div className="grid h-full place-items-center">
-              <LayoutGridIcon size={16} className="text-base-300" aria-hidden="true" />
-            </div>
-          )}
-        </div>
-      </div>
-
-      <div className="flex items-start gap-2 pt-2">
-        <button type="button" onClick={onOpen} className="min-w-0 flex-1 cursor-pointer text-left">
-          <span className="block truncate text-sm font-medium text-base-contrast">{entry.title}</span>
-          <span className="mt-0.5 block text-xs text-base-contrast-light">
-            {entry.slideCount} {entry.slideCount === 1 ? "slide" : "slides"} · {formatTimestamp(entry.updatedAt)}
-          </span>
-          <span className="mt-2 flex flex-wrap items-center gap-1.5">
-            <DeckStatusChip label="Private" dotClassName="bg-[var(--color-status-draft-text)]" />
-            {entry.unpublishedChanges && (
-              <DeckStatusChip label="Unpublished changes" dotClassName="bg-[var(--color-status-modified-text)]" />
-            )}
-          </span>
-        </button>
-
-        <IconButton
-          ref={kebabRef}
-          icon={<MoreVerticalIcon size={16} />}
-          label={`Actions for ${entry.title}`}
-          onClick={() => setMenuOpen((v) => !v)}
-          aria-haspopup="menu"
-          aria-expanded={menuOpen}
-        />
-        <Popover
-          isOpen={menuOpen}
-          onClose={() => {
-            setMenuOpen(false);
-            setConfirming(false);
-          }}
-          anchorRef={kebabRef}
-          align="end"
-          className="min-w-44 py-1"
-        >
-          {confirming ? (
-            <div className="px-3 py-2">
-              <p className="text-xs text-base-contrast-light">
-                Delete “{entry.title}”? {entry.published ? "The published deck is removed too." : "It has never been published."}
-              </p>
-              <div className="mt-2 flex justify-end gap-2">
-                <Button variant="ghost" onClick={() => setConfirming(false)}>
-                  Cancel
-                </Button>
-                <Button
-                  variant="destructive"
-                  onClick={() => {
-                    setMenuOpen(false);
-                    setConfirming(false);
-                    onDelete();
-                  }}
-                >
-                  Delete
-                </Button>
-              </div>
-            </div>
-          ) : (
-            <PopoverItem className="text-red-600" onClick={() => setConfirming(true)}>
-              Delete
-            </PopoverItem>
-          )}
-        </Popover>
-      </div>
-    </li>
-  );
-}
-
-function DeckStatusChip({ label, dotClassName }: { label: string; dotClassName: string }) {
-  return (
-    <span className="inline-flex items-center gap-1.5 rounded-full border border-base-200 px-2 py-0.5 align-middle text-xs font-medium text-base-contrast">
-      <span aria-hidden="true" className={cn("h-3 w-3 rounded-full border border-base", dotClassName)} />
-      {label}
-    </span>
-  );
-}

package/src/deck-builder/DeckSlideSurface.tsx

@@ -1,55 +0,0 @@
-import { useMemo } from "react";
-import { DeckMediaProvider, DeckSlideView, DeckStage, DeckTextEditProvider, type DeckTextEditor } from "../deck";
-import type { DeckMediaAsset, DeckMediaResolver, DeckSlide } from "../schemas/deck";
-
-// Re-exported rather than imported from `../deck` by its consumers: this file
-// is the builder's ONLY window onto the runtime (see the whitelist in
-// tests/deck/viewer-isolation.test.ts), and that stays true for types too.
-export type { DeckTextEditor };
-
-/**
- * The builder's one window onto the deck runtime — every other module in this
- * directory renders decks THROUGH this component and imports nothing from
- * `../deck` itself. That is deliberate: `tests/deck/viewer-isolation.test.ts`
- * whitelists the files that may reach the runtime, and keeping the list at one
- * entry is what keeps the whitelist reviewable.
- *
- * `DeckPlayer` is not used here because it owns its own slide index and slide
- * chrome, and in the builder the filmstrip owns both. This composes the same
- * three runtime pieces `DeckPlayer` does, which is why a thumbnail and the
- * stage render identically.
- */
-interface Props {
-  slide: DeckSlide;
-  /** Pre-resolved portal media, keyed by media id (see `deckMediaAssets`). */
-  mediaAssets: Record<string, DeckMediaAsset>;
-  /** Applied to the fit box the 16:9 stage is scaled into. */
-  className?: string;
-  /**
-   * Inline text editing (#39). Omitted everywhere but the editing view's own
-   * stage — filmstrip thumbnails, in-portal deck views and the Public Link
-   * route all render read-only, which is the acceptance criterion "nothing in
-   * this surface appears for read-only deck viewing" held at one place.
-   */
-  editor?: DeckTextEditor;
-}
-
-export function DeckSlideSurface({ slide, mediaAssets, className, editor }: Props) {
-  // `Object.hasOwn`, not indexing: a media id is author-supplied and a plain
-  // object answers "constructor" with something that is not an asset. Same
-  // guard DeckPlayer's own map-form resolver uses, for the same reason.
-  const resolve = useMemo<DeckMediaResolver>(
-    () => (ref) => (ref.kind === "portal" && Object.hasOwn(mediaAssets, ref.id) ? mediaAssets[ref.id] : null),
-    [mediaAssets],
-  );
-
-  return (
-    <DeckStage className={className}>
-      <DeckMediaProvider resolve={resolve}>
-        <DeckTextEditProvider editor={editor ?? null}>
-          <DeckSlideView slide={slide} />
-        </DeckTextEditProvider>
-      </DeckMediaProvider>
-    </DeckStage>
-  );
-}

package/src/deck-builder/deck-api.ts

@@ -1,177 +0,0 @@
-import { parseDeck, type Deck } from "../schemas/deck";
-
-/**
- * The builder's client for `/api/decks` (ADR 0002's routes).
- *
- * Every function returns a discriminated result instead of throwing, because
- * every failure mode here is one the UI has to SAY something specific about —
- * a 409 is not an error to log, it is a decision to put in front of the author.
- */
-
-/**
- * Just the sidecar fields the grid renders, narrowed from the response rather
- * than cast to `DeckMeta`.
- *
- * Deliberately NOT the whole sidecar and NOT `parseDeckMeta`: the meta schema
- * pins `schemaVersion` to a literal, so validating the full shape here would
- * make a portal running an older package version drop every deck from the
- * listing — silently, and exactly for the user whose decks they are. Reading
- * only what is displayed keeps a schema bump a non-event on this side.
- */
-export interface PublishedDeckMeta {
-  title: string;
-  slideCount: number;
-  updatedAt: string;
-}
-
-export interface PublishedDeckSummary {
-  id: string;
-  version: string;
-  /** null when the route reported the sidecar unreadable, or a field is missing. */
-  meta: PublishedDeckMeta | null;
-}
-
-function metaFrom(source: Record<string, unknown>): PublishedDeckMeta | null {
-  const { title, slideCount, updatedAt } = source;
-  if (typeof title !== "string" || title.length === 0) return null;
-  if (typeof slideCount !== "number" || !Number.isFinite(slideCount)) return null;
-  if (typeof updatedAt !== "string" || updatedAt.length === 0) return null;
-  return { title, slideCount, updatedAt };
-}
-
-export type DeckApiFailure =
-  /** 409 — the deck moved on the branch since this draft's baseVersion. */
-  | { kind: "conflict"; currentVersion: string | null; message: string }
-  /** 400 — the deck did not satisfy the schema. Per-path messages. */
-  | { kind: "invalid"; details: string[] }
-  /** 401/403 — not signed in, or not a Deck Creator. */
-  | { kind: "forbidden"; message: string }
-  /** 404 — no such deck, or not one this caller may see. */
-  | { kind: "notFound" }
-  /** 503 and transport failures — nothing was written and a retry is right. */
-  | { kind: "unavailable"; message: string }
-  | { kind: "failed"; message: string };
-
-export type DeckApiResult<T> = { ok: true; value: T } | ({ ok: false } & DeckApiFailure);
-
-async function body(res: Response): Promise<Record<string, unknown>> {
-  try {
-    return (await res.json()) as Record<string, unknown>;
-  } catch {
-    return {};
-  }
-}
-
-function messageFrom(data: Record<string, unknown>, fallback: string): string {
-  return typeof data.message === "string" ? data.message : fallback;
-}
-
-/** Maps a non-2xx response onto the failure the UI branches on. */
-async function failure(res: Response): Promise<{ ok: false } & DeckApiFailure> {
-  const data = await body(res);
-  switch (res.status) {
-    case 400:
-      return {
-        ok: false,
-        kind: "invalid",
-        details: Array.isArray(data.details) ? (data.details as string[]) : [messageFrom(data, "The deck is not valid.")],
-      };
-    case 401:
-    case 403:
-      return { ok: false, kind: "forbidden", message: messageFrom(data, "You are not allowed to do that.") };
-    case 404:
-      return { ok: false, kind: "notFound" };
-    case 409:
-      return {
-        ok: false,
-        kind: "conflict",
-        currentVersion: typeof data.currentVersion === "string" ? data.currentVersion : null,
-        message: messageFrom(data, "This deck changed since you loaded it."),
-      };
-    case 503:
-      return { ok: false, kind: "unavailable", message: "The deck store is busy. Try again in a moment." };
-    default:
-      return { ok: false, kind: "failed", message: messageFrom(data, `Request failed (${res.status}).`) };
-  }
-}
-
-/** A network error is indistinguishable from a 503 to the author: retry. */
-function transportFailure(): { ok: false } & DeckApiFailure {
-  return { ok: false, kind: "unavailable", message: "Could not reach the portal. Check your connection and try again." };
-}
-
-export async function listPublishedDecks(): Promise<DeckApiResult<PublishedDeckSummary[]>> {
-  let res: Response;
-  try {
-    res = await fetch("/api/decks");
-  } catch {
-    return transportFailure();
-  }
-  if (!res.ok) return failure(res);
-  const data = await body(res);
-  const raw = Array.isArray(data.decks) ? (data.decks as Record<string, unknown>[]) : [];
-  // The route answers a projection of the meta sidecar plus `version`; an entry
-  // whose sidecar it could not parse carries `invalid: true` and no fields, so
-  // read defensively rather than assuming the shape.
-  return {
-    ok: true,
-    value: raw.flatMap((entry) => {
-      const id = typeof entry.id === "string" ? entry.id : null;
-      const version = typeof entry.version === "string" ? entry.version : null;
-      if (!id || !version) return [];
-      return [{ id, version, meta: entry.invalid === true ? null : metaFrom(entry) }];
-    }),
-  };
-}
-
-export async function readPublishedDeck(
-  id: string,
-): Promise<DeckApiResult<{ deck: Deck; version: string; meta: PublishedDeckMeta | null }>> {
-  let res: Response;
-  try {
-    res = await fetch(`/api/decks/${encodeURIComponent(id)}`);
-  } catch {
-    return transportFailure();
-  }
-  if (!res.ok) return failure(res);
-  const data = await body(res);
-  const parsed = parseDeck(data.deck);
-  if (!parsed.ok) return { ok: false, kind: "invalid", details: parsed.errors };
-  if (typeof data.version !== "string") return { ok: false, kind: "failed", message: "The deck store returned no version." };
-  const meta = data.meta !== null && typeof data.meta === "object" ? metaFrom(data.meta as Record<string, unknown>) : null;
-  return { ok: true, value: { deck: parsed.deck, version: data.version, meta } };
-}
-
-export async function publishDeck(
-  deck: Deck,
-  baseVersion: string | null,
-): Promise<DeckApiResult<{ version: string; meta: PublishedDeckMeta | null }>> {
-  let res: Response;
-  try {
-    res = await fetch("/api/decks", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ deck, baseVersion }),
-    });
-  } catch {
-    return transportFailure();
-  }
-  if (!res.ok) return failure(res);
-  const data = await body(res);
-  if (typeof data.version !== "string") return { ok: false, kind: "failed", message: "The deck store returned no version." };
-  const meta = data.meta !== null && typeof data.meta === "object" ? metaFrom(data.meta as Record<string, unknown>) : null;
-  return { ok: true, value: { version: data.version, meta } };
-}
-
-export async function deletePublishedDeck(id: string): Promise<DeckApiResult<true>> {
-  let res: Response;
-  try {
-    res = await fetch(`/api/decks/${encodeURIComponent(id)}`, { method: "DELETE" });
-  } catch {
-    return transportFailure();
-  }
-  // A deck that is not there is already deleted — the caller wanted it gone.
-  if (res.status === 404) return { ok: true, value: true };
-  if (!res.ok) return failure(res);
-  return { ok: true, value: true };
-}

package/src/deck-builder/deck-chat-client.ts

@@ -1,129 +0,0 @@
-import { parseDeck, type Deck } from "../schemas/deck";
-
-/**
- * The builder's client for `POST /api/deck-chat` (#35).
- *
- * The route's event contract, and what each event means to the UI:
- *
- *   text   { text }              a delta of the assistant's prose
- *   retry  { attempt, issues }   the model's deck failed validation and it is
- *                                being asked to fix it — DISCARD the prose
- *                                streamed so far, or the transcript shows two
- *                                answers for one turn
- *   deck   { deck }              a deck that PARSED server-side; stage it
- *   error  { error, details? }   the turn produced no usable deck
- *   done   { truncated }         end of turn (always last)
- *
- * A turn with no `deck` event is not a failure: the assistant is allowed to
- * answer a question without rewriting the deck.
- */
-
-export interface DeckChatMessage {
-  role: "user" | "assistant";
-  content: string;
-}
-
-export interface DeckChatHandlers {
-  onText: (delta: string) => void;
-  /** Prose from the failed attempt must be dropped before the next one streams. */
-  onRetry: (attempt: number, issues: string[]) => void;
-}
-
-export type DeckChatResult =
-  | { ok: true; deck: Deck | null; truncated: boolean }
-  | { ok: false; error: string; details?: string[]; retryAfterMs?: number };
-
-export const DECK_CHAT_ERROR_COPY: Record<string, string> = {
-  rate_limited: "You've hit the deck-building limit — try again later.",
-  disabled: "Deck building isn't available on this site right now.",
-  not_authorized: "You don't have access to build decks here.",
-  invalid_deck: "The assistant couldn't produce a valid deck. Your deck is unchanged — try describing the change differently.",
-  // The opposite problem, and it must not read like the one above: this deck is
-  // the one already staged on this device, so rewording the request changes
-  // nothing. Deliberately prescribes NO fix — "reopen it" is a dead end for a
-  // draft that was never published, since there is no server copy to re-read
-  // and the open path never clobbers a local draft anyway. A real repair
-  // affordance (discard this draft) is #39-shaped.
-  bad_deck: "The copy of this deck saved on this device isn't valid, so the assistant can't work on it.",
-  stream_truncated: "The assistant's deck was too long to finish. Your deck is unchanged — try asking for fewer slides.",
-  upstream_error: "Something went wrong — please try again.",
-};
-
-/** `bad_deck` is deliberately absent: it fails identically on every attempt, so
- *  a Try again button would only loop the user through the same 400. */
-const RETRYABLE = new Set(["rate_limited", "upstream_error", "invalid_deck", "stream_truncated"]);
-
-export function deckChatCanRetry(error: string): boolean {
-  return RETRYABLE.has(error);
-}
-
-export async function streamDeckChat(
-  body: { deck: Deck; messages: DeckChatMessage[] },
-  handlers: DeckChatHandlers,
-  signal?: AbortSignal,
-): Promise<DeckChatResult> {
-  let res: Response;
-  try {
-    res = await fetch("/api/deck-chat", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body),
-      signal,
-    });
-  } catch {
-    if (signal?.aborted) return { ok: true, deck: null, truncated: false };
-    return { ok: false, error: "upstream_error" };
-  }
-  if (!res.ok || !res.body) {
-    const err = (await res.json().catch(() => ({}))) as { error?: string; details?: string[]; retryAfterMs?: number };
-    return { ok: false, error: err.error ?? "upstream_error", details: err.details, retryAfterMs: err.retryAfterMs };
-  }
-
-  const reader = res.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let deck: Deck | null = null;
-  let truncated = false;
-  let failure: { error: string; details?: string[] } | null = null;
-  try {
-    for (;;) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      let sep: number;
-      while ((sep = buffer.indexOf("\n\n")) !== -1) {
-        const frame = buffer.slice(0, sep);
-        buffer = buffer.slice(sep + 2);
-        const event = /^event: (.+)$/m.exec(frame)?.[1];
-        const raw = /^data: (.+)$/m.exec(frame)?.[1];
-        if (!event || !raw) continue;
-        let data: { text?: string; deck?: unknown; error?: string; details?: string[]; truncated?: boolean; attempt?: number; issues?: string[] };
-        try {
-          data = JSON.parse(raw);
-        } catch {
-          continue; // malformed frame — skip
-        }
-        if (event === "text" && typeof data.text === "string") handlers.onText(data.text);
-        else if (event === "retry") handlers.onRetry(data.attempt ?? 0, data.issues ?? []);
-        else if (event === "deck") {
-          // The route already validated this against the same schema. Parsing
-          // again is not distrust of the route — it is what turns `unknown` off
-          // the wire into a `Deck` the Dexie writer can be handed without a cast.
-          const parsed = parseDeck(data.deck);
-          if (parsed.ok) deck = parsed.deck;
-          else failure = { error: "invalid_deck", details: parsed.errors };
-        } else if (event === "error") failure = { error: data.error ?? "upstream_error", details: data.details };
-        else if (event === "done") truncated = data.truncated === true;
-      }
-    }
-  } catch {
-    // A user-initiated stop is a clean finish: whatever streamed stays, and a
-    // deck that already arrived is still good.
-    if (!signal?.aborted) return { ok: false, error: "upstream_error" };
-  }
-  // A deck that arrived wins over a late error: the route emits at most one
-  // outcome per turn, and applying a valid deck is never the wrong move.
-  if (deck) return { ok: true, deck, truncated };
-  if (failure) return { ok: false, ...failure };
-  return { ok: true, deck: null, truncated };
-}

package/src/deck-builder/deck-chat-history.ts

@@ -1,62 +0,0 @@
-import type { DeckChatMessage } from "./deck-chat-client";
-
-/**
- * Per-deck conversation persistence for the Deck Builder assistant (#35).
- *
- * localStorage, like the brand chat's archive (`components/chat/chat-history`)
- * — the server keeps no conversation state (ADR 0002), so the transcript is the
- * browser's or it is nowhere.
- *
- * SCOPED BY DECK AND BY IDENTITY, exactly as the Deck Draft is (`deckDraftScope`).
- * A browser profile is shared between people far more often than an account is,
- * and a deck's conversation is unpublished work: keyed by deck alone, the next
- * person to sign in on the same machine would read it. The scope value is the
- * same digest the draft database name uses — never a raw username.
- */
-
-const KEY_PREFIX = "bp-deck-chat";
-/** Turns kept per deck. A turn is a user line plus a reply; 60 is a long
- *  authoring session and still a bounded localStorage footprint. */
-export const DECK_CHAT_MESSAGE_CAP = 60;
-
-function key(scope: string, deckId: string): string {
-  return `${KEY_PREFIX}:${scope}:${deckId}`;
-}
-
-function isMessage(m: unknown): m is DeckChatMessage {
-  return (
-    !!m &&
-    typeof m === "object" &&
-    ((m as DeckChatMessage).role === "user" || (m as DeckChatMessage).role === "assistant") &&
-    typeof (m as DeckChatMessage).content === "string"
-  );
-}
-
-export function loadDeckChat(scope: string, deckId: string): DeckChatMessage[] {
-  try {
-    const parsed: unknown = JSON.parse(window.localStorage.getItem(key(scope, deckId)) ?? "[]");
-    return Array.isArray(parsed) ? parsed.filter(isMessage).slice(-DECK_CHAT_MESSAGE_CAP) : [];
-  } catch {
-    return [];
-  }
-}
-
-/** Empty turns (the mid-stream assistant stub) are never stored. */
-export function saveDeckChat(scope: string, deckId: string, messages: DeckChatMessage[]): void {
-  const stored = messages.filter((m) => m.content !== "").slice(-DECK_CHAT_MESSAGE_CAP);
-  try {
-    if (stored.length === 0) window.localStorage.removeItem(key(scope, deckId));
-    else window.localStorage.setItem(key(scope, deckId), JSON.stringify(stored));
-  } catch {
-    /* storage unavailable or full — the transcript just won't survive a reload */
-  }
-}
-
-/** Called when a deck is deleted: its conversation goes with it. */
-export function clearDeckChat(scope: string, deckId: string): void {
-  try {
-    window.localStorage.removeItem(key(scope, deckId));
-  } catch {
-    /* nothing to do — the entry is unreachable either way */
-  }
-}

package/src/deck-builder/index.ts

@@ -1,12 +0,0 @@
-/**
- * The Deck Builder — a sealed subtree like ./deck and ./document.
- *
- * NOT re-exported from the primitives root barrel: this graph reaches the deck
- * runtime, and nothing on an ordinary viewer page may pull that in. Only the
- * builder route (`core/src/pages/decks.astro`) imports from here, as a
- * `client:only` island, so the whole thing is paid for by opening the builder
- * and by nothing else.
- */
-export { DeckBuilderApp } from "./DeckBuilderApp";
-export { starterDeck, newDeckId } from "./starter-deck";
-export type { DeckGridEntry } from "./types";