@slatesvideo/shared 0.6.3 → 0.6.5

package/dist/prompts/reference-rules.d.ts

@@ -1,17 +1,4 @@
 export { PARTIALS } from './partials.generated.js';
-export type SourceGrade = 'Eric-test' | 'community' | 'code-verified' | 'creator-demo';
-export interface ReferenceRule {
-    id: string;
-    title: string;
-    rule: string;
-    why: string;
-    grade: SourceGrade;
-}
-/**
- * The 10 verified reference rules. These are the WHY; the fragments below
- * are the reusable text the templates compose.
- */
-export declare const REFERENCE_RULES: ReferenceRule[];
 /** Flat, even, shadowless identity lighting on a deep neutral-grey plate. */
 export declare const IDENTITY_LIGHTING = "flat, even, shadowless lighting";
 /**
@@ -21,21 +8,23 @@ export declare const IDENTITY_LIGHTING = "flat, even, shadowless lighting";
  */
 export declare const IDENTITY_PLATE_HEX = "#3a3a3c";
 /**
- * 🚨 THE HEX IS EMITTED WITHOUT ITS `#` AND THAT IS LOAD-BEARING (2026-07-30).
- *
- * `#` is a REFERENCE-TOKEN SIGIL in the desktop's prompt composer
- * (`slate/src/shared/promptComposition.ts` — `/([@#])([\w-]+)/g`), and an
- * unresolved `#token` is SILENTLY DELETED. So `#3a3a3c` never survived to any
- * model: fal echoed back `deep neutral-grey background ()` on a real 2026-07-30
- * request. The plate value has been doing nothing since the composer shipped.
+ * THE HEX IS EMITTED WITHOUT ITS `#`. This USED to be load-bearing (2026-07-30):
+ * `#` is a reference-token sigil in the prompt composer, and an unresolved
+ * `#token` was SILENTLY DELETED, so `#3a3a3c` never survived to any model — fal
+ * echoed back `deep neutral-grey background ()` on a real 2026-07-30 request and
+ * the plate value had been doing nothing since the composer shipped.
  *
- * Writing it bare keeps the value in the prompt. `IDENTITY_PLATE_HEX` keeps its
- * `#` because it is a colour constant and may have non-prompt consumers.
+ * 🚨 THE HAZARD IS GONE, AND THE OLD GENERAL RULE WITH IT. The composer now
+ * treats a sigil as a mention ONLY when it resolves and passes every other
+ * `@`/`#` through byte-identically (`reference-composer.ts` → `TOKEN_RE`) — the
+ * exact "HOW YOU'D KNOW THIS IS BEATEN" this comment used to name. Emitting a
+ * `#hex` or an `@handle` into prompt text is safe again.
  *
- * GENERAL RULE FOR THIS FILE: never emit `#` or `@` into prompt text. Both are
- * sigils downstream and both mangle silently — no error, no log, just missing
- * words. HOW YOU'D KNOW THIS IS BEATEN: the composer stops treating bare
- * `#hex` as a token, or starts leaving unresolved tokens intact.
+ * It stays bare here anyway: "hex 3a3a3c" reads at least as clearly to a model,
+ * and rewording it would churn the generated skills/docs corpus for no gain.
+ * That is now a style choice, NOT a workaround — do not re-derive a "never emit
+ * a sigil" law from it. `IDENTITY_PLATE_HEX` keeps its `#` because it is a
+ * colour constant with possible non-prompt consumers.
  */
 export declare const IDENTITY_BACKGROUND: string;
 export declare const IDENTITY_LIGHTING_CLAUSE: string;

package/dist/prompts/reference-rules.js

@@ -1,90 +1,10 @@
 // Reference best-practices — the canonical "how to use reference images"
 // knowledge for every Slates surface (desktop templates, MCP skills, the
 // lead-magnet .skill). Authored ONCE here; consumers derive from it.
-//
-// Source grades: [Eric-test] = Eric's own hands-on result (doctrine-grade);
-// [community] = multi-guide consensus; [code-verified] = verified against
-// the slate codebase; [creator-demo] = single creator demonstration.
 // The generated partial store — one entry per skills/_partials/*.md file.
 // Re-exported so consumers can reach any partial, not just the rules block.
 export { PARTIALS } from './partials.generated.js';
 import { PARTIALS } from './partials.generated.js';
-/**
- * The 10 verified reference rules. These are the WHY; the fragments below
- * are the reusable text the templates compose.
- */
-export const REFERENCE_RULES = [
-    {
-        id: 'two-to-four-refs',
-        title: '2-4 strong references beat both extremes',
-        rule: 'Use 2-4 strong, focused references — not 1 (warps), not 12 (averages worse). Start with 2-3.',
-        why: 'One reference warps toward itself; a dozen averages everyone into mush. One tester cut drift ~60% going 6→2.',
-        grade: 'community',
-    },
-    {
-        id: 'one-ref-per-role',
-        title: 'One reference per ROLE, labeled in the prompt',
-        rule: 'Use one reference per role — identity, style-grade, environment — and label each role explicitly in the prompt text. The model does not infer roles from order.',
-        why: 'Same-role competitors drift; two "identity" refs of different people blend into a third face.',
-        grade: 'community',
-    },
-    {
-        id: 'identity-name-as-one-entity',
-        title: 'One identity sheet per character, named inline',
-        rule: 'Attach the character\'s single identity sheet (dominant portrait + body panels) rather than a pile of views — fewer competing renderings of a face is better, because the model cannot tell which is authoritative and averages them. Cite it inline as the subject ("Marcus (image 1)"). Do not inject a role essay ("use for identity, ignore the outfit/lighting, render neutral"): the user\'s prompt owns wardrobe, expression, and lighting.',
-        why: 'Distinct inline naming is each model\'s own consistency lever — NB2 "assign a distinct name to each character/object"; Seedance "Reference <Subject_N> in <Image_N>"; Kling "reuse a fixed label verbatim". One canonical identity image removes same-role competition before it starts.',
-        grade: 'Eric-test',
-    },
-    {
-        id: 'flat-light-identity',
-        title: 'Flat-light identity refs',
-        rule: 'Prep identity refs with flat, even, shadowless lighting on a plain neutral background. Studio-lit or scene-lit sheets bleed their lighting into every generation.',
-        why: "Eric's Norse-woman test: a studio-lit sheet produced a subject that looked green-screen-pasted in front of mountains. Reference prep beats prompting here.",
-        grade: 'Eric-test',
-    },
-    {
-        id: 'describe-environment',
-        title: 'Environment: describe it, don\'t feed a grid',
-        rule: 'Default to describing the environment in words. Reserve an environment reference for a mandatory exact-match location, and when you do, use ONE clean establishing image — never a multi-panel grid fed whole.',
-        why: "Eric's test: character sheet + 3x3 mountain grid → pasted-in mess; the same character + a described background → believable scene with natural lighting the model invented to fit.",
-        grade: 'Eric-test',
-    },
-    {
-        id: 'grids-explore-not-input',
-        title: 'Grids: generation/exploration = fine; INPUT reference = bad',
-        rule: 'Use grids to EXPLORE compositions (cheap multi-angle generation), then pick a cell. Do NOT feed a grid back in as a reference image — cells share a split detail budget and generate jointly, so flaws propagate.',
-        why: 'A picked cell re-generated with a "preserve the exact composition" prompt keeps its flaws faithfully (that is the budget path, kept on purpose). A loose prompt can fix anatomy but drifts off the picked composition.',
-        grade: 'code-verified',
-    },
-    {
-        id: 'reuse-refs',
-        title: 'Reuse the same refs across all shots',
-        rule: 'Lock a reference set and reuse it across every shot in a sequence. Swapping refs mid-sequence causes drift.',
-        why: 'The model adapts environment refs to each prompt rather than copying them, so swapping compounds inconsistency shot to shot.',
-        grade: 'community',
-    },
-    {
-        id: 'text-as-start-frame',
-        title: 'Legible in-shot text → image start-frame, never trust text-to-video',
-        rule: 'When a shot needs legible on-screen text, bake it into a still start frame (NB2) and animate from that. Do not expect a text-to-video model to render clean text.',
-        why: 'Video models smear text; an image model holds it, and the video inherits the locked frame.',
-        grade: 'community',
-    },
-    {
-        id: 'i2v-own-footage',
-        title: 'I2V / own-footage superpower — describe only what changes',
-        rule: 'Restyle your own clip while keeping the performance; "video one" delayed-VFX; marker-object insertion; video-as-ref for a series. In all cases describe ONLY what changes, not the whole scene.',
-        why: 'The source clip already carries motion, timing, and performance; re-describing them fights the model. Narrate the delta.',
-        grade: 'creator-demo',
-    },
-    {
-        id: 'style-transform-nl',
-        title: 'Style transform by natural language',
-        rule: 'Default: keep the source\'s artistic medium/style. To change it, add a plain-text instruction ("anime → real person") — no preset pickers.',
-        why: 'Paste/natural-language over preset menus is the product philosophy; the medium is inherited unless the user explicitly asks to transform it.',
-        grade: 'Eric-test',
-    },
-];
 // ── Reusable text fragments (the template-assembly building blocks) ──
 // These are the exact strings the desktop prompt templates, MCP skills,
 // and lead-magnet compose. Change a rule HERE and every consumer follows.
@@ -97,21 +17,23 @@ export const IDENTITY_LIGHTING = 'flat, even, shadowless lighting';
  */
 export const IDENTITY_PLATE_HEX = '#3a3a3c';
 /**
- * 🚨 THE HEX IS EMITTED WITHOUT ITS `#` AND THAT IS LOAD-BEARING (2026-07-30).
- *
- * `#` is a REFERENCE-TOKEN SIGIL in the desktop's prompt composer
- * (`slate/src/shared/promptComposition.ts` — `/([@#])([\w-]+)/g`), and an
- * unresolved `#token` is SILENTLY DELETED. So `#3a3a3c` never survived to any
- * model: fal echoed back `deep neutral-grey background ()` on a real 2026-07-30
- * request. The plate value has been doing nothing since the composer shipped.
+ * THE HEX IS EMITTED WITHOUT ITS `#`. This USED to be load-bearing (2026-07-30):
+ * `#` is a reference-token sigil in the prompt composer, and an unresolved
+ * `#token` was SILENTLY DELETED, so `#3a3a3c` never survived to any model — fal
+ * echoed back `deep neutral-grey background ()` on a real 2026-07-30 request and
+ * the plate value had been doing nothing since the composer shipped.
  *
- * Writing it bare keeps the value in the prompt. `IDENTITY_PLATE_HEX` keeps its
- * `#` because it is a colour constant and may have non-prompt consumers.
+ * 🚨 THE HAZARD IS GONE, AND THE OLD GENERAL RULE WITH IT. The composer now
+ * treats a sigil as a mention ONLY when it resolves and passes every other
+ * `@`/`#` through byte-identically (`reference-composer.ts` → `TOKEN_RE`) — the
+ * exact "HOW YOU'D KNOW THIS IS BEATEN" this comment used to name. Emitting a
+ * `#hex` or an `@handle` into prompt text is safe again.
  *
- * GENERAL RULE FOR THIS FILE: never emit `#` or `@` into prompt text. Both are
- * sigils downstream and both mangle silently — no error, no log, just missing
- * words. HOW YOU'D KNOW THIS IS BEATEN: the composer stops treating bare
- * `#hex` as a token, or starts leaving unresolved tokens intact.
+ * It stays bare here anyway: "hex 3a3a3c" reads at least as clearly to a model,
+ * and rewording it would churn the generated skills/docs corpus for no gain.
+ * That is now a style choice, NOT a workaround — do not re-derive a "never emit
+ * a sigil" law from it. `IDENTITY_PLATE_HEX` keeps its `#` because it is a
+ * colour constant with possible non-prompt consumers.
  */
 export const IDENTITY_BACKGROUND = `a plain, deep neutral-grey background (hex ${IDENTITY_PLATE_HEX.replace('#', '')})`;
 export const IDENTITY_LIGHTING_CLAUSE = `Render on ${IDENTITY_BACKGROUND} with ${IDENTITY_LIGHTING} so the sheet captures the character's identity, not scene lighting.`;

package/dist/prompts/shot-grammar.d.ts

@@ -0,0 +1,154 @@
+/**
+ * SHOT GRAMMAR — the buckets that COUNT framing, and the measured speech rate.
+ *
+ * 🚨 KEEP THIS A DEPENDENCY-FREE LEAF, exported from its own subpath
+ * (`@slatesvideo/shared/shot-grammar`). The desktop imports it from
+ * `slate/src/shared/` for the variety counter and the fit check, and the same
+ * two reasons that made `model-capabilities.ts` a leaf apply verbatim: the root
+ * barrel re-exports `auth.js` → `node:fs` (breaks renderer bundling) and
+ * `/prompts` drags the 5,000-word tips corpus in with no `require` condition.
+ *
+ * 🚨 BUCKETS EXIST TO COUNT, NEVER TO CONSTRAIN. `rules/ads/cinematic-storyboard.md`
+ * §4e, reconciled against ByteDance's own ModelArk docs: *"Camera vocabulary is
+ * open standard language and includes shot size (close-up / medium / wide) —
+ * not a closed list of eight moves."* Authoring `shotSize` and `camera` is FREE
+ * TEXT. A value matching no bucket counts as `other` and is never rejected,
+ * rewritten, or warned about. This module is the ONE home for these names —
+ * a second bucket list anywhere downstream is the drift `MODEL_CAPABILITIES`
+ * was created to end.
+ */
+export declare const SHOT_SIZE_BUCKETS: readonly ["wide", "medium", "close", "extreme-close", "other"];
+export type ShotSizeBucket = (typeof SHOT_SIZE_BUCKETS)[number];
+export declare const CAMERA_MOVE_BUCKETS: readonly ["static", "push", "pull", "handheld", "orbit", "crane", "other"];
+export type CameraMoveBucket = (typeof CAMERA_MOVE_BUCKETS)[number];
+/** Which shot-size bucket a free-text value counts in. Never rejects. */
+export declare function bucketShotSize(raw: string | null | undefined): ShotSizeBucket;
+/** Which camera-move bucket a free-text value counts in. Never rejects. */
+export declare function bucketCameraMove(raw: string | null | undefined): CameraMoveBucket;
+/** Human label for a bucket, for a header strip or an op result. Derived from
+ *  the bucket name so a seventh bucket cannot ship without a label. */
+export declare function bucketLabel(bucket: ShotSizeBucket | CameraMoveBucket): string;
+/**
+ * 🚨 MEASURED, NOT CITED — and the corpus is ours.
+ *
+ * An earlier draft of the plan that introduced this said no source existed and
+ * deferred the fit check. That was a claim about the world made without looking:
+ * `second-brain/business/projects/slates/content-strategy/examples/ad-research.db`
+ * carries `transcript` and `duration_seconds` on every row and always did.
+ *
+ * ⚠️ IT IS A CORPUS STATISTIC, SO IT DECAYS AND MUST STAY RE-DERIVABLE.
+ * `SPEECH_RATE_QUERY` below is the exact derivation; a constant whose query no
+ * longer reproduces it is STALE, not wrong — update the number and the `n`
+ * together. Same discipline as the pSEO `verifiedOn` dates. What it must never
+ * become is a hand-typed figure nobody can reproduce.
+ *
+ * 🚨 THE SAMPLE IS OPT-IN, AND THAT IS THE WHOLE POINT (2026-09-04, Eric).
+ * A row counts ONLY if its `speech_rate` column names a register. The query
+ * used to take every row carrying a transcript, which coupled two things that
+ * have no business touching: **researching a new ad turned a Slates RELEASE
+ * BUILD red.** `predist` → `check:all` → `check:shot-list` re-derives from the
+ * vault, so two ads landing in the corpus blocked `npm run dist` on work that
+ * had nothing to do with the desktop app. Opt-in decouples them — new research
+ * changes nothing until it is marked, so a red check is a deliberate act again
+ * rather than noise, and blocking on it is finally correct.
+ *
+ * Three things the old unfiltered query got wrong, all fixed by the mark:
+ * 1. **wpm is words ÷ TOTAL RUNTIME, not speaking time**, so a silence-heavy or
+ *    music-only ad reads as a slow talker. The corpus really held a 179s row at
+ *    55 wpm and a 16s row at 26 wpm. Nobody speaks at 26 wpm.
+ * 2. **`has_voiceover` was SELECTed and never filtered on** — 9 of the 74 rows
+ *    had no voiceover at all. (One row's value is the free text
+ *    `'yes (scripted dialogue/interviews)'`, so a naive boolean filter would
+ *    have dropped a real read as well.)
+ * 3. **The register was a creator-name regex on free text.** `%AI Video
+ *    Bootcamp%` happened to catch three different spellings of one person, and
+ *    `conversational` was the median over EVERYTHING — the other two registers
+ *    included. Each ad now names its own register and belongs to exactly one.
+ *
+ * Honest about the size of it: the medians barely moved (156 → 159) and the
+ * CEILING — the only number that ever flags a line — is 283 under every
+ * definition tried, because the fastest read was always a genuine voiceover
+ * row. The accuracy was never really the problem. The coupling was.
+ */
+export interface SpeechRate {
+    /** Words per minute. */
+    readonly wpm: number;
+    /** How many ads in the corpus this segment covers. */
+    readonly n: number;
+    /** Which rows `SPEECH_RATE_QUERY` was segmented to. */
+    readonly segment: string;
+}
+/**
+ * The derivation, verbatim, so gate 13a can re-run it.
+ *
+ * Word count is a WHITESPACE SPLIT of the trimmed transcript (`/\s+/`), not a
+ * space count — transcripts carry newlines, and counting only ' ' undercounts
+ * every multi-line row and drags the median down about ten wpm.
+ */
+export declare const SPEECH_RATE_QUERY: string;
+/** When the numbers below were last derived from the query above. */
+export declare const SPEECH_RATE_MEASURED_ON = "2026-09-04";
+/**
+ * 🔑 THE REGISTER SPLIT IS REAL AND MEASURED, which is why there is no single
+ * number. the performed, genre-acted reads run a median of 133 wpm;
+ * the hard-sell direct response runs 169 — thirty-six words a
+ * minute apart on the same runtime. A single point value would have been worse
+ * than none.
+ */
+export declare const SPEECH_RATE: {
+    readonly performed: {
+        readonly wpm: 133;
+        readonly n: 4;
+        readonly segment: "speech_rate = 'performed'";
+    };
+    readonly conversational: {
+        readonly wpm: 159;
+        readonly n: 41;
+        readonly segment: "speech_rate = 'conversational'";
+    };
+    readonly direct_response: {
+        readonly wpm: 169;
+        readonly n: 20;
+        readonly segment: "speech_rate = 'direct_response'";
+    };
+    /**
+     * The fastest read in the whole corpus. **The fit check flags only ABOVE
+     * this** — that is what "cannot fit at any plausible delivery" means. Not
+     * 250, not p90: those are rates real ads actually hit, and flagging an
+     * achievable read is exactly how a check gets ignored.
+     */
+    readonly ceiling: {
+        readonly wpm: 283;
+        readonly n: 65;
+        readonly segment: "max over every marked row";
+    };
+};
+export type SpeechRegister = Exclude<keyof typeof SPEECH_RATE, 'ceiling'>;
+/**
+ * The default register, and there is deliberately no picker for it.
+ *
+ * It is the corpus median and the safest of the three. A control would be a
+ * preference widget in a feature whose whole argument is that fewer required
+ * choices is better. If a project's own measured rate ever justifies one, that
+ * is a later change with its own evidence.
+ */
+export declare const DEFAULT_SPEECH_REGISTER: SpeechRegister;
+/** How many words fit in `seconds` at a register's pace. `null` when there is
+ *  no duration — a cut with no model has none, and inventing one would lie. */
+export declare function wordsForDuration(seconds: number | null | undefined, register?: SpeechRegister): number | null;
+/** Words in a spoken line. One definition, shared by the header and the flag. */
+export declare function countWords(line: string | null | undefined): number;
+/**
+ * Does this line fit this cut? `false` ONLY when it cannot fit at ANY plausible
+ * delivery — above the fastest read in every ad marked for the sample.
+ *
+ * 🚨 THE CLAIM IS DELIBERATELY WEAK SO THE CITATION CAN BE WEAK. Never flag "a
+ * bit long"; a check that nags gets ignored, and then it is worse than absent.
+ * Returns `null` when it cannot be decided (no line, or no duration).
+ */
+export declare function lineFitsCut(line: string | null | undefined, seconds: number | null | undefined): {
+    fits: boolean;
+    words: number;
+    requiredWpm: number;
+} | null;
+//# sourceMappingURL=shot-grammar.d.ts.map

package/dist/prompts/shot-grammar.js

@@ -0,0 +1,184 @@
+/**
+ * SHOT GRAMMAR — the buckets that COUNT framing, and the measured speech rate.
+ *
+ * 🚨 KEEP THIS A DEPENDENCY-FREE LEAF, exported from its own subpath
+ * (`@slatesvideo/shared/shot-grammar`). The desktop imports it from
+ * `slate/src/shared/` for the variety counter and the fit check, and the same
+ * two reasons that made `model-capabilities.ts` a leaf apply verbatim: the root
+ * barrel re-exports `auth.js` → `node:fs` (breaks renderer bundling) and
+ * `/prompts` drags the 5,000-word tips corpus in with no `require` condition.
+ *
+ * 🚨 BUCKETS EXIST TO COUNT, NEVER TO CONSTRAIN. `rules/ads/cinematic-storyboard.md`
+ * §4e, reconciled against ByteDance's own ModelArk docs: *"Camera vocabulary is
+ * open standard language and includes shot size (close-up / medium / wide) —
+ * not a closed list of eight moves."* Authoring `shotSize` and `camera` is FREE
+ * TEXT. A value matching no bucket counts as `other` and is never rejected,
+ * rewritten, or warned about. This module is the ONE home for these names —
+ * a second bucket list anywhere downstream is the drift `MODEL_CAPABILITIES`
+ * was created to end.
+ */
+// ── Shot size ──────────────────────────────────────────────────────
+export const SHOT_SIZE_BUCKETS = [
+    'wide',
+    'medium',
+    'close',
+    'extreme-close',
+    'other',
+];
+// ── Camera move ────────────────────────────────────────────────────
+export const CAMERA_MOVE_BUCKETS = [
+    'static',
+    'push',
+    'pull',
+    'handheld',
+    'orbit',
+    'crane',
+    'other',
+];
+/**
+ * The vocabulary each bucket answers to, as whole-word patterns.
+ *
+ * 🚨 NO TWO-LETTER ABBREVIATIONS — no `CU`, `ECU`, `MS`, `WS`, `LS`. They
+ * collide with ordinary words, they collide with EACH OTHER across shooting
+ * conventions (`MS` is a medium shot to one crew and a master to another), and
+ * a value bucketed WRONG is worse than one bucketed `other`: the whole claim of
+ * the variety check is that it is arithmetic anyone can verify by eye. `other`
+ * says "I did not recognise this"; a wrong bucket says something false.
+ * `cinematic-storyboard.md` §1's own example — `long-lens CU, other head
+ * blurred` — is deliberately `other`, and that is the correct answer.
+ *
+ * `satisfies Record<Exclude<Bucket, 'other'>, string[]>` on both records is
+ * what makes a SEVENTH bucket a compile error here rather than a name nothing
+ * ever matches. `other` is excluded because it is the fallback, by definition
+ * the bucket with no vocabulary.
+ */
+const SHOT_SIZE_VOCABULARY = {
+    // Longest/most specific first — `extreme close` must win over `close`.
+    'extreme-close': ['extreme close', 'extreme-close', 'macro', 'insert'],
+    close: ['close up', 'close-up', 'closeup', 'close on', 'close', 'tight'],
+    medium: ['medium', 'mid shot', 'mid-shot', 'waist', 'cowboy', 'two shot', 'two-shot'],
+    wide: ['wide', 'establishing', 'long shot', 'long-shot', 'full shot', 'full-shot', 'master'],
+};
+const CAMERA_MOVE_VOCABULARY = {
+    // `pull` before `push` so "dolly out" is never eaten by a looser "dolly".
+    // The bare bucket name is in every list: `push` alone matched while `pull`
+    // alone did not, which is the kind of asymmetry nobody notices until a count
+    // is quietly wrong.
+    pull: ['pull back', 'pull-back', 'pull out', 'pull away', 'dolly out', 'track out', 'zoom out', 'pull'],
+    push: ['push in', 'push-in', 'push', 'dolly in', 'track in', 'punch in', 'creep in', 'zoom in'],
+    // No trailing space on `arc` — matching is word-boundary based, so a space in
+    // the needle is both redundant and a trap for the next editor.
+    orbit: ['orbit', 'arc', 'circle', 'revolve', 'around the'],
+    crane: ['crane', 'jib', 'boom', 'drone', 'aerial', 'overhead descend'],
+    handheld: ['handheld', 'hand-held', 'shaky', 'shoulder', 'verite', 'vérité'],
+    static: ['static', 'locked off', 'locked-off', 'lock off', 'tripod', 'still', 'no movement'],
+};
+/** Case- and punctuation-insensitive containment, on word boundaries so
+ *  `wide` does not match `widescreen` and `close` does not match `closer`. */
+function matches(haystack, needle) {
+    const escaped = needle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`(^|[^a-z0-9])${escaped}([^a-z0-9]|$)`, 'i').test(haystack);
+}
+function bucketBy(raw, vocabulary, fallback) {
+    if (!raw || !raw.trim())
+        return fallback;
+    const text = ` ${raw.toLowerCase().trim()} `;
+    for (const [bucket, words] of Object.entries(vocabulary)) {
+        for (const word of words)
+            if (matches(text, word))
+                return bucket;
+    }
+    return fallback;
+}
+/** Which shot-size bucket a free-text value counts in. Never rejects. */
+export function bucketShotSize(raw) {
+    return bucketBy(raw, SHOT_SIZE_VOCABULARY, 'other');
+}
+/** Which camera-move bucket a free-text value counts in. Never rejects. */
+export function bucketCameraMove(raw) {
+    return bucketBy(raw, CAMERA_MOVE_VOCABULARY, 'other');
+}
+/** Human label for a bucket, for a header strip or an op result. Derived from
+ *  the bucket name so a seventh bucket cannot ship without a label. */
+export function bucketLabel(bucket) {
+    return bucket.replace(/-/g, ' ');
+}
+/**
+ * The derivation, verbatim, so gate 13a can re-run it.
+ *
+ * Word count is a WHITESPACE SPLIT of the trimmed transcript (`/\s+/`), not a
+ * space count — transcripts carry newlines, and counting only ' ' undercounts
+ * every multi-line row and drags the median down about ten wpm.
+ */
+export const SPEECH_RATE_QUERY = `
+-- words-per-minute per ad, from second-brain/business/projects/slates/
+--   content-strategy/examples/ad-research.db
+-- words = transcript.trim().split(/\s+/).length   (applied to each row)
+-- wpm   = words / (duration_seconds / 60)
+SELECT id, speech_rate, duration_seconds, transcript
+  FROM ads
+ WHERE speech_rate IS NOT NULL
+   AND transcript IS NOT NULL AND TRIM(transcript) <> ''
+   AND duration_seconds IS NOT NULL AND duration_seconds > 0;
+-- segments: speech_rate, which is one register per ad and never overlaps
+-- statistic: median per register; ceiling = max over every marked row
+`.trim();
+/** When the numbers below were last derived from the query above. */
+export const SPEECH_RATE_MEASURED_ON = '2026-09-04';
+/**
+ * 🔑 THE REGISTER SPLIT IS REAL AND MEASURED, which is why there is no single
+ * number. the performed, genre-acted reads run a median of 133 wpm;
+ * the hard-sell direct response runs 169 — thirty-six words a
+ * minute apart on the same runtime. A single point value would have been worse
+ * than none.
+ */
+export const SPEECH_RATE = {
+    performed: { wpm: 133, n: 4, segment: "speech_rate = 'performed'" },
+    conversational: { wpm: 159, n: 41, segment: "speech_rate = 'conversational'" },
+    direct_response: { wpm: 169, n: 20, segment: "speech_rate = 'direct_response'" },
+    /**
+     * The fastest read in the whole corpus. **The fit check flags only ABOVE
+     * this** — that is what "cannot fit at any plausible delivery" means. Not
+     * 250, not p90: those are rates real ads actually hit, and flagging an
+     * achievable read is exactly how a check gets ignored.
+     */
+    ceiling: { wpm: 283, n: 65, segment: 'max over every marked row' },
+};
+/**
+ * The default register, and there is deliberately no picker for it.
+ *
+ * It is the corpus median and the safest of the three. A control would be a
+ * preference widget in a feature whose whole argument is that fewer required
+ * choices is better. If a project's own measured rate ever justifies one, that
+ * is a later change with its own evidence.
+ */
+export const DEFAULT_SPEECH_REGISTER = 'conversational';
+/** How many words fit in `seconds` at a register's pace. `null` when there is
+ *  no duration — a cut with no model has none, and inventing one would lie. */
+export function wordsForDuration(seconds, register = DEFAULT_SPEECH_REGISTER) {
+    if (seconds == null || !(seconds > 0))
+        return null;
+    return Math.round((SPEECH_RATE[register].wpm * seconds) / 60);
+}
+/** Words in a spoken line. One definition, shared by the header and the flag. */
+export function countWords(line) {
+    if (!line)
+        return 0;
+    return line.trim().split(/\s+/).filter(Boolean).length;
+}
+/**
+ * Does this line fit this cut? `false` ONLY when it cannot fit at ANY plausible
+ * delivery — above the fastest read in every ad marked for the sample.
+ *
+ * 🚨 THE CLAIM IS DELIBERATELY WEAK SO THE CITATION CAN BE WEAK. Never flag "a
+ * bit long"; a check that nags gets ignored, and then it is worse than absent.
+ * Returns `null` when it cannot be decided (no line, or no duration).
+ */
+export function lineFitsCut(line, seconds) {
+    const words = countWords(line);
+    if (words === 0 || seconds == null || !(seconds > 0))
+        return null;
+    const requiredWpm = Math.round(words / (seconds / 60));
+    return { fits: requiredWpm <= SPEECH_RATE.ceiling.wpm, words, requiredWpm };
+}
+//# sourceMappingURL=shot-grammar.js.map