@slatesvideo/shared 0.6.2 → 0.6.4

package/dist/prompts/banned-tokens.d.ts

@@ -0,0 +1,40 @@
+/** Which generate op a list applies to. */
+export type BannedTokenScope = 'image' | 'video';
+export interface BannedToken {
+    /** The literal phrase, verbatim from the skill. */
+    token: string;
+    /** Skill file it was read from — cited in every warning. */
+    skill: string;
+    scope: BannedTokenScope;
+}
+/** Every banned token, in skill-document order. Integrity asserted at load. */
+export declare const BANNED_PROMPT_TOKENS: readonly BannedToken[];
+export declare function bannedTokensFor(scope: BannedTokenScope): readonly BannedToken[];
+/** The never-use list a single skill declares. Empty for a skill with no block. */
+export declare function bannedTokensForSkill(skill: string): readonly BannedToken[];
+/**
+ * A single model's never-use list, for the estimate RESULT.
+ *
+ * Deliberately NOT the cross-model list — that one already rides the op
+ * description on every call. This is the half that could not: the quirk that is
+ * true of Veo and false of Kling.
+ */
+export declare function describeBannedTokensForSkill(skill: string): string;
+/** The tokens a submitted prompt actually contains. `skill` adds that model's
+ *  own list to the modality-wide one — the two overlap for nano-banana-2 and
+ *  seedance, so hits are deduplicated by token. */
+export declare function findBannedTokens(prompt: string, scope: BannedTokenScope, skill?: string): BannedToken[];
+/**
+ * The list as it appears INSIDE an op description — always in context, on both
+ * surfaces, with no call required to see it. Generated, never hand-typed.
+ */
+export declare function describeBannedTokens(scope: BannedTokenScope): string;
+/**
+ * Non-blocking warning for a submitted prompt. Empty string when clean.
+ *
+ * Returned in the op RESULT — the one place the agent cannot avoid reading —
+ * rather than raised as an error. The generation proceeds either way: the
+ * sandbox doctrine says make state visible, never block.
+ */
+export declare function bannedTokenWarning(prompt: string, scope: BannedTokenScope, skill?: string): string;
+//# sourceMappingURL=banned-tokens.d.ts.map

package/dist/prompts/banned-tokens.js

@@ -0,0 +1,219 @@
+// ============================================================
+// BANNED PROMPT TOKENS — the "load the guide" rule, made structural.
+//
+// THE PROBLEM: "before prompting any model, load the matching guide" is a
+// sentence in a system prompt with nothing checking it. Measured 2026-08-30 in
+// a real Studio Agent session: slates_get_prompting_guide was called ZERO
+// times, and the prompt that shipped tripped the skill's own never-use list
+// twice (`photorealistic`, `cinematic`). A rule with no check is a suggestion,
+// and an LLM is the least reliable enforcer you could pick.
+//
+// THE FIX, in two halves, neither of which the model can skip:
+//   (a) the never-use list is INLINED into the generate ops' descriptions.
+//       Op descriptions are always in context on BOTH surfaces — there is no
+//       call to omit and no discretion to exercise.
+//   (b) the submitted prompt is MATCHED against the list and a warning comes
+//       back in the op result. Non-blocking: the generation proceeds
+//       (PRODUCT_PHILOSOPHY.md → make state visible, never block).
+//
+// 🚨 THE LIST IS NEVER HAND-TYPED HERE. It is extracted from the skill files
+// themselves, between `<!-- @banned:start -->` / `<!-- @banned:end -->`
+// markers. That is this workspace's LLM-docs doctrine — never hand-type a fact
+// an LLM will read — and it is the only way the op description and the skill
+// cannot drift apart. Change the skill; the description follows on the next
+// build. scripts/agent-surface-lockstep-check.mjs fails the build if a token
+// in a description no longer appears in its source skill.
+//
+// Deterministic by construction (document order, no sorting, no dedupe
+// reshuffle) because these strings land in the desktop's prompt-cached tool
+// prefix, whose byte-stability IS the cache mechanism.
+// ============================================================
+import { SKILLS } from '../skills/content.js';
+/**
+ * Where each scope's CROSS-MODEL list lives.
+ *
+ * One skill per scope on purpose: these are the two lists that are GENERIC to
+ * their modality (Stable-Diffusion-era tag soup for images, quality
+ * incantations for video), not model-specific quirks. A per-model list cannot
+ * ride the op DESCRIPTION — a description is one static string for every call,
+ * so it cannot change with the `model` argument. That is what
+ * `bannedTokensForSkill` below is for: the per-model list rides the estimate
+ * RESULT, where the model has just been named.
+ */
+const BANNED_TOKEN_SOURCES = [
+    { skill: 'slates-prompting-nano-banana-2', scope: 'image' },
+    { skill: 'slates-prompting-seedance', scope: 'video' },
+];
+/**
+ * 🚨 THE ENFORCEMENT THAT WORKED COVERED TWO SKILLS OF FIFTEEN.
+ *
+ * `describeBannedTokens('image')` was Nano Banana's list and `('video')` was
+ * Seedance's, so a Veo, Kling, LTX, MiniMax, FLUX, Seedream, GPT-Image or audio
+ * generation was matched against another model's never-use list and its own was
+ * enforced by nothing — while four skills (content-policy, lip-sync,
+ * minimax-h3, motion-transfer) carried never-use prose with no markers at all,
+ * which is a rule an LLM has to notice.
+ *
+ * Every skill that carries an `@banned` block now contributes to a per-skill
+ * list, delivered on the estimate result beside the craft card. The two above
+ * stay ALSO on the op descriptions, because a modality-wide list is true of
+ * every call that op can make.
+ */
+function extractPerSkill() {
+    const out = new Map();
+    for (const [skill, content] of Object.entries(SKILLS)) {
+        // Cheap pre-test: only pay the regex for files that carry the marker.
+        if (!content.includes('@banned:start'))
+            continue;
+        const scope = inferScope(skill);
+        out.set(skill, extractFromSkill(skill).map((token) => ({ token, skill, scope })));
+    }
+    return out;
+}
+/** Image-lane skills prompt for pixels; everything else is a time-based lane.
+ *  Only used to tag a token for the warning text — the per-skill list is
+ *  matched by SKILL, never by scope, so a wrong guess here cannot mis-enforce. */
+function inferScope(skill) {
+    return /nano-banana|gpt-image|flux|seedream/.test(skill) ? 'image' : 'video';
+}
+const FENCE_RE = /<!--\s*@banned:start\s*-->([\s\S]*?)<!--\s*@banned:end\s*-->/g;
+const HTML_COMMENT_RE = /<!--[\s\S]*?-->/g;
+const BACKTICKED_RE = /`([^`\n]+)`/g;
+/**
+ * Pull every backticked phrase out of a skill's fenced block(s).
+ *
+ * HTML comments are stripped FIRST: the fence carries a "MACHINE-READ" note to
+ * whoever edits the skill next, and that note itself contains backticks.
+ */
+function extractFromSkill(skill) {
+    const content = SKILLS[skill];
+    if (content === undefined) {
+        throw new Error(`[banned-tokens] no such skill: ${skill}. BANNED_TOKEN_SOURCES must name files in packages/shared/skills/.`);
+    }
+    const out = [];
+    let fence;
+    FENCE_RE.lastIndex = 0;
+    let fences = 0;
+    while ((fence = FENCE_RE.exec(content)) !== null) {
+        fences += 1;
+        const body = fence[1].replace(HTML_COMMENT_RE, '');
+        let m;
+        BACKTICKED_RE.lastIndex = 0;
+        while ((m = BACKTICKED_RE.exec(body)) !== null) {
+            const token = m[1].trim();
+            if (token && !out.includes(token))
+                out.push(token);
+        }
+    }
+    if (fences === 0) {
+        throw new Error(`[banned-tokens] ${skill}.md has no <!-- @banned:start --> / <!-- @banned:end --> block. ` +
+            `The op description and the prompt warnings are GENERATED from it — restore the markers, ` +
+            `or drop the skill from BANNED_TOKEN_SOURCES.`);
+    }
+    if (out.length === 0) {
+        throw new Error(`[banned-tokens] ${skill}.md has a @banned block with no backticked tokens in it. ` +
+            `An empty list would silently disable the check instead of failing it.`);
+    }
+    return out;
+}
+/** Every banned token, in skill-document order. Integrity asserted at load. */
+export const BANNED_PROMPT_TOKENS = BANNED_TOKEN_SOURCES.flatMap(({ skill, scope }) => extractFromSkill(skill).map((token) => ({ token, skill, scope })));
+const byScope = new Map();
+for (const entry of BANNED_PROMPT_TOKENS) {
+    const list = byScope.get(entry.scope) ?? [];
+    list.push(entry);
+    byScope.set(entry.scope, list);
+}
+export function bannedTokensFor(scope) {
+    return byScope.get(scope) ?? [];
+}
+/** Regex cache — one word-boundary matcher per token, built once. */
+const matchers = new Map();
+function matcherFor(token) {
+    let re = matchers.get(token);
+    if (!re) {
+        const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // \b at both ends so `4k` does not fire inside "84king" and `flawless`
+        // does not fire inside "flawlessly". Every token starts and ends with a
+        // word character today; if one ever starts with punctuation, \b would
+        // anchor wrong — the load-time check below is what would catch it.
+        re = new RegExp(`\\b${escaped}\\b`, 'i');
+        matchers.set(token, re);
+    }
+    return re;
+}
+for (const { token, skill } of BANNED_PROMPT_TOKENS) {
+    if (!/^\w/.test(token) || !/\w$/.test(token)) {
+        throw new Error(`[banned-tokens] ${skill}: token ${JSON.stringify(token)} does not start and end with a word ` +
+            `character, so the \\b word-boundary match would never fire. Rewrite the entry or teach ` +
+            `matcherFor() the new shape.`);
+    }
+}
+/** Every per-skill list, keyed by skill name. */
+const bySkill = extractPerSkill();
+/** The never-use list a single skill declares. Empty for a skill with no block. */
+export function bannedTokensForSkill(skill) {
+    return bySkill.get(skill) ?? [];
+}
+/**
+ * A single model's never-use list, for the estimate RESULT.
+ *
+ * Deliberately NOT the cross-model list — that one already rides the op
+ * description on every call. This is the half that could not: the quirk that is
+ * true of Veo and false of Kling.
+ */
+export function describeBannedTokensForSkill(skill) {
+    const list = bannedTokensForSkill(skill);
+    if (list.length === 0)
+        return '';
+    return (`NEVER put these in a ${skill.replace('slates-prompting-', '')} prompt: ` +
+        list.map((b) => `"${b.token}"`).join(', ') +
+        `. Describe specifically instead (${skill}).`);
+}
+/** The tokens a submitted prompt actually contains. `skill` adds that model's
+ *  own list to the modality-wide one — the two overlap for nano-banana-2 and
+ *  seedance, so hits are deduplicated by token. */
+export function findBannedTokens(prompt, scope, skill) {
+    const candidates = [...bannedTokensFor(scope), ...(skill ? bannedTokensForSkill(skill) : [])];
+    const seen = new Set();
+    const hits = [];
+    for (const b of candidates) {
+        if (seen.has(b.token))
+            continue;
+        seen.add(b.token);
+        if (matcherFor(b.token).test(prompt))
+            hits.push(b);
+    }
+    return hits;
+}
+/**
+ * The list as it appears INSIDE an op description — always in context, on both
+ * surfaces, with no call required to see it. Generated, never hand-typed.
+ */
+export function describeBannedTokens(scope) {
+    const list = bannedTokensFor(scope);
+    if (list.length === 0)
+        return '';
+    const skills = [...new Set(list.map((b) => b.skill))].join(' / ');
+    return (`NEVER put these in a prompt (they measurably degrade output — full rationale in ${skills}): ` +
+        list.map((b) => `"${b.token}"`).join(', ') +
+        `. Describe specifically instead.`);
+}
+/**
+ * Non-blocking warning for a submitted prompt. Empty string when clean.
+ *
+ * Returned in the op RESULT — the one place the agent cannot avoid reading —
+ * rather than raised as an error. The generation proceeds either way: the
+ * sandbox doctrine says make state visible, never block.
+ */
+export function bannedTokenWarning(prompt, scope, skill) {
+    const hits = findBannedTokens(prompt, scope, skill);
+    if (hits.length === 0)
+        return '';
+    const skills = [...new Set(hits.map((b) => b.skill))].join(', ');
+    return (`⚠️ PROMPT WARNING: your prompt contains ${hits.map((b) => `"${b.token}"`).join(', ')} — ` +
+        `on the never-use list in ${skills}. Not blocked, and this generation ran as submitted. ` +
+        `Load that guide with slates_get_prompting_guide and rewrite with specific description ` +
+        `(named lens, light direction, stock, composition) before the next generation.`);
+}
+//# sourceMappingURL=banned-tokens.js.map

package/dist/prompts/character-sheet.d.ts

@@ -13,8 +13,6 @@
  * removal and must be SCOPED TO THE FACE rather than to the whole body.
  */
 export declare const CHARACTER_SHEET_PANELS_DESC: string;
-/** Panel identifiers, in sheet order. */
-export declare const BODY_POSE_LABELS: readonly ["portrait", "front", "back"];
 /**
  * The character identity sheet — one asset, three panels.
  *

package/dist/prompts/character-sheet.js

@@ -139,8 +139,6 @@ export const CHARACTER_SHEET_PANELS_DESC = 'a large chest-up portrait on the lef
     'a full-body front view in a relaxed A-pose in the centre, cropped at the collarbone — ' +
     'an invisible-mannequin presentation with just the face cropped out, ' +
     'and a full-body back view on the right with the head and hair fully visible';
-/** Panel identifiers, in sheet order. */
-export const BODY_POSE_LABELS = ['portrait', 'front', 'back'];
 // The sheet's style directive: a user transform REPLACES the inherit-source
 // instruction (so the model isn't told to both preserve the medium AND change
 // it); otherwise inherit the source medium.

package/dist/prompts/craft-cards.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Hard ceiling per card, in characters.
+ *
+ * A card is a CARD. The largest skill is 5,736 words and loading it whole is
+ * exactly the cost this mechanism exists to avoid — if a card needs more than
+ * this, the extra belongs in the body of the skill, which is one
+ * `slates_get_prompting_guide` call away. Asserted at load, so an over-long
+ * card fails the build rather than quietly inflating every estimate result.
+ */
+export declare const CRAFT_CARD_CEILING = 2400;
+/** Every card, keyed by skill name. Built once at load; integrity asserted. */
+export declare const CRAFT_CARDS: Readonly<Record<string, string>>;
+/** The card for a skill, or null when that skill carries none. */
+export declare function craftCard(skill: string): string | null;
+/**
+ * The card as it appears in an op RESULT: the body, plus one line naming where
+ * the rest lives so the agent knows the card is a summary and not the guide.
+ */
+export declare function describeCraftCard(skill: string): string;
+//# sourceMappingURL=craft-cards.d.ts.map

package/dist/prompts/craft-cards.js

@@ -0,0 +1,82 @@
+// ============================================================
+// CRAFT CARDS — the POSITIVE half of "load the guide", made structural.
+//
+// THE MEASUREMENT THIS ANSWERS (2026-08-30, 48 trials at k=8, same brain, same
+// scorer). Inlining each model's NEVER-USE list into the generate ops'
+// descriptions moved `no_banned_tokens` from 0/8 to 30/32 — 94%. Over the same
+// runs, `guide_before_generate` was 13% before and 13% after: the agent still
+// did not fetch the skill. So the skill's NEGATIVE half became enforced and its
+// POSITIVE half — the named lens, the light direction, the stock, the
+// composition, the levers that make a shot GOOD rather than merely UN-BAD —
+// still only arrived if the model chose to go and get it, and it usually did
+// not.
+//
+// The lesson generalised in the CLAUDE.md rules: put the FACT where it cannot
+// be skipped, not a POINTER to the fact. A card is that fact for the positive
+// half — 250-400 words of the levers that matter for ONE model, delivered
+// where the agent is already looking.
+//
+// 🚨 WHERE IT IS DELIVERED, AND WHY THERE. On the RESULT of
+// `slates_estimate_generation_cost`, which the doctrine already tells the agent
+// to call before every generation. That placement costs ZERO prefix bytes — the
+// desktop's cached tool prefix is unchanged — and it arrives at the one moment
+// the model has just named the model it is about to use. Putting it in the
+// `model` param description instead would have grown the largest op on the
+// surface by 15 cards on every turn of every session, to be read once.
+//
+// 🚨 THE CARD IS NEVER WRITTEN HERE. It is EXTRACTED from the skill file
+// itself, between `<!-- @card:start -->` / `<!-- @card:end -->` markers — the
+// same mechanism, and the same reason, as banned-tokens.ts: a card authored
+// downstream is a second copy of the skill that drifts from it. Edit the skill;
+// the card follows on the next build.
+// ============================================================
+import { SKILLS } from '../skills/content.js';
+/**
+ * Hard ceiling per card, in characters.
+ *
+ * A card is a CARD. The largest skill is 5,736 words and loading it whole is
+ * exactly the cost this mechanism exists to avoid — if a card needs more than
+ * this, the extra belongs in the body of the skill, which is one
+ * `slates_get_prompting_guide` call away. Asserted at load, so an over-long
+ * card fails the build rather than quietly inflating every estimate result.
+ */
+export const CRAFT_CARD_CEILING = 2400;
+const CARD_FENCE_RE = /<!--\s*@card:start\s*-->([\s\S]*?)<!--\s*@card:end\s*-->/g;
+/** Author notes to whoever edits the skill next; never part of the card. */
+const HTML_COMMENT_RE = /<!--[\s\S]*?-->/g;
+function extractCard(skill, content) {
+    CARD_FENCE_RE.lastIndex = 0;
+    const parts = [];
+    let m;
+    while ((m = CARD_FENCE_RE.exec(content)) !== null) {
+        parts.push(m[1].replace(HTML_COMMENT_RE, '').trim());
+    }
+    if (parts.length === 0)
+        return null;
+    const body = parts.join('\n\n').trim();
+    if (body.length > CRAFT_CARD_CEILING) {
+        throw new Error(`[craft-cards] ${skill}.md's @card block is ${body.length} chars, over the ` +
+            `${CRAFT_CARD_CEILING} ceiling. A card rides EVERY estimate result for that model — ` +
+            `move the overflow into the body of the skill, which slates_get_prompting_guide returns whole.`);
+    }
+    return body;
+}
+/** Every card, keyed by skill name. Built once at load; integrity asserted. */
+export const CRAFT_CARDS = Object.freeze(Object.fromEntries(Object.entries(SKILLS)
+    .map(([skill, content]) => [skill, extractCard(skill, content)])
+    .filter((entry) => entry[1] !== null)));
+/** The card for a skill, or null when that skill carries none. */
+export function craftCard(skill) {
+    return CRAFT_CARDS[skill] ?? null;
+}
+/**
+ * The card as it appears in an op RESULT: the body, plus one line naming where
+ * the rest lives so the agent knows the card is a summary and not the guide.
+ */
+export function describeCraftCard(skill) {
+    const card = craftCard(skill);
+    if (!card)
+        return '';
+    return `${card}\n\nFull guide (examples, failure modes, sources): slates_get_prompting_guide("${skill}").`;
+}
+//# sourceMappingURL=craft-cards.js.map

package/dist/prompts/environment-sheet.js

@@ -25,6 +25,22 @@ export function buildEnvironmentEstablishingPrompt(userStyle) {
         `If the reference image contains people or characters, generate the location as an empty space — ignore the figures. ` +
         `No text, no labels, no captions.`);
 }
+// ⚠️ STATUS: authored doctrine that currently reaches NO model. Adjudicated
+// 2026-09-04 (dead-code sweep §5 D1). Both constants below have zero consumers
+// anywhere in the workspace, and — unlike IMAGE_PROMPT_FORMULA, which was a
+// verbatim second copy of slates-prompting-nano-banana-2.md and was deleted —
+// nothing in skills/*.md or the craft cards carries this content. So it is a
+// capability gap, not a duplicate: deleting it would lose the only copy.
+//
+// The fix is NOT to wire a TS consumer. craft-cards.ts states the rule: "THE
+// CARD IS NEVER WRITTEN HERE… a card authored downstream is a second copy of
+// the skill that drifts from it." Environment plates have no skill of their own
+// yet (there is a Characters/Environments/Styles tab in the product, and a
+// slates-character-identity skill, but no environment counterpart). Wiring this
+// in means AUTHORING that skill section — a content + token-budget decision —
+// after which these two constants should be deleted, not kept alongside it.
+//
+// Until then: EDITING THE TEXT BELOW CHANGES NOTHING THAT SHIPS.
 /** Guidance shown to users/agents: prefer describing the environment in text. */
 export const ENVIRONMENT_DESCRIBE_FIRST = 'Default to describing the environment in words and let the model build it to fit the shot. Generate an establishing plate only when a location must be locked exactly across shots. ' +
     'When you do: frame it three-quarter, never dead-on (a frontal facade turns the location into a backdrop characters stand in FRONT of; a three-quarter exposes side geometry and usable floor), ' +

package/dist/prompts/index.d.ts

@@ -7,4 +7,5 @@ export * from './model-facts.js';
 export * from './character-sheet.js';
 export * from './environment-sheet.js';
 export * from './prompting-tips.js';
+export * from './asset-label.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/prompts/index.js

@@ -24,4 +24,8 @@ export * from './environment-sheet.js';
 // desktop RENDERER imports the tips — the root barrel re-exports auth.js
 // (node:fs/os/path), which breaks browser bundling. `./prompts` stays Node-free.
 export * from './prompting-tips.js';
+// Asset captions — one rule for the op surface's compactAsset and the desktop
+// gallery. Also its own leaf subpath (`@slatesvideo/shared/asset-label`) for the
+// renderer, which cannot import the root barrel.
+export * from './asset-label.js';
 //# sourceMappingURL=index.js.map

package/dist/prompts/model-capabilities.d.ts

@@ -6,8 +6,20 @@ export type AspectRatio = '1:1' | '2:3' | '3:2' | '3:4' | '4:3' | '4:5' | '5:4'
  * and prices between 480p and 2K ($0.060/s vs 720p Seedance's $0.15/s — a
  * different tier of a different model, not a rename); 2K is H3's upscaled tier.
  * Aliasing either onto 720p/1080p would build a cost key that does not exist.
+ *
+ * 🚨 `1440p` entered with LTX-2.5 (2026-08-29) and is likewise NOT an alias —
+ * specifically it is NOT `2k`, despite both being ~1440 lines tall. `2k` is
+ * H3's UPSCALED tier ($0.130/s, an H3-Regenerate-2K pass over a 768p base);
+ * `1440p` is LTX's NATIVELY GENERATED tier ($0.190/s). Different models,
+ * different mechanisms, different prices, and `ltx-2-5-2k-6s` is a key that
+ * exists nowhere. Co-height is not sameness.
+ *
+ * ⚠️ Our `4k` is LTX's `2160p` ON THE WIRE. fal's enum literal for that tier is
+ * `2160p` while its own pricing copy calls it "4K". `4k` stays the token here
+ * because it is what every cost key, `is4kVideoKey` and the Pro gate already
+ * speak; the handler translates at the request boundary.
  */
-export type VideoResolution = '480p' | '720p' | '768p' | '1080p' | '2k' | '4k';
+export type VideoResolution = '480p' | '720p' | '768p' | '1080p' | '1440p' | '2k' | '4k';
 /**
  * The full ten, in display order. `9:21` was in the MCP op's enum and in NO
  * model — it was invented downstream. Do not add a ratio here that no model
@@ -37,6 +49,41 @@ export interface VideoResolutionCapability {
     default?: VideoResolution;
 }
 /** Everything a model will ACCEPT. Capability only — never a price. */
+/**
+ * What a TEXT-TO-SPEECH surface accepts. Every number here was MEASURED against
+ * the live API on 2026-09-05, not read from documentation — the vendor's docs
+ * omit the rate limit entirely and its API accepts an unknown `audioEncoding`
+ * with a 200 rather than a 400, so anything taken on trust here is a guess that
+ * bills.
+ *
+ * 🚨 `clonesPerMinute` IS A PRODUCT CONSTRAINT, NOT A TUNING KNOB. The vendor
+ * rate-limits voice cloning WORKSPACE-WIDE (every Slates user shares our one
+ * key), so it caps how many people can mint a voice in the same minute across
+ * the whole product. It is surfaced here so the seat can say so in words rather
+ * than failing opaquely.
+ */
+export interface VoiceCloneCapability {
+    /** Reference-audio duration the clone endpoint accepts, in seconds. */
+    minSeconds: number;
+    maxSeconds: number;
+    /** Ceiling on ONE reference sample, in bytes. */
+    maxBytes: number;
+    /** Container formats the clone endpoint decodes. */
+    formats: readonly string[];
+    /** Clone requests per minute, WORKSPACE-WIDE (measured: a 429 names the limit). */
+    clonesPerMinute: number;
+    /**
+     * Stored custom voices the plan allows. The seat holds the steady-state count
+     * near ZERO by deleting each voice after it renders (mint → synthesize →
+     * delete), so this is the wall that argument exists to never reach.
+     */
+    maxStoredVoices: number;
+    /** Bounds on the voice-DESIGN prompt, the path that needs no reference audio. */
+    designPromptChars: {
+        min: number;
+        max: number;
+    };
+}
 export interface ModelCapability {
     aspectRatios: AspectRatio[];
     /** Provider-keyed overrides. `fal` is the one that matters — see AGENT_ROUTE_PROVIDER. */
@@ -57,6 +104,14 @@ export interface ModelCapability {
     maxReferenceVideoSeconds?: number;
     /** Combined seconds across every reference audio clip. */
     maxReferenceAudioSeconds?: number;
+    /**
+     * Max characters in ONE synthesis request. Present ⟺ the surface is TTS.
+     * This is the number the character BILLING BUCKET is sized against, so it
+     * must never be hand-typed downstream — `slate`'s registry spreads it in.
+     */
+    maxCharacters?: number;
+    /** Reference-audio and voice-design spec. Present ⟺ the surface can clone. */
+    voiceClone?: VoiceCloneCapability;
 }
 /**
  * The provider every AGENT generation actually lands on for Kling and Veo.
@@ -74,6 +129,15 @@ export interface ModelCapability {
 export declare const AGENT_ROUTE_PROVIDER = "fal";
 export declare const MODEL_CAPABILITIES: Record<string, ModelCapability>;
 export declare function getModelCapability(model: string): ModelCapability | undefined;
+/**
+ * The voice-cloning spec for a TTS surface, or undefined for anything else.
+ *
+ * Exists so the desktop reads the reference-audio bounds, the design-prompt
+ * bounds and the clone rate limit from HERE rather than retyping them into a
+ * form control. A control whose limit disagrees with the vendor's is a limit
+ * the user first meets AFTER pressing the button.
+ */
+export declare function voiceCloneFor(model: string): VoiceCloneCapability | undefined;
 /** Aspect ratios a model accepts, honouring the provider override. */
 export declare function aspectRatiosFor(model: string, provider?: string): AspectRatio[];
 /** Video resolutions a model accepts. A FIXED model reports exactly its one value. */