@drawnagency/primitives 0.1.118 → 0.1.120

package/src/lib/deck-dexie.ts

@@ -1,190 +0,0 @@
-import Dexie from "dexie";
-import { serializeDeck, type Deck } from "../schemas/deck";
-
-/**
- * Deck Draft staging — the deck builder's half of the editor's unsaved-state
- * model (`./dexie.ts`), and the reason the authoring loop performs no server
- * writes at all (ADR 0002). A draft lives in this browser only until an
- * explicit publish; nothing here ever talks to the network.
- *
- * A SEPARATE database from the editor's `brand-portal-{siteId}`, not a table on
- * it. The builder is a VIEWER surface: opening the editor's connection from it
- * would run the editor's upgrade chain (11 versions, several of which clear
- * caches) in a viewer's browser, and would hold a connection open that blocks
- * the editor's next schema bump. Nothing here needs the editor's rows.
- *
- * Keyed by site AND by identity scope (`deckDraftScope`). One browser profile
- * routinely serves several people, and drafts are unpublished work — see that
- * function for what the scope is, why it is a digest, and what happens to the
- * databases an identity leaves behind.
- */
-
-export interface DeckDraftRow {
-  /** Deck id — also the directory name on the decks branch. */
-  deckId: string;
-  deck: Deck;
-  /**
-   * The published version this draft was based on, and the `baseVersion` the
-   * next publish sends. `null` means the deck has never been published, which
-   * is exactly what POST /api/decks wants to be told to create it.
-   */
-  baseVersion: string | null;
-  /**
-   * The published deck's serialized bytes AT `baseVersion`, or null when it has
-   * never been published. Stored rather than a dirty flag because the flag has
-   * to survive a reload, and re-deriving it would mean a server read — which is
-   * the one thing a draft must not need. Comparing bytes also makes an
-   * edit-then-undo correctly report "no unpublished changes".
-   */
-  publishedText: string | null;
-  updatedAt: string;
-}
-
-class DeckDraftDatabase extends Dexie {
-  drafts!: Dexie.Table<DeckDraftRow, string>;
-
-  constructor(name: string) {
-    super(name);
-    this.version(1).stores({ drafts: "deckId" });
-  }
-}
-
-/** `scope` is a `deckDraftScope` digest — never a raw username or user id. */
-function databaseName(siteId: string, scope: string): string {
-  return `brand-portal-decks-${siteId}-${scope}`;
-}
-
-let db: DeckDraftDatabase | null = null;
-
-export function initDeckDraftStore(siteId: string, scope: string): void {
-  const name = databaseName(siteId, scope);
-  // Re-initialising for the database we already hold is a no-op — replacing the
-  // instance would leave the old connection open, and an open connection on the
-  // previous version is what makes the next schema bump hang on `blocked`.
-  // (Same reasoning as initEditorStore.) Switching identity DOES replace it,
-  // which is the point: the previous identity's rows become unreachable here.
-  if (db?.name === name) return;
-  db?.close();
-  db = new DeckDraftDatabase(name);
-}
-
-function getDb(): DeckDraftDatabase {
-  if (!db) throw new Error("Deck draft store not initialized. Call initDeckDraftStore first.");
-  return db;
-}
-
-/** Every staged draft, newest first. Drives the builder's deck grid. */
-export async function listDeckDrafts(): Promise<DeckDraftRow[]> {
-  const rows = await getDb().drafts.toArray();
-  return rows.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-}
-
-export async function getDeckDraft(deckId: string): Promise<DeckDraftRow | null> {
-  return (await getDb().drafts.get(deckId)) ?? null;
-}
-
-/**
- * Stage a deck edit. `baseVersion`/`publishedText` are carried forward from the
- * existing row rather than taken as arguments: an edit never changes what the
- * server holds, and letting a caller pass them is how a draft would come to
- * claim it was published when it was not.
- */
-export async function putDeckDraft(deck: Deck): Promise<DeckDraftRow> {
-  const db = getDb();
-  // Transactional, not get-then-put: this races `recordDeckPublish` on exactly
-  // the fields it carries forward. Two overlapping read-modify-writes both
-  // reading the pre-publish row would revert `baseVersion` to null, and the next
-  // publish would then send `baseVersion: null` for a deck that already exists —
-  // a 409 the author cannot explain. IDB serializes readwrite transactions on
-  // the store, so the two can only ever run one after the other.
-  return db.transaction("rw", db.drafts, async () => {
-    const existing = await db.drafts.get(deck.id);
-    const row: DeckDraftRow = {
-      deckId: deck.id,
-      deck,
-      baseVersion: existing?.baseVersion ?? null,
-      publishedText: existing?.publishedText ?? null,
-      updatedAt: new Date().toISOString(),
-    };
-    await db.drafts.put(row);
-    return row;
-  });
-}
-
-/**
- * Record what the server now holds — after a publish, or after loading a
- * published deck into the draft. The deck body is restated from `deck` so the
- * row and its published baseline can never disagree.
- *
- * `updatedAt` is an argument because the two callers mean different things by
- * it. A publish genuinely changed the deck, so "now" is right. Merely OPENING a
- * published deck changes nothing, and stamping "now" there sorted it to the top
- * of the grid — reading a deck must not reorder the library — so that caller
- * passes the sidecar's own timestamp.
- */
-export async function markDeckDraftPublished(deck: Deck, version: string, updatedAt?: string): Promise<DeckDraftRow> {
-  const row: DeckDraftRow = {
-    deckId: deck.id,
-    deck,
-    baseVersion: version,
-    publishedText: serializeDeck(deck),
-    updatedAt: updatedAt ?? new Date().toISOString(),
-  };
-  await getDb().drafts.put(row);
-  return row;
-}
-
-/**
- * Record a successful publish WITHOUT touching the working deck (#39).
- *
- * The difference from `markDeckDraftPublished` is the whole point: that
- * function restates the body from its argument, which is a pre-request snapshot
- * at the publish call site, so an edit landing during the round-trip was
- * silently discarded. #35 could answer that with a lock because its only other
- * writer was a chat turn; inline editing cannot — locking a text field the
- * author is mid-word in is worse than the race it prevents.
- *
- * So this re-reads the row and writes back only the publish BASELINE: what the
- * server now holds (`baseVersion`) and the bytes it holds (`publishedText`,
- * serialized from the deck that was actually sent). `deck` stays whatever is
- * current by now, which makes `hasUnpublishedChanges` correctly report the
- * mid-flight edit as unpublished rather than losing it.
- *
- * Returns null when the row is gone (deleted during the round-trip) — recreating
- * it would resurrect a deck the author just removed.
- */
-export async function recordDeckPublish(deckId: string, publishedDeck: Deck, version: string): Promise<DeckDraftRow | null> {
-  const db = getDb();
-  // Transactional for the same reason `putDeckDraft` is, and it is the half
-  // that bites hardest: an inline commit whose put lands between this read and
-  // this write is REVERTED here — the row goes back to the pre-edit deck with a
-  // matching `publishedText`, so the edit is gone AND the deck reports itself
-  // clean. Re-reading inside the transaction is what makes "leave `deck` alone"
-  // mean the deck as of the write, not as of the request.
-  return db.transaction("rw", db.drafts, async () => {
-    const existing = await db.drafts.get(deckId);
-    if (!existing) return null;
-    const row: DeckDraftRow = {
-      ...existing,
-      baseVersion: version,
-      publishedText: serializeDeck(publishedDeck),
-      // "Now", as the previous implementation stamped: a publish is activity the
-      // deck grid should sort on, even though it did not change the body.
-      updatedAt: new Date().toISOString(),
-    };
-    await db.drafts.put(row);
-    return row;
-  });
-}
-
-export async function deleteDeckDraft(deckId: string): Promise<void> {
-  await getDb().drafts.delete(deckId);
-}
-
-/**
- * Does this row differ from what was published? A never-published draft always
- * has changes — there is nothing on the server to match.
- */
-export function hasUnpublishedChanges(row: DeckDraftRow): boolean {
-  return row.publishedText === null || serializeDeck(row.deck) !== row.publishedText;
-}

package/src/lib/deck-edit.ts

@@ -1,196 +0,0 @@
-import {
-  parseDeck,
-  type Deck,
-  type DeckComponent,
-  type DeckRichText,
-  type DeckSlide,
-} from "../schemas/deck";
-
-/**
- * Direct-manipulation edits to a Deck Draft (#39).
- *
- * Every operation here is PURE and ends in `parseDeck`, which is what makes
- * "a manual edit is always schema-valid" a property of this module rather than
- * of its callers. It also means the schema owns the refusals: duplicating past
- * `DECK_MAX_SLIDES` and deleting the last slide are reported with the same
- * messages the authoring loop's validation retry reads, not with a second copy
- * of those rules written here.
- *
- * The scope line is the product decision recorded in CONTEXT.md — "chat
- * authors, direct manipulation adjusts". There is deliberately no operation
- * here that changes a Layout, adds or removes a Deck Component, or composes a
- * grid. Text leaves and slide order are the whole vocabulary.
- */
-
-/**
- * Which Deck Component within a slide's Layout. A slide-local coordinate: the
- * runtime renders one slide and has no idea which one, so the slide index stays
- * an argument at the call site.
- */
-// Module-private VALUES, exported types only. The deck runtime imports
-// `DeckTextPath` from here, and `import type` is erased — exporting the arrays
-// would offer a value import that pulls this module, and the deck schema and
-// zod behind it, into the runtime chunk served to Public Link readers. Neither
-// fence would see it: the unit test cannot tell a type import from a value one
-// and excludes the runtime subtree anyway.
-const DECK_TEXT_SLOTS = ["content", "overlay", "left", "right"] as const;
-export type DeckTextSlot = (typeof DECK_TEXT_SLOTS)[number];
-
-const DECK_TEXT_FIELDS = ["kicker", "heading", "subheading", "paragraphs", "bullets"] as const;
-export type DeckTextField = (typeof DECK_TEXT_FIELDS)[number];
-
-/**
- * A single editable text LEAF — always a plain string in the schema.
- *
- * That "always a leaf" framing is what keeps inline editing free of a
- * formatting UI without ever destroying a mark: a paragraph carrying spans is
- * edited one span at a time (`span`), so `bold`/`italic` are untouched by an
- * edit that only ever writes `text`. A plain-string line has no `span`.
- */
-export interface DeckTextPath {
-  slot: DeckTextSlot;
-  field: DeckTextField;
-  /** Index into `paragraphs`/`bullets`. Absent for the three single-line fields. */
-  line?: number;
-  /** Index into that line's spans, when the line is a span run rather than a string. */
-  span?: number;
-}
-
-export type DeckEditResult = { ok: true; deck: Deck } | { ok: false; errors: string[] };
-
-/** A path that points at nothing is a bug in the caller, not author input. */
-function unresolved(path: DeckTextPath): DeckEditResult {
-  return {
-    ok: false,
-    errors: [`no editable text at ${path.slot}.${path.field}${path.line === undefined ? "" : `[${path.line}]`}`],
-  };
-}
-
-/** The rich text a slot holds, or null when that slot holds something else. */
-export function richTextAt(slide: DeckSlide, slot: DeckTextSlot): DeckRichText | null {
-  const { layout } = slide;
-  if (layout.type === "centeredText") {
-    return slot === "content" && layout.content.type === "richText" ? layout.content : null;
-  }
-  if (layout.type === "fullBleedImage") {
-    return slot === "overlay" ? (layout.overlay?.content ?? null) : null;
-  }
-  if (slot !== "left" && slot !== "right") return null;
-  const component: DeckComponent = layout[slot];
-  return component.type === "richText" ? component : null;
-}
-
-/** The same addressing, as a setter. Returns null when the slot has no rich text. */
-function withRichTextAt(slide: DeckSlide, slot: DeckTextSlot, next: DeckRichText): DeckSlide | null {
-  const { layout } = slide;
-  if (layout.type === "centeredText") {
-    if (slot !== "content" || layout.content.type !== "richText") return null;
-    return { ...slide, layout: { ...layout, content: next } };
-  }
-  if (layout.type === "fullBleedImage") {
-    if (slot !== "overlay" || layout.overlay === undefined) return null;
-    return { ...slide, layout: { ...layout, overlay: { ...layout.overlay, content: next } } };
-  }
-  if (slot !== "left" && slot !== "right") return null;
-  if (layout[slot].type !== "richText") return null;
-  return { ...slide, layout: { ...layout, [slot]: next } };
-}
-
-/** Writes `text` into the addressed leaf, or null when the path resolves to nothing. */
-function withLeafText(content: DeckRichText, path: DeckTextPath, text: string): DeckRichText | null {
-  if (path.field === "kicker" || path.field === "heading" || path.field === "subheading") {
-    // Only a field that is already present is editable — a blank line the
-    // author never wrote is not a place to click, and inventing one here would
-    // be the structural editing this module does not do.
-    if (content[path.field] === undefined) return null;
-    return { ...content, [path.field]: text };
-  }
-
-  const lines = content[path.field];
-  if (lines === undefined || path.line === undefined || path.line < 0 || path.line >= lines.length) return null;
-
-  const nextLines = lines.slice();
-  const line = nextLines[path.line];
-
-  if (path.span === undefined) {
-    if (typeof line !== "string") return null;
-    nextLines[path.line] = text;
-  } else {
-    if (typeof line === "string" || path.span < 0 || path.span >= line.length) return null;
-    const spans = line.slice();
-    spans[path.span] = { ...spans[path.span], text };
-    nextLines[path.line] = spans;
-  }
-
-  return { ...content, [path.field]: nextLines };
-}
-
-/**
- * Commit an inline text edit.
- *
- * Rejecting (rather than clamping) an over-long or emptied field is deliberate:
- * the caps are the schema's, and a silent truncation is an edit the author did
- * not make. The caller shows the schema's own message and leaves the draft
- * untouched.
- */
-export function applyDeckTextEdit(deck: Deck, slideIndex: number, path: DeckTextPath, text: string): DeckEditResult {
-  const slide = deck.slides[slideIndex];
-  if (slide === undefined) return { ok: false, errors: [`no slide at index ${slideIndex}`] };
-
-  const content = richTextAt(slide, path.slot);
-  if (content === null) return unresolved(path);
-
-  const nextContent = withLeafText(content, path, text);
-  if (nextContent === null) return unresolved(path);
-
-  const nextSlide = withRichTextAt(slide, path.slot, nextContent);
-  if (nextSlide === null) return unresolved(path);
-
-  const slides = deck.slides.slice();
-  slides[slideIndex] = nextSlide;
-  return parseDeck({ ...deck, slides });
-}
-
-/** Move a slide to a new index. `to` is the destination in the POST-removal list. */
-export function moveDeckSlide(deck: Deck, from: number, to: number): DeckEditResult {
-  if (from < 0 || from >= deck.slides.length) return { ok: false, errors: [`no slide at index ${from}`] };
-  if (to < 0 || to >= deck.slides.length) return { ok: false, errors: [`cannot move a slide to index ${to}`] };
-  const slides = deck.slides.slice();
-  const [moved] = slides.splice(from, 1);
-  slides.splice(to, 0, moved);
-  return parseDeck({ ...deck, slides });
-}
-
-/**
- * A fresh slide id for a copy. Ids are unique within a deck (the schema refuses
- * a duplicate by name) and double as diff anchors across revisions, so a copy
- * has to be given its own rather than inheriting one.
- */
-function copySlideId(sourceId: string, taken: ReadonlySet<string>): string {
-  // Copying a copy chains "-copy-2", not "-copy-copy". The slice keeps room for
-  // the suffix inside DeckIdSchema's 64-character cap.
-  const stem = sourceId.replace(/-copy(-\d+)?$/, "").slice(0, 52).replace(/-+$/, "") || "slide";
-  let candidate = `${stem}-copy`;
-  for (let n = 2; taken.has(candidate); n++) candidate = `${stem}-copy-${n}`;
-  return candidate;
-}
-
-/** Duplicate a slide, inserting the copy directly after the original. */
-export function duplicateDeckSlide(deck: Deck, index: number): DeckEditResult {
-  const source = deck.slides[index];
-  if (source === undefined) return { ok: false, errors: [`no slide at index ${index}`] };
-  const copy: DeckSlide = {
-    ...structuredClone(source),
-    id: copySlideId(source.id, new Set(deck.slides.map((s) => s.id))),
-  };
-  const slides = deck.slides.slice();
-  slides.splice(index + 1, 0, copy);
-  return parseDeck({ ...deck, slides });
-}
-
-/** Remove a slide. Removing the only one is refused by the schema, by design. */
-export function removeDeckSlide(deck: Deck, index: number): DeckEditResult {
-  if (deck.slides[index] === undefined) return { ok: false, errors: [`no slide at index ${index}`] };
-  const slides = deck.slides.filter((_, i) => i !== index);
-  return parseDeck({ ...deck, slides });
-}

package/src/lib/deck-media-assets.ts

@@ -1,57 +0,0 @@
-import type { DeckMediaAsset } from "../schemas/deck";
-import type { MediaManifest } from "../media/types";
-import type { MediaProvider } from "../media/provider";
-
-/**
- * The production side of the deck runtime's media seam: the site's image
- * manifest, resolved to the `mediaAssets` map `DeckPlayer` takes.
- *
- * A MAP, not a `DeckMediaResolver` function, because the builder mounts across
- * an Astro island boundary and a function prop cannot survive that trip. It is
- * built server-side, where the manifest and the media provider live.
- *
- * This replaces the dev preview route's generated plates
- * (`core/src/lib/dev-deck-preview.ts`), which stay exactly where they are —
- * they keep that route working offline and with no GitHub credentials.
- */
-export function deckMediaAssets(
-  manifest: MediaManifest,
-  sizes: number[],
-  provider: MediaProvider,
-  /**
-   * The audience boundary, when the caller has one. Only these ids resolve.
-   *
-   * The builder's map must match the catalog the model is offered (#35, decided
-   * 2026-08-07) or the two disagree about what exists — and because this map
-   * travels as ISLAND PROPS, an unfiltered one also puts every asset's filename
-   * and alt text in the page source of a creator who cannot see those pages.
-   * Omitted means no filtering, which is what the dev preview route wants.
-   */
-  allowIds?: ReadonlySet<string>,
-): Record<string, DeckMediaAsset> {
-  const assets: Record<string, DeckMediaAsset> = {};
-  for (const [id, item] of Object.entries(manifest.images)) {
-    // System-generated assets (the social-preview raster) are excluded from the
-    // media library UI, so they are not part of the catalog a deck may cite.
-    if (item.hidden) continue;
-    if (allowIds && !allowIds.has(id)) continue;
-    const resolved = provider.resolve(item, sizes);
-    // An unresolvable entry is simply absent, which the runtime already renders
-    // as a quiet gap — the same thing a deleted asset produces.
-    if (!resolved) continue;
-    assets[id] = {
-      src: resolved.src,
-      alt: item.alt,
-      // The manifest always knows the intrinsic size, and supplying it is what
-      // lets the image grid reserve aspect-correct space before a byte loads.
-      width: resolved.width,
-      height: resolved.height,
-      ...(resolved.tag === "video" && resolved.poster ? { poster: resolved.poster } : {}),
-    };
-  }
-  // A plain object, and that is safe because every reader guards its lookups
-  // with `Object.hasOwn` (DeckPlayer's map resolver, DeckSlideSurface) and the
-  // deck schema constrains a media id's charset. A null-prototype object would
-  // also have to be re-spread to survive Astro's prop serialization.
-  return assets;
-}

package/src/lib/deck-media-refs.ts

@@ -1,67 +0,0 @@
-/**
- * Every portal media reference a deck makes, extracted from RAW deck JSON.
- *
- * Publish-time GC builds its keep-set from the site's manifests and deletes
- * every other bucket object (ADR 0002's "GC must learn the decks branch"), so a
- * deck referencing an asset the editor later removed from portal content would
- * otherwise have its media deleted underneath it.
- *
- * Deliberately untyped and structural rather than a walk over `Deck`: the media
- * reference union lands with the image/grid components (#31), and this has to
- * work the day it does without a second change here. It matches the union's
- * discriminator shape — `{ kind: "portal", id: string }` — wherever it appears
- * in the tree, at any depth, in any component. Staying schema-free is also what
- * keeps this module off the deck-schema carrier list (tests/deck/viewer-isolation).
- */
-
-/** One reference, with the path an author (or a model) can act on. */
-export interface DeckMediaRefSite {
-  /** `slides[2].layout.media` — the ref object's own path, not its `id` field. */
-  path: string;
-  id: string;
-}
-
-function step(path: string, key: string): string {
-  return path === "" ? key : `${path}.${key}`;
-}
-
-export function deckMediaRefSites(deck: unknown): DeckMediaRefSite[] {
-  const sites: DeckMediaRefSite[] = [];
-  const visit = (node: unknown, path: string): void => {
-    if (Array.isArray(node)) {
-      node.forEach((item, i) => visit(item, `${path}[${i}]`));
-      return;
-    }
-    if (typeof node !== "object" || node === null) return;
-    const record = node as Record<string, unknown>;
-    if (record.kind === "portal" && typeof record.id === "string" && record.id !== "") {
-      sites.push({ path, id: record.id });
-    }
-    for (const [key, value] of Object.entries(record)) visit(value, step(path, key));
-  };
-  visit(deck, "");
-  return sites;
-}
-
-export function deckMediaIds(deck: unknown): Set<string> {
-  return new Set(deckMediaRefSites(deck).map((site) => site.id));
-}
-
-/**
- * Media references the catalog does not contain — the server-side half of media
- * grounding (#35).
- *
- * The deck schema constrains a media id's CHARSET; only the catalog can say
- * whether an id exists, so membership is checked here rather than in the schema
- * (which is also read by the runtime, where no catalog is in hand). One line per
- * offending reference, in the same `path: message` shape `formatDeckIssues`
- * produces, so the authoring loop can hand both lists back in one tool_result.
- */
-export function deckUnknownMediaIssues(deck: unknown, catalogIds: ReadonlySet<string>): string[] {
-  return deckMediaRefSites(deck)
-    .filter((site) => !catalogIds.has(site.id))
-    .map(
-      (site) =>
-        `${step(site.path, "id")}: "${site.id}" is not in the portal media catalog — use only the ids listed under "Media catalog", copied exactly.`,
-    );
-}

package/src/lib/deck-tool.ts

@@ -1,95 +0,0 @@
-import { z } from "zod";
-import {
-  DECK_COMPONENT_TYPES,
-  DECK_LAYOUT_TYPES,
-  DECK_MAX_SLIDES,
-  DECK_SCHEMA_VERSION,
-  DeckSchema,
-} from "../schemas/deck";
-
-/**
- * The `update_deck` tool the deck-chat loop hands the model (#35, ADR 0001).
- *
- * The input schema is DERIVED from `DeckSchema` rather than written out, so the
- * contract cannot drift from what the server will actually accept: every
- * `.describe()` in the deck schema IS the LLM's documentation, and a field
- * added there reaches the model on the next request with no second edit here.
- *
- * Emitted INLINE (zod's default `reused: "inline"`), not with `$defs`/`$ref`.
- * The ref form is less than half the bytes, but names every shared node
- * `__schema7`, which puts the layout and component descriptions an indirection
- * away from the slot that uses them. The tool block sits in the cached prefix
- * (tools precede `system`, and the corpus block carries the cache breakpoint),
- * so the size is paid once per conversation while the legibility is paid on
- * every turn.
- */
-
-export const UPDATE_DECK_TOOL_NAME = "update_deck";
-
-export interface DeckToolDefinition {
-  name: string;
-  description: string;
-  /** JSON Schema; the tool's input IS the whole deck. */
-  input_schema: Record<string, unknown>;
-}
-
-/**
- * The vocabulary, spelled out in prose above the schema.
- *
- * The derived JSON Schema already carries it, but only as `const` values buried
- * in nested `anyOf` branches — and live authoring showed the model guessing
- * layout and component types from there, burning validation retries on
- * "unknown layout type" and sometimes exhausting them. A flat list costs a few
- * dozen tokens in the cached tool block and removes the guess.
- *
- * The type names come from the schema's own constants, so a new Layout or
- * Component cannot be added without appearing here; the slot shapes are spelled
- * out because they are structure, not a list — `tests/deck/deck-tool.test.ts`
- * pins that every name in both constants is mentioned.
- */
-const VOCABULARY = [
-  `Layouts (a slide uses exactly one, and \`type\` must be one of these ${DECK_LAYOUT_TYPES.length}): ${DECK_LAYOUT_TYPES.map((t) => `\`${t}\``).join(", ")}.`,
-  "- `centeredText` — a title card. Slot: `content` (one Component). Optional `background`: `base` or `brand`.",
-  "- `fullBleedImage` — the image IS the slide. Takes `media` directly, plus an optional `overlay` panel whose `content` must be a `richText` Component. It has no other slots.",
-  "- `columnSplit` — two slots, `left` and `right`, each one Component, at a `ratio` of `1-2` or `2-1`.",
-  "",
-  `Components (what fills a Layout slot; \`type\` must be one of these ${DECK_COMPONENT_TYPES.length}): ${DECK_COMPONENT_TYPES.map((t) => `\`${t}\``).join(", ")}.`,
-  "- `richText` — kicker / heading / subheading / paragraphs / bullets. Text only; no media.",
-  "- `image` — one `media` reference and an optional caption.",
-  "- `imageGrid` — two to twelve `items`, each with its own `media`.",
-  "- `video` — one `media` reference.",
-  "",
-  "There is nothing else. A `type` outside those lists is rejected, and so is a slot a Layout does not have — do not invent `body`, `columns`, `slots` or `children`.",
-].join("\n");
-
-const DESCRIPTION = [
-  "Replace the ENTIRE deck with a new version. This is how every change to the deck is made — adding a slide, rewriting a line, reordering, or building the deck from nothing.",
-  "",
-  VOCABULARY,
-  "",
-  "Rules:",
-  "- Emit the COMPLETE deck every time, including slides you are not changing. There is no patch or partial form: whatever you send becomes the deck, and anything you leave out is deleted.",
-  `- Keep \`id\` exactly as it is in the current deck, and keep \`schemaVersion\` at ${DECK_SCHEMA_VERSION}.`,
-  "- Reuse a slide's existing `id` when that slide survives the edit, so revisions stay diffable. Give a genuinely new slide a new lowercase-hyphen id that no other slide uses.",
-  "- Every `media` reference must be a portal media id copied exactly from the Media catalog in your instructions. Never invent one, and never use a filename, path or URL.",
-  `- At most ${DECK_MAX_SLIDES} slides.`,
-  "",
-  "Say what you changed in your reply text; do not restate the deck JSON there.",
-].join("\n");
-
-export function updateDeckTool(): DeckToolDefinition {
-  const schema = z.toJSONSchema(DeckSchema, {
-    // `io: "input"` is what makes fields with defaults optional — under
-    // "output" the model would be told `background` is required. `unrepresentable
-    // : "any"` is for the superRefines (duplicate slide ids, the "a richText
-    // needs some content" rule); they are enforced server-side by parseDeck,
-    // and their messages are what a failed turn gets handed back.
-    target: "draft-2020-12",
-    io: "input",
-    unrepresentable: "any",
-  }) as Record<string, unknown>;
-  // The provider takes the schema body directly; `$schema` is inert there and
-  // is just tokens on every request.
-  delete schema.$schema;
-  return { name: UPDATE_DECK_TOOL_NAME, description: DESCRIPTION, input_schema: schema };
-}

package/src/lib/document-input.ts

@@ -1,57 +0,0 @@
-// Content adapters that turn portal content into the document engine's input
-// shape. These live in the primitives lib (outside the sealed document/ subtree)
-// so the editor (EditorShell) can reach them; primitives cannot import core, so
-// the audience-filtered viewer/presentation adapter lives in core's
-// document-route.ts and calls into this module for image mapping.
-import type { MediaManifest } from "../schemas/media";
-import type { Page } from "../schemas/site-config";
-import type { LoadedSection } from "./loader";
-import type { DocImage, DocSectionInput, DocSourceContent } from "../document";
-
-/**
- * Map a media manifest to the engine's pre-resolved image dictionary. Port of
- * the harness's `portalImagesFrom` against the real MediaManifest type:
- * - only `kind === "image"` entries (videos/animated skipped);
- * - SVGs → `original.svg` for both preview and print;
- * - other images: previewFile = largest variant ≤ 1080 (else the smallest),
- *   printFile = largest; images with zero variants are skipped.
- * The manifest is already schema-parsed upstream, so no tolerant re-parse here.
- */
-export function docImagesFrom(manifest: MediaManifest): Record<string, DocImage> {
-  const out: Record<string, DocImage> = {};
-  for (const [imageId, item] of Object.entries(manifest.images)) {
-    if (item.kind !== "image") continue;
-    if (item.mimeType === "image/svg+xml") {
-      out[imageId] = { imageId, width: item.width, height: item.height, alt: item.alt, previewFile: "original.svg", printFile: "original.svg" };
-      continue;
-    }
-    const widths = item.variants.map((v) => v.width).sort((a, b) => a - b);
-    if (widths.length === 0) continue;
-    const preview = [...widths].reverse().find((w) => w <= 1080) ?? widths[0];
-    const print = widths[widths.length - 1];
-    out[imageId] = { imageId, width: item.width, height: item.height, alt: item.alt, previewFile: `${preview}.webp`, printFile: `${print}.webp` };
-  }
-  return out;
-}
-
-function toSectionInput(s: LoadedSection): DocSectionInput {
-  return { id: s.section.id, type: s.section.type, content: s.section.content, options: s.section.options };
-}
-
-/**
- * Editor path: build the engine's source content from the caller's already-
- * selected page + its draft sections, verbatim. No status/audience filtering —
- * editors see everything (the shell passes in-memory draft content).
- */
-export function buildDraftDocumentInput(opts: {
-  page: Page;
-  sections: LoadedSection[];
-  manifest: MediaManifest;
-}): DocSourceContent {
-  const { page, sections, manifest } = opts;
-  return {
-    pageTitle: page.title,
-    sections: sections.map(toSectionInput),
-    images: docImagesFrom(manifest),
-  };
-}