@drawnagency/primitives 0.1.111 → 0.1.113

package/dist/deck-builder/starter-deck.d.ts

@@ -0,0 +1,23 @@
+import { type Deck } from "../schemas/deck";
+/**
+ * A new deck's seed. Three slides using the two text-only Layouts, so a New
+ * Deck is publishable and presentable before the author has said anything —
+ * and so the starter never cites media that a given site may not have (a
+ * reference the manifest cannot resolve renders as a gap, which is a poor
+ * first impression of the runtime).
+ *
+ * Parsed rather than cast: this is the one deck the product itself authors, so
+ * a schema change that breaks it should break a test, not a client's first
+ * deck.
+ */
+export declare function starterDeck(id: string, title: string): Deck;
+/**
+ * A deck id for a new deck: a slug of the title plus a short random suffix.
+ *
+ * Random rather than sequential because the id is a directory name on a shared
+ * branch that this browser cannot enumerate (a viewer only ever sees their own
+ * decks), so "next free number" is not something the builder can know. The
+ * charset is `DeckIdSchema`'s.
+ */
+export declare function newDeckId(title: string): string;
+//# sourceMappingURL=starter-deck.d.ts.map

package/dist/deck-builder/starter-deck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"starter-deck.d.ts","sourceRoot":"","sources":["../../src/deck-builder/starter-deck.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE7E;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAsD3D;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ/C"}

package/dist/deck-builder/types.d.ts

@@ -0,0 +1,29 @@
+import type { Deck } from "../schemas/deck";
+/**
+ * One row of the builder's deck grid: whatever this browser has staged, joined
+ * to whatever the decks branch holds.
+ *
+ * The join is by deck id and both sides are optional, because the three states
+ * are all real: a draft never published (published side absent), a deck
+ * published from another device (draft side absent), and the normal case where
+ * both exist and may differ.
+ */
+export interface DeckGridEntry {
+    id: string;
+    title: string;
+    slideCount: number;
+    /** ISO timestamp behind the card's "… ago" line. */
+    updatedAt: string;
+    /** Present when this browser has the deck staged. */
+    draft: {
+        deck: Deck;
+        baseVersion: string | null;
+    } | null;
+    /** Present when the decks branch holds it. */
+    published: {
+        version: string;
+    } | null;
+    /** The draft differs from what was published (or was never published). */
+    unpublishedChanges: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/deck-builder/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/deck-builder/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,qDAAqD;IACrD,KAAK,EAAE;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;IACzD,8CAA8C;IAC9C,SAAS,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACtC,0EAA0E;IAC1E,kBAAkB,EAAE,OAAO,CAAC;CAC7B"}

package/dist/deck-builder/useSortableSlide.d.ts

@@ -0,0 +1,29 @@
+interface Options {
+    index: number;
+    onReorder: (fromIndex: number, toIndex: number) => void;
+    /** False while a chat turn streams — the strip goes inert, like the stage. */
+    enabled: boolean;
+}
+/**
+ * Drag-to-reorder for one filmstrip thumbnail.
+ *
+ * A sibling of `useSortableRow` rather than an option on it: the filmstrip is
+ * HORIZONTAL, so it reads left/right edges where every existing consumer reads
+ * top/bottom, and widening that hook's `closestEdge` type would change the two
+ * shipped editor modals that render `DropEdgeIndicator` from it. The Deck
+ * Builder is a sealed subtree; a second small hook here costs less than a type
+ * change under two surfaces this ticket is not touching.
+ *
+ * The pointer-math is NOT duplicated: `computeReorderTarget` is written in
+ * before/after terms, so left maps to "top" and right to "bottom" and the
+ * unit-tested decrement stays the one implementation. The whole atlaskit
+ * adapter is imported lazily, as it is everywhere else — jsdom cannot run it,
+ * which is why `moveDeckSlide` and the move affordances carry the coverage.
+ */
+export declare function useSortableSlide<E extends HTMLElement>({ index, onReorder, enabled }: Options): {
+    ref: import("react").RefObject<E | null>;
+    isDragging: boolean;
+    closestEdge: "right" | "left" | null;
+};
+export {};
+//# sourceMappingURL=useSortableSlide.d.ts.map

package/dist/deck-builder/useSortableSlide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSortableSlide.d.ts","sourceRoot":"","sources":["../../src/deck-builder/useSortableSlide.ts"],"names":[],"mappings":"AAGA,UAAU,OAAO;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACxD,8EAA8E;IAC9E,OAAO,EAAE,OAAO,CAAC;CAClB;AAID;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,WAAW,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,OAAO;;;;EAyE7F"}

package/dist/index.js

@@ -57,45 +57,7 @@ import {
   resolveMedia,
   sanitizeMediaName,
   setMediaProvider
-} from "./chunk-XQMDWXD6.js";
-import {
-  MediaGridOptionsSchema
-} from "./chunk-B7VBSE5X.js";
-import {
-  AudienceSchema,
-  RoleSchema,
-  SessionSchema,
-  SiteUserSchema
-} from "./chunk-6P4CJCXB.js";
-import {
-  AudienceColorSchema,
-  AudienceNameSchema,
-  NormalizedUsernameSchema,
-  VIEWER_PASSWORD_MIN_LENGTH,
-  ViewerCredentialSchema,
-  ViewerPasswordSchema,
-  ViewerUsernameSchema,
-  normalizeUsername,
-  slugifyAudienceName
-} from "./chunk-HBULBDGP.js";
-import {
-  DEFAULT_LINK,
-  LinkTargetSchema,
-  LinkValueSchema,
-  isSafeHref
-} from "./chunk-3ZRQ4G5F.js";
-import {
-  DOCUMENT_BUCKET_MAX_BYTES,
-  DOCUMENT_GIT_MAX_BYTES,
-  DOCUMENT_KIND_TO_MIME,
-  DOCUMENT_MANIFEST_PATH,
-  DOCUMENT_MIME_TO_EXT,
-  DocumentManifestEntrySchema,
-  DocumentManifestSchema,
-  documentBucketPath,
-  documentFileUrl,
-  documentGitPath
-} from "./chunk-BS5AQHZG.js";
+} from "./chunk-FRE2CCLV.js";
 import {
   DEFAULT_CHATBOT_NAME,
   accentVarValue,
@@ -103,7 +65,6 @@ import {
   contrastColor,
   contrastRatio,
   deriveContrast,
-  formatTimestamp,
   gridColsClass,
   loadSiteContent,
   loadStaticSiteContent,
@@ -116,8 +77,11 @@ import {
   safeRedirect,
   suggestAccessibleOn,
   wcagLevel
-} from "./chunk-VCCNKTFD.js";
+} from "./chunk-VWWY5TL5.js";
 import "./chunk-FRVO75DK.js";
+import {
+  formatTimestamp
+} from "./chunk-MM7KZS5C.js";
 import {
   curatedIcons,
   getIcon
@@ -129,14 +93,25 @@ import {
   navChangeEvent
 } from "./chunk-4RNF2DRG.js";
 import {
-  ensureSanitizer,
   generateNavLinks,
-  sanitizeHtml,
   toSectionId
-} from "./chunk-RA5IOFPY.js";
+} from "./chunk-DNY72JZN.js";
+import "./chunk-CXZ5YJG4.js";
+import {
+  ensureSanitizer,
+  sanitizeHtml
+} from "./chunk-QQ3S3P5P.js";
 import {
   cn
 } from "./chunk-7EOSDFS3.js";
+import {
+  audiencePasses,
+  groupDisplayLabel,
+  groupOfPage,
+  navEntries,
+  pagesInNavOrder,
+  reconcileNav
+} from "./chunk-NHN2LSIU.js";
 import {
   isSameOriginRequest,
   requireSessionSecret,
@@ -146,13 +121,8 @@ import {
   env
 } from "./chunk-WKZ7OENC.js";
 import {
-  audiencePasses,
-  groupDisplayLabel,
-  groupOfPage,
-  navEntries,
-  pagesInNavOrder,
-  reconcileNav
-} from "./chunk-OTDA6KWL.js";
+  MediaGridOptionsSchema
+} from "./chunk-B7VBSE5X.js";
 import {
   NavEntrySchema,
   NavFileSchema
@@ -162,20 +132,10 @@ import {
   getSectionSchema,
   getSectionSchemaForType
 } from "./chunk-DMCGN5AS.js";
-import {
-  clearRegistry,
-  createRegistry,
-  defineSection,
-  getAllSchemas,
-  getAllSections,
-  getSchema,
-  getSection,
-  registerSchema,
-  registerSection
-} from "./chunk-FTPETWXE.js";
 import {
   ChatbotConfigSchema,
   ChatbotTaskSchema,
+  DeckBuilderConfigSchema,
   ImageManifestSchema,
   IndexSchema,
   MediaConfigSchema,
@@ -190,8 +150,36 @@ import {
   StatusSchema,
   VariantSchema,
   normalizeSiteIndex
-} from "./chunk-UVIYI4J6.js";
+} from "./chunk-AHALSCQH.js";
 import "./chunk-4TZJZU2T.js";
+import {
+  clearRegistry,
+  createRegistry,
+  defineSection,
+  getAllSchemas,
+  getAllSections,
+  getSchema,
+  getSection,
+  registerSchema,
+  registerSection
+} from "./chunk-FTPETWXE.js";
+import {
+  AudienceSchema,
+  RoleSchema,
+  SessionSchema,
+  SiteUserSchema
+} from "./chunk-6P4CJCXB.js";
+import {
+  AudienceColorSchema,
+  AudienceNameSchema,
+  NormalizedUsernameSchema,
+  VIEWER_PASSWORD_MIN_LENGTH,
+  ViewerCredentialSchema,
+  ViewerPasswordSchema,
+  ViewerUsernameSchema,
+  normalizeUsername,
+  slugifyAudienceName
+} from "./chunk-HBULBDGP.js";
 import {
   FontNameSchema,
   HexColorSchema,
@@ -200,6 +188,24 @@ import {
   TextLineSchema
 } from "./chunk-GGXZZ77Z.js";
 import "./chunk-NSCT3AMV.js";
+import {
+  DEFAULT_LINK,
+  LinkTargetSchema,
+  LinkValueSchema,
+  isSafeHref
+} from "./chunk-3ZRQ4G5F.js";
+import {
+  DOCUMENT_BUCKET_MAX_BYTES,
+  DOCUMENT_GIT_MAX_BYTES,
+  DOCUMENT_KIND_TO_MIME,
+  DOCUMENT_MANIFEST_PATH,
+  DOCUMENT_MIME_TO_EXT,
+  DocumentManifestEntrySchema,
+  DocumentManifestSchema,
+  documentBucketPath,
+  documentFileUrl,
+  documentGitPath
+} from "./chunk-BS5AQHZG.js";
 import "./chunk-JSBRDJBE.js";
 export {
   ASSET_CACHE_CONTROL,
@@ -220,6 +226,7 @@ export {
   DOCUMENT_KIND_TO_MIME,
   DOCUMENT_MANIFEST_PATH,
   DOCUMENT_MIME_TO_EXT,
+  DeckBuilderConfigSchema,
   DocumentManifestEntrySchema,
   DocumentManifestSchema,
   EXT_TO_MIME,

package/dist/lib/deck-access.d.ts

@@ -0,0 +1,86 @@
+import type { DeckOwner } from "../schemas/deck-meta";
+/**
+ * Who is asking. Built from the request's identity — a signed audience cookie
+ * (with the credential username when the site has named credentials) or an
+ * editor session — and deliberately NOT an Astro `locals`: the decision below
+ * is pure, so it is testable the way `audiencePasses` is.
+ *
+ * `audience` (no username) is the env-mode standalone case: a shared password
+ * per audience means there is no person to attribute to (ADR 0002).
+ */
+export type DeckIdentity = {
+    kind: "viewer";
+    username: string;
+    audience: string;
+} | {
+    kind: "editor";
+    userId: string;
+} | {
+    kind: "audience";
+    audience: string;
+};
+/** The owner to record on a deck this identity is creating. */
+export declare function deckOwnerFor(identity: DeckIdentity): DeckOwner;
+/**
+ * Ownership. Credential-keyed for viewers (the username is the person-level
+ * key — an audience change must not hand a deck to someone else, and must not
+ * take it away from its author), user-id-keyed for editors, and audience-keyed
+ * for the env-mode fallback.
+ *
+ * An audience-owned deck is owned by everyone in that audience, which is
+ * exactly the attribution loss ADR 0002 accepts for env-mode portals. The
+ * reverse does not hold: an identity with no username cannot claim a
+ * credential-owned deck.
+ */
+export declare function isDeckOwner(owner: DeckOwner, identity: DeckIdentity): boolean;
+/**
+ * May this identity see and change this deck? Owner, or any editor — editors
+ * are super-admins over every deck on the site regardless of audience config
+ * (feasibility decision 9).
+ *
+ * One function for read and for write because today they are the same rule:
+ * a deck is private to its owner (Deck Visibility). Audience grants and Public
+ * Links (#36/#37) widen READ only, and that is when the two split.
+ */
+export declare function canAccessDeck(owner: DeckOwner, identity: DeckIdentity): boolean;
+/**
+ * May this identity CREATE a deck? Editors always (super-admins); everyone else
+ * only from a deck-enabled audience — `deckBuilder.audiences`, strict opt-in
+ * exactly like `chatbot.audiences`, so an empty list means no viewer may.
+ *
+ * Creation rights are AUDIENCE-keyed while ownership of the result is
+ * CREDENTIAL-keyed (`deckOwnerFor`); the two deliberately do not share a key.
+ * An `audience` identity (env-mode standalone, shared password, no named
+ * credential) passes when its audience is listed: that is a deliberate opt-in
+ * by the editor, and the resulting deck is audience-owned — the attribution
+ * loss ADR 0002 accepts, not an accident. What the list prevents is the DEFAULT
+ * audience being enabled implicitly, i.e. anyone holding the site password
+ * writing to the client's repo.
+ */
+export declare function canCreateDeck(identity: DeckIdentity, deckAudiences: readonly string[]): boolean;
+/**
+ * The Deck Draft partition key for an identity.
+ *
+ * A Deck Draft lives in one browser until it is published (ADR 0002), and a
+ * browser PROFILE is shared between people far more often than an account is.
+ * Keyed by site alone, two viewers signing into the same portal on one machine
+ * saw each other's unpublished drafts in the grid, could open and read them,
+ * and could publish another person's never-published draft under their own
+ * ownership; a signed-out user's drafts simply waited for whoever came next.
+ *
+ * The partition mirrors `deckOwnerFor` exactly, so a draft can only ever be
+ * published under the identity that staged it.
+ *
+ * DIGESTED, not spelled out, because the value becomes an IndexedDB database
+ * NAME and any script on the origin can enumerate those — a raw username there
+ * would disclose who last used the browser. This is NOT a security boundary:
+ * IndexedDB is per-origin and isolates nothing between people sharing a
+ * profile. It bounds accidents, not somebody with the keyboard.
+ *
+ * Switching identity leaves the previous identity's database in place,
+ * untouched and unread. That is deliberate — the alternative is destroying a
+ * colleague's unpublished work on sign-in — so orphaned drafts persist until
+ * the browser's own storage eviction takes them.
+ */
+export declare function deckDraftScope(identity: DeckIdentity): string;
+//# sourceMappingURL=deck-access.d.ts.map

package/dist/lib/deck-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deck-access.d.ts","sourceRoot":"","sources":["../../src/lib/deck-access.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACtD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,CAS9D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAS7E;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAE/E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAG/F;AAgBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAW7D"}

package/dist/lib/deck-access.js

@@ -0,0 +1,58 @@
+import "../chunk-JSBRDJBE.js";
+
+// src/lib/deck-access.ts
+function deckOwnerFor(identity) {
+  switch (identity.kind) {
+    case "viewer":
+      return { kind: "viewer", username: identity.username, audience: identity.audience };
+    case "editor":
+      return { kind: "editor", userId: identity.userId };
+    case "audience":
+      return { kind: "audience", audience: identity.audience };
+  }
+}
+function isDeckOwner(owner, identity) {
+  switch (owner.kind) {
+    case "viewer":
+      return identity.kind === "viewer" && identity.username === owner.username;
+    case "editor":
+      return identity.kind === "editor" && identity.userId === owner.userId;
+    case "audience":
+      return (identity.kind === "viewer" || identity.kind === "audience") && identity.audience === owner.audience;
+  }
+}
+function canAccessDeck(owner, identity) {
+  return identity.kind === "editor" || isDeckOwner(owner, identity);
+}
+function canCreateDeck(identity, deckAudiences) {
+  if (identity.kind === "editor") return true;
+  return deckAudiences.includes(identity.audience);
+}
+function digest(input) {
+  const half = (offset) => {
+    let hash = offset;
+    for (let i = 0; i < input.length; i++) {
+      hash ^= input.charCodeAt(i);
+      hash = Math.imul(hash, 16777619) >>> 0;
+    }
+    return hash.toString(16).padStart(8, "0");
+  };
+  return half(2166136261) + half(2147483647);
+}
+function deckDraftScope(identity) {
+  switch (identity.kind) {
+    case "viewer":
+      return digest(`viewer:${identity.username}@${identity.audience}`);
+    case "editor":
+      return digest(`editor:${identity.userId}`);
+    case "audience":
+      return digest(`audience:${identity.audience}`);
+  }
+}
+export {
+  canAccessDeck,
+  canCreateDeck,
+  deckDraftScope,
+  deckOwnerFor,
+  isDeckOwner
+};

package/dist/lib/deck-dexie.d.ts

@@ -0,0 +1,88 @@
+import { 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;
+}
+export declare function initDeckDraftStore(siteId: string, scope: string): void;
+/** Every staged draft, newest first. Drives the builder's deck grid. */
+export declare function listDeckDrafts(): Promise<DeckDraftRow[]>;
+export declare function getDeckDraft(deckId: string): Promise<DeckDraftRow | 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 declare function putDeckDraft(deck: Deck): Promise<DeckDraftRow>;
+/**
+ * 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 declare function markDeckDraftPublished(deck: Deck, version: string, updatedAt?: string): Promise<DeckDraftRow>;
+/**
+ * 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 declare function recordDeckPublish(deckId: string, publishedDeck: Deck, version: string): Promise<DeckDraftRow | null>;
+export declare function deleteDeckDraft(deckId: string): Promise<void>;
+/**
+ * Does this row differ from what was published? A never-published draft always
+ * has changes — there is nothing on the server to match.
+ */
+export declare function hasUnpublishedChanges(row: DeckDraftRow): boolean;
+//# sourceMappingURL=deck-dexie.d.ts.map

package/dist/lib/deck-dexie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deck-dexie.d.ts","sourceRoot":"","sources":["../../src/lib/deck-dexie.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE3D;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,YAAY;IAC3B,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,IAAI,CAAC;IACX;;;;OAIG;IACH,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;;;;;OAMG;IACH,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;CACnB;AAkBD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAUtE;AAOD,wEAAwE;AACxE,wBAAsB,cAAc,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAG9D;AAED,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAE/E;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAoBpE;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAUnH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAsB1H;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEnE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAEhE"}

package/dist/lib/deck-dexie.js

@@ -0,0 +1,22 @@
+import {
+  deleteDeckDraft,
+  getDeckDraft,
+  hasUnpublishedChanges,
+  initDeckDraftStore,
+  listDeckDrafts,
+  markDeckDraftPublished,
+  putDeckDraft,
+  recordDeckPublish
+} from "../chunk-FV7JQRCN.js";
+import "../chunk-VAYZJKVR.js";
+import "../chunk-JSBRDJBE.js";
+export {
+  deleteDeckDraft,
+  getDeckDraft,
+  hasUnpublishedChanges,
+  initDeckDraftStore,
+  listDeckDrafts,
+  markDeckDraftPublished,
+  putDeckDraft,
+  recordDeckPublish
+};

package/dist/lib/deck-edit.d.ts

@@ -0,0 +1,67 @@
+import { type Deck, 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.
+ */
+declare const DECK_TEXT_SLOTS: readonly ["content", "overlay", "left", "right"];
+export type DeckTextSlot = (typeof DECK_TEXT_SLOTS)[number];
+declare const DECK_TEXT_FIELDS: readonly ["kicker", "heading", "subheading", "paragraphs", "bullets"];
+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[];
+};
+/** The rich text a slot holds, or null when that slot holds something else. */
+export declare function richTextAt(slide: DeckSlide, slot: DeckTextSlot): DeckRichText | null;
+/**
+ * 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 declare function applyDeckTextEdit(deck: Deck, slideIndex: number, path: DeckTextPath, text: string): DeckEditResult;
+/** Move a slide to a new index. `to` is the destination in the POST-removal list. */
+export declare function moveDeckSlide(deck: Deck, from: number, to: number): DeckEditResult;
+/** Duplicate a slide, inserting the copy directly after the original. */
+export declare function duplicateDeckSlide(deck: Deck, index: number): DeckEditResult;
+/** Remove a slide. Removing the only one is refused by the schema, by design. */
+export declare function removeDeckSlide(deck: Deck, index: number): DeckEditResult;
+export {};
+//# sourceMappingURL=deck-edit.d.ts.map

package/dist/lib/deck-edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deck-edit.d.ts","sourceRoot":"","sources":["../../src/lib/deck-edit.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,IAAI,EAET,KAAK,YAAY,EACjB,KAAK,SAAS,EACf,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;;GAcG;AAEH;;;;GAIG;AAOH,QAAA,MAAM,eAAe,kDAAmD,CAAC;AACzE,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D,QAAA,MAAM,gBAAgB,uEAAwE,CAAC;AAC/F,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,aAAa,CAAC;IACrB,kFAAkF;IAClF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sFAAsF;IACtF,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAUxF,+EAA+E;AAC/E,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,YAAY,GAAG,IAAI,CAWpF;AA+CD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,CAgBlH;AAED,qFAAqF;AACrF,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,cAAc,CAOlF;AAgBD,yEAAyE;AACzE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,CAU5E;AAED,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,CAIzE"}

package/dist/lib/deck-media-assets.d.ts

@@ -0,0 +1,27 @@
+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 declare 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>;
+//# sourceMappingURL=deck-media-assets.d.ts.map

package/dist/lib/deck-media-assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deck-media-assets.d.ts","sourceRoot":"","sources":["../../src/lib/deck-media-assets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,MAAM,EAAE,EACf,QAAQ,EAAE,aAAa;AACvB;;;;;;;;GAQG;AACH,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CA0BhC"}