@melite/formats 0.0.0-stage → 0.1.4-alpha

package/lib/bodyPresets.js

@@ -0,0 +1,77 @@
+// Anny's 11 phenotype dims in order:
+//   [gender, age, muscle, weight, height, proportions, cupsize, firmness,
+//    african, asian, caucasian]
+// gender: 0.0 = masculine, 1.0 = feminine (verified against the live mesh:
+// gender=0 widens jaw and shoulders; gender=1 narrows them and widens hips).
+// age/muscle/weight: 0.5 = average adult. height/proportions: 0.5 = standard.
+// race dims are left at neutral 0.5 so race-specific features stay default.
+const NEUTRAL_RACE = [0.5, 0.5, 0.5]; // african, asian, caucasian
+/**
+ * Neutral - reset to the Anny default with no stylization.
+ *
+ * Provides a quick "back to neutral" affordance in the preset bar without
+ * the user having to hit the Reset button. Coeffs all 0.5 = Anny's neutral
+ * adult, no local changes, no custom target blends.
+ */
+const NEUTRAL = {
+    id: "neutral",
+    name: "Neutral",
+    description: "Default Anny - no stylization, no morphs",
+    identityModel: "anny",
+    coeffs: [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, ...NEUTRAL_RACE],
+    localChanges: null,
+    customTargets: null,
+};
+/**
+ * Male - basic masculine baseline with no stylization.
+ *
+ * Gender 0.0 (fully masculine → wider jaw, broader shoulders, narrower
+ * hips). Age/muscle/weight tuned to a healthy adult male build. No
+ * local_changes — this is a clean starting point the user can sculpt
+ * further. Height slightly above average.
+ */
+const MALE = {
+    id: "male",
+    name: "Male",
+    description: "Basic masculine baseline - no stylization",
+    identityModel: "anny",
+    coeffs: [0.0, 0.45, 0.55, 0.50, 0.55, 0.50, 0.40, 0.55, ...NEUTRAL_RACE],
+    //          gen  age   mus   wt    ht    prop  cup  firm
+    localChanges: null,
+    customTargets: null,
+};
+/**
+ * Female - basic feminine baseline with no stylization.
+ *
+ * Gender 1.0 (fully feminine → narrower jaw, defined waist, wider hips).
+ * Age/muscle/weight tuned to a healthy adult female build. No
+ * local_changes — clean starting point for further sculpting.
+ */
+const FEMALE = {
+    id: "female",
+    name: "Female",
+    description: "Basic feminine baseline - no stylization",
+    identityModel: "anny",
+    coeffs: [1.0, 0.40, 0.35, 0.38, 0.52, 0.52, 0.45, 0.55, ...NEUTRAL_RACE],
+    //          gen  age   mus   wt    ht    prop  cup  firm
+    localChanges: null,
+    customTargets: null,
+};
+export const BODY_PRESETS = [
+    NEUTRAL, MALE, FEMALE,
+];
+/**
+ * Find a preset by id (returns undefined if not found).
+ *
+ * Used by tests and any future "load preset by URL hash" affordances.
+ */
+export function getPresetById(id) {
+    return BODY_PRESETS.find((p) => p.id === id);
+}
+/**
+ * Default preset (the one applied to the very first Body Studio mount).
+ * Returns null so we DON'T clobber the user's saved edits on subsequent
+ * loads - the default is the un-morphed Anny.
+ */
+export const DEFAULT_PRESET_ID = null;
+//# sourceMappingURL=bodyPresets.js.map

package/lib/capabilityCards.d.ts

@@ -0,0 +1,54 @@
+import { type CapabilityEntry, type CapabilityRoute, type Catalog, type FamilyEntry } from "@melite/catalog";
+import type { CardGenre } from "@melite/contracts";
+/** A card ready to land on the canvas (what onPick hands the store).
+ *
+ *  ``kind`` is optional — capabilities/families always produce
+ *  ``"generation"`` (the default), so the existing helpers don't set it
+ *  and the canvas defaults to "generation". The Input / Media Prep tile
+ *  sets ``kind: "input"`` so the canvas routes the stage through the
+ *  doc-driven input family (POST /v1/flows/start, 1-step inline
+ *  doc) — NOT the generation wire. This is rule 4: the shape carries
+ *  the kind, so pick → addStage never silently misroutes. */
+export interface PickedCard {
+    service: string;
+    title: string;
+    genre?: CardGenre;
+    params: Record<string, unknown>;
+    kind?: string;
+}
+/**
+ * Seed params for a route: the backend-computed defaults + an empty prompt
+ * ONLY when the model's form actually serves a prompt field
+ * (prompt_in_form — backend-computed from the builder schema) + a null
+ * seed for EVERY input slot the model declares (input_slots — multi-slot
+ * forms like edit's three images / video's two frames get one null per
+ * slot, so the card renders all its squares from the start). Unknown
+ * prompt_in_form → seed (old behavior).
+ */
+export declare function seededParams(cat: Catalog | null, route: string, base?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Resolve a capability tile (+ optional route override) to a card. The
+ * default tile click uses cap.resolved; the tile's model switcher passes a
+ * different CapabilityRoute — same capability intent, model switched
+ * underneath. The route's params are backend-precomputed (capability
+ * default_params as fallback, model's own defaults winning), so switching
+ * the model correctly swaps the per-model recipe (steps / cfg / sampler).
+ */
+export declare function capabilityToCard(cat: Catalog | null, cap: CapabilityEntry, route: CapabilityRoute): PickedCard;
+/** Resolve a specific family entry (the "All models" list) to a card. */
+export declare function familyEntryToCard(cat: Catalog | null, familyId: string, fam: FamilyEntry): PickedCard;
+export declare const CAPABILITY_DRAG_MIME = "application/tech-noir-capability";
+/** What a capability tile writes to the drag data store. Carries the fully
+ *  resolved card (service + title + params + kind) so the drop target can
+ *  apply it WITHOUT a catalog lookup — the sidebar already paid that cost
+ *  via capabilityToCard. ``capId`` is diagnostics-only (not read by the
+ *  drop target; useful for e2e traces). */
+export type CapabilityDropPayload = PickedCard & {
+    capId?: string;
+};
+/** Serialize a picked card onto the drag data store. */
+export declare function capabilityDragPayload(capId: string, card: PickedCard): string;
+/** Parse the capability MIME off a drop event. null = absent or malformed
+ *  (the drop target falls through to the asset/file path). */
+export declare function parseCapabilityDrop(raw: string): CapabilityDropPayload | null;
+//# sourceMappingURL=capabilityCards.d.ts.map

package/lib/capabilityCards.js

@@ -0,0 +1,127 @@
+// capabilityCards — the ONE capability→card derivation path.
+//
+// A capability tile (Generate / Edit / Upscale / ...) resolves to a card
+// descriptor: the backend-precomputed default model route + merged params
+// (capabilities.<id>.resolved). This module is the single implementation —
+// the ServicePicker dialog AND the Library's right sidebar (LibrarySidebar)
+// both derive their "what lands on the canvas" from these helpers, so a
+// catalog or schema change cannot make the two surfaces drift.
+//
+
+//   • an empty prompt is seeded ONLY when the model's form actually serves
+//     a prompt field (prompt_in_form — backend-computed from the builder
+//     schema); a prompt-less card (upscale) must never carry one
+//   • a null input slot is seeded when the model's schema has an input
+//     (the card modal renders the attach control for it)
+import { familyGenre, narrowGenre } from "@melite/catalog";
+/**
+ * Seed params for a route: the backend-computed defaults + an empty prompt
+ * ONLY when the model's form actually serves a prompt field
+ * (prompt_in_form — backend-computed from the builder schema) + a null
+ * seed for EVERY input slot the model declares (input_slots — multi-slot
+ * forms like edit's three images / video's two frames get one null per
+ * slot, so the card renders all its squares from the start). Unknown
+ * prompt_in_form → seed (old behavior).
+ */
+export function seededParams(cat, route, base = {}) {
+    const model = cat?.models[route];
+    const slots = model?.input_slots?.length
+        ? model.input_slots
+        : (model?.input ? [model.input] : []);
+    const hasPrompt = model?.prompt_in_form ?? true; // unknown → seed (old behavior)
+    return {
+        ...base,
+        ...(hasPrompt ? { prompt: "" } : {}),
+        ...(slots.length ? Object.fromEntries(slots.map((k) => [k, null])) : {}),
+    };
+}
+/**
+ * Resolve a capability tile (+ optional route override) to a card. The
+ * default tile click uses cap.resolved; the tile's model switcher passes a
+ * different CapabilityRoute — same capability intent, model switched
+ * underneath. The route's params are backend-precomputed (capability
+ * default_params as fallback, model's own defaults winning), so switching
+ * the model correctly swaps the per-model recipe (steps / cfg / sampler).
+ */
+export function capabilityToCard(cat, cap, route) {
+    // Model-less capabilities (kind:"input") carry their params VERBATIM — no
+    // prompt/slot seeding. Those are generation-form concerns (prompt_in_form,
+    // input_slots); input's editor is the fixed-field InputCardEditor, which
+    // owns crop/scale/trim/volume/mask. Seeding a prompt here would give the
+    
+    // regression, generalized). The kind rides through to PickedCard so the
+    // canvas routes the stage through executeInput, not executeGeneration.
+    const isModelLess = cap.kind !== undefined && cap.kind !== "generation";
+    return {
+        service: route.model,
+        title: cap.label,
+        genre: genreForRoute(cat, route.model),
+        params: isModelLess ? { ...route.params } : seededParams(cat, route.model, route.params),
+        ...(isModelLess ? { kind: cap.kind } : {}),
+    };
+}
+/** Resolve a specific family entry (the "All models" list) to a card. */
+export function familyEntryToCard(cat, familyId, fam) {
+    // Route resolution — the SAME chain the backend's capability resolver
+    // and familiesForForm use: the catalog-declared ``default_model`` (when
+    // it is a member), else the member whose key equals the family id, else
+    // the FIRST member. NEVER the bare familyId: mask_studio's family id
+    // and model key differ (mask_studio vs mask-studio), and a family-id
+    // service is a PHANTOM ROUTE — no models[] entry, no familyGenre, and
+    // no studio registry match (the "mask studio does not appear" bug,
+    
+    // card zoomed as a plain form card). The catalog now declares
+    // default_model for every id-divergent family; this chain is the
+    // backstop for the next one.
+    const declared = fam.default_model;
+    const members = Object.entries(cat?.models ?? {})
+        .filter(([, m]) => m.family === familyId)
+        .map(([k]) => k);
+    const route = (declared && members.includes(declared) ? declared : undefined) ??
+        members.find((k) => k === familyId) ??
+        members[0] ??
+        familyId;
+    return {
+        service: route,
+        title: fam.label ?? familyId,
+        genre: narrowGenre(fam.genre) ?? genreForRoute(cat, route),
+        params: seededParams(cat, route, cat?.models[route]?.defaults ?? {}),
+    };
+}
+/** Genre for a model route — the catalog's familyGenre derivation. */
+function genreForRoute(cat, route) {
+    return cat ? familyGenre(route, cat) : undefined;
+}
+
+// A capability tile in the LibrarySidebar is DRAGGABLE onto a card in the
+// canvas — "clicking and dragging from the right sidebar onto the middle
+// part should populate the card". The drop REPURPOSES the target card: its
+// service + params + title become the dragged capability's resolved card
+// (the same shape a click would `addStage`, applied to an EXISTING stage).
+//
+// The MIME is deliberately distinct from `application/tech-noir-asset`
+// (AppSidebar's asset drag) so a card's drop handler can tell "populate
+// this card's identity" (capability) from "attach an asset to a slot"
+// (asset) — one drop target, two contracts, no ambiguity.
+export const CAPABILITY_DRAG_MIME = "application/tech-noir-capability";
+/** Serialize a picked card onto the drag data store. */
+export function capabilityDragPayload(capId, card) {
+    return JSON.stringify({ ...card, capId });
+}
+/** Parse the capability MIME off a drop event. null = absent or malformed
+ *  (the drop target falls through to the asset/file path). */
+export function parseCapabilityDrop(raw) {
+    if (!raw)
+        return null;
+    try {
+        const p = JSON.parse(raw);
+        if (typeof p.service === "string" && typeof p.title === "string" && p.params && typeof p.params === "object") {
+            return p;
+        }
+        return null;
+    }
+    catch { /* not our payload — the JSON probe answers absent (row 28) */
+        return null;
+    }
+}
+//# sourceMappingURL=capabilityCards.js.map

package/lib/captionSplitter.d.ts

@@ -0,0 +1,49 @@
+/**
+ * E3.7 — Caption text splitter.
+ *
+ * Converts a plain-text transcription into a sequence of CaptionCues with
+ * proportional timing. When the ASR backend provides word-level timestamps
+ * (via `tokens`), we use those directly. Otherwise we fall back to
+ * sentence-aware splitting with proportional duration allocation (by
+ * character count — longer sentences get proportionally more time).
+ *
+ * Caption length targets ~42 characters per cue (the industry standard
+ * for readable subtitles, per the BBC/NBC style guides). Sentences longer
+ * than that are split at clause boundaries (commas, semicolons, dashes)
+ * or at word boundaries as a last resort.
+ *
+ * Timing model: cue.start/end are SECONDS RELATIVE TO THE SEGMENT START
+ * (not the global timeline). The program monitor maps global time →
+ * segment-relative time before looking up the active cue.
+ */
+import type { CaptionCue } from "@melite/contracts";
+export interface SplitArgs {
+    /** Full transcription text. */
+    text: string;
+    /** Segment duration in seconds (the cues' timing window). */
+    duration: number;
+    /** Optional word-level timestamps from the ASR backend. When provided,
+     *  cues are built from the actual word timings instead of proportional
+     *  splitting. Each token: { text, start, end } in seconds. */
+    tokens?: Array<{
+        text: string;
+        start: number;
+        end: number;
+    }> | null;
+    /** Max characters per cue (default 42). */
+    maxChars?: number;
+}
+/**
+ * Build CaptionCues from a transcription. Returns an empty array if the
+ * text is empty/whitespace or the duration is <= 0.
+ */
+export declare function splitCaptions(args: SplitArgs): CaptionCue[];
+/**
+ * Split text into caption-length chunks. Strategy (in priority order):
+ *   1. Split into sentences (terminators . ! ? …).
+ *   2. If a sentence exceeds maxChars, split at clause boundaries
+ *      (, ; : — –) then at word boundaries as a last resort.
+ *   3. Merge short consecutive fragments up to maxChars.
+ */
+export declare function splitIntoChunks(text: string, maxChars?: number): string[];
+//# sourceMappingURL=captionSplitter.d.ts.map

package/lib/captionSplitter.js

@@ -0,0 +1,172 @@
+const DEFAULT_MAX_CHARS = 42;
+/**
+ * Build CaptionCues from a transcription. Returns an empty array if the
+ * text is empty/whitespace or the duration is <= 0.
+ */
+export function splitCaptions(args) {
+    const { text, duration, tokens = null, maxChars = DEFAULT_MAX_CHARS } = args;
+    if (duration <= 0)
+        return [];
+    // ── Timestamped path takes precedence — tokens can build cues even
+    //    with empty text (the text is derived from the tokens). ─────────────
+    if (tokens && tokens.length > 0) {
+        return buildFromTokens(tokens, maxChars, duration);
+    }
+    const trimmed = text.trim();
+    if (!trimmed)
+        return [];
+    // ── Proportional path: split text + distribute by character count ──────
+    const chunks = splitIntoChunks(trimmed, maxChars);
+    
+
+
+    if (chunks.length === 0)
+        return [];
+    const totalChars = chunks.reduce((s, c) => s + c.length, 0);
+    let elapsed = 0;
+    return chunks.map((chunk, i) => {
+        
+        // chunks.length guard above), so totalChars is positive — no fallback.
+        const proportion = chunk.length / totalChars;
+        const start = elapsed;
+        const segDur = proportion * duration;
+        // Last cue gets the remaining time (avoids float drift at the end).
+        const end = i === chunks.length - 1 ? duration : Math.min(duration, start + segDur);
+        elapsed = end;
+        return {
+            id: `cap_${i}_${Math.random().toString(36).slice(2, 8)}`,
+            start: Number(start.toFixed(3)),
+            end: Number(end.toFixed(3)),
+            text: chunk,
+        };
+    });
+}
+/**
+ * Split text into caption-length chunks. Strategy (in priority order):
+ *   1. Split into sentences (terminators . ! ? …).
+ *   2. If a sentence exceeds maxChars, split at clause boundaries
+ *      (, ; : — –) then at word boundaries as a last resort.
+ *   3. Merge short consecutive fragments up to maxChars.
+ */
+export function splitIntoChunks(text, maxChars = DEFAULT_MAX_CHARS) {
+    // Normalize whitespace.
+    const clean = text.replace(/\s+/g, ' ').trim();
+    if (!clean)
+        return [];
+    // Step 1: split into sentences, keeping the terminator.
+    // The second alternative matches any trailing non-space run, so a
+    // non-empty input always yields >=1 match (the `as` is proven, not blind:
+    // `clean` is non-empty per the guard above).
+    const sentences = clean.match(/[^.!?…]+[.!?…]+|\S[^.!?…]*$/g);
+    // Step 2: break long sentences at clause / word boundaries.
+    const fragments = [];
+    for (const s of sentences) {
+        const trimmed = s.trim();
+        
+
+
+        if (!trimmed)
+            continue;
+        if (trimmed.length <= maxChars) {
+            fragments.push(trimmed);
+        }
+        else {
+            fragments.push(...splitLongSentence(trimmed, maxChars));
+        }
+    }
+    // Step 3: greedily merge short fragments up to maxChars.
+    return mergeFragments(fragments, maxChars);
+}
+/** Split a long sentence at clause boundaries, then word boundaries. */
+function splitLongSentence(s, maxChars) {
+    // Try clause boundaries first: , ; : — –
+    const clauseParts = s.split(/(?<=[,;:—–])\s+/).map((p) => p.trim()).filter(Boolean);
+    if (clauseParts.length > 1) {
+        return clauseParts.flatMap((p) => p.length <= maxChars ? [p] : splitAtWordBoundary(p, maxChars));
+    }
+    // No clause boundaries — split at word boundaries.
+    return splitAtWordBoundary(s, maxChars);
+}
+/** Split at word boundaries, each chunk <= maxChars. */
+function splitAtWordBoundary(s, maxChars) {
+    const words = s.split(/\s+/);
+    const chunks = [];
+    let cur = '';
+    for (const w of words) {
+        if ((cur + ' ' + w).trim().length <= maxChars) {
+            cur = (cur + ' ' + w).trim();
+        }
+        else {
+            if (cur)
+                chunks.push(cur);
+            cur = w;
+        }
+    }
+    
+    if (cur)
+        chunks.push(cur);
+    return chunks;
+}
+/** Greedily merge short fragments that fit within maxChars. */
+function mergeFragments(frags, maxChars) {
+    const merged = [];
+    let cur = '';
+    for (const f of frags) {
+        const candidate = cur ? `${cur} ${f}` : f;
+        if (candidate.length <= maxChars) {
+            cur = candidate;
+        }
+        else {
+            if (cur)
+                merged.push(cur);
+            cur = f;
+        }
+    }
+    
+
+    if (cur)
+        merged.push(cur);
+    return merged;
+}
+/** Build cues from timestamped word tokens, grouping words into cues. */
+function buildFromTokens(tokens, maxChars, fallbackDuration) {
+    const cues = [];
+    let curWords = [];
+    let curLen = 0;
+    for (const tok of tokens) {
+        const addedLen = (curLen > 0 ? 1 : 0) + tok.text.length;
+        if (curLen + addedLen > maxChars && curWords.length > 0) {
+            // Flush the current group.
+            cues.push(makeTokenCue(curWords, cues.length));
+            curWords = [];
+            curLen = 0;
+        }
+        curWords.push(tok);
+        curLen += (curLen > 0 ? 1 : 0) + tok.text.length;
+    }
+    
+
+
+    if (curWords.length > 0) {
+        cues.push(makeTokenCue(curWords, cues.length));
+    }
+    // Clamp the last cue's end to the segment duration if tokens overshoot.
+    
+
+    if (cues.length > 0) {
+        const last = cues[cues.length - 1];
+        if (last.end > fallbackDuration) {
+            last.end = fallbackDuration;
+        }
+    }
+    return cues;
+}
+function makeTokenCue(words, idx) {
+    return {
+        id: `cap_${idx}_${Math.random().toString(36).slice(2, 8)}`,
+        start: Number(words[0].start.toFixed(3)),
+        end: Number(words[words.length - 1].end.toFixed(3)),
+        text: words.map((w) => w.text).join(' '),
+    };
+}
+//# sourceMappingURL=captionSplitter.js.map

package/lib/cardMutations.d.ts

@@ -0,0 +1,52 @@
+/** Max length of a card title / flow name, enforced by this gate at edit time. The wire types carry titles as bare strings — the gate is the bound's single home. */
+export declare const TITLE_MAX_LEN = 120;
+export interface MutationSpec {
+    /** The field this mutation writes (the patch key). */
+    field: string;
+    /** Coerce the raw value before validation (trim). */
+    coerce: (v: unknown) => unknown;
+    /** Type-guard gate: string, non-empty after trim, <= TITLE_MAX_LEN. */
+    validate: (v: unknown) => v is string;
+}
+/** The closed set of stage mutations. Add a member + a CARD_MUTATIONS entry
+ * to extend the gate. */
+export type StageMutationKind = "rename";
+export type StageMutation = {
+    kind: "rename";
+    value: string;
+};
+export declare const CARD_MUTATIONS: Record<StageMutationKind, MutationSpec>;
+export type StageMutationResult = {
+    ok: true;
+    patch: {
+        title: string;
+    };
+} | {
+    ok: false;
+    error: string;
+};
+/** Pure gate. Unknown kinds error at runtime (defense in depth beyond the
+ * tsc union). Every card mutation must pass through here. */
+export declare function applyStageMutation(mutation: StageMutation): StageMutationResult;
+
+
+export type DocMutationKind = "rename";
+export type DocMutation = {
+    kind: "rename";
+    value: string;
+};
+export declare const DOC_MUTATIONS: Record<DocMutationKind, MutationSpec>;
+export type DocMutationResult = {
+    ok: true;
+    patch: {
+        name: string;
+    };
+} | {
+    ok: false;
+    error: string;
+};
+/** Pure gate for flow-doc mutations — the flow-level sibling of
+ * applyStageMutation. Cosmetic: the store action must NOT mark stale or
+ * recompute keys (a rename is not a semantic change). */
+export declare function applyDocMutation(mutation: DocMutation): DocMutationResult;
+//# sourceMappingURL=cardMutations.d.ts.map

package/lib/cardMutations.js

@@ -0,0 +1,67 @@
+
+//
+// DECLARATIVE way. One table, one gate — no per-kind imperative store code.
+// Each row declares the field a mutation kind writes + its validation
+// + coercion; extending the gate = adding a union member + a table row
+// (same discipline as _FORM_CONFIGS: one table the gate mirrors).
+//
+// The enforcement is two-layer, mirroring the catalog schema's pattern:
+// • HERE (frontend, edit time): the typed unions (tsc) + this runtime gate —
+// every card/doc mutation passes through applyStageMutation /
+// applyDocMutation (the shared runMutation core).
+// • WIRE (run start): FlowDoc.title AND BackendStage.title in FlowTypes.ts are bare strings — this gate is the bound's single home; a title that passes here fits the wire.
+// Bump all together.
+//
+
+// name gets a row in one of these tables + a bound in the owning layer
+// (this gate where the card owns the name, the wire contract where the
+// run owns it). No ad-hoc name writes — that's how drift and breakage
+// creep in.
+/** Max length of a card title / flow name, enforced by this gate at edit time. The wire types carry titles as bare strings — the gate is the bound's single home. */
+export const TITLE_MAX_LEN = 120;
+/** Shared core: coerce → validate → patch. Every table's apply* entry is a
+ * thin wrapper over this — one gate, one error language across targets. */
+function runMutation(spec, value) {
+    const v = spec.coerce(value);
+    if (!spec.validate(v)) {
+        return {
+            ok: false,
+            error: `Invalid ${spec.field}: must be 1-${TITLE_MAX_LEN} non-empty characters`,
+        };
+    }
+    return { ok: true, patch: { [spec.field]: v } };
+}
+export const CARD_MUTATIONS = {
+    rename: {
+        field: "title",
+        coerce: (v) => (typeof v === "string" ? v.trim() : v),
+        validate: (v) => typeof v === "string" && v.trim().length > 0 && v.trim().length <= TITLE_MAX_LEN,
+    },
+};
+/** Pure gate. Unknown kinds error at runtime (defense in depth beyond the
+ * tsc union). Every card mutation must pass through here. */
+export function applyStageMutation(mutation) {
+    const spec = CARD_MUTATIONS[mutation.kind];
+    if (!spec) {
+        return { ok: false, error: `Unknown stage mutation kind: ${mutation.kind}` };
+    }
+    return runMutation(spec, mutation.value);
+}
+export const DOC_MUTATIONS = {
+    rename: {
+        field: "name",
+        coerce: (v) => (typeof v === "string" ? v.trim() : v),
+        validate: (v) => typeof v === "string" && v.trim().length > 0 && v.trim().length <= TITLE_MAX_LEN,
+    },
+};
+/** Pure gate for flow-doc mutations — the flow-level sibling of
+ * applyStageMutation. Cosmetic: the store action must NOT mark stale or
+ * recompute keys (a rename is not a semantic change). */
+export function applyDocMutation(mutation) {
+    const spec = DOC_MUTATIONS[mutation.kind];
+    if (!spec) {
+        return { ok: false, error: `Unknown doc mutation kind: ${mutation.kind}` };
+    }
+    return runMutation(spec, mutation.value);
+}
+//# sourceMappingURL=cardMutations.js.map

package/lib/downloads.d.ts

@@ -0,0 +1,18 @@
+/** downloads - browser download triggers for pose artifacts
+ * (ex-lib/text-to-pose export helpers). */
+import type { PoseMotion } from "./textToPose.js";
+/**
+ * Trigger a browser download from a base64-encoded payload.
+ * Mirrors Kimodo demo's _download_bytes_to_browser (ui.py).
+ */
+export declare function downloadBase64Payload(b64: string, filename: string, mimeType?: string): void;
+/**
+ * Download the SOMA-77 motion as an .npz file (poses + rotmats + deformed verts).
+ */
+export declare function downloadMotionNpz(motion: PoseMotion, filename?: string): void;
+/**
+ * Capture the largest <canvas> on the page as a PNG download.
+ * Used for screenshots of the 3D viewer.
+ */
+export declare function downloadCanvasScreenshot(filename?: string): void;
+//# sourceMappingURL=downloads.d.ts.map