@jokerized/decksmith 0.3.0 → 0.3.1

package/dist/types/mcp/tools.d.ts

@@ -26,6 +26,10 @@ export declare const settingsSchema: z.ZodObject<{
         normal: "normal";
         dense: "dense";
     }>>;
+    genre: z.ZodOptional<z.ZodEnum<{
+        general: "general";
+        paper: "paper";
+    }>>;
     duration: z.ZodOptional<z.ZodNumber>;
     slides: z.ZodOptional<z.ZodInt>;
     animation_speed: z.ZodOptional<z.ZodNumber>;
@@ -63,6 +67,10 @@ export declare const estimateSchema: z.ZodObject<{
             normal: "normal";
             dense: "dense";
         }>>;
+        genre: z.ZodOptional<z.ZodEnum<{
+            general: "general";
+            paper: "paper";
+        }>>;
         duration: z.ZodOptional<z.ZodNumber>;
         slides: z.ZodOptional<z.ZodInt>;
         animation_speed: z.ZodOptional<z.ZodNumber>;
@@ -101,6 +109,10 @@ export declare const createSchema: z.ZodObject<{
             normal: "normal";
             dense: "dense";
         }>>;
+        genre: z.ZodOptional<z.ZodEnum<{
+            general: "general";
+            paper: "paper";
+        }>>;
         duration: z.ZodOptional<z.ZodNumber>;
         slides: z.ZodOptional<z.ZodInt>;
         animation_speed: z.ZodOptional<z.ZodNumber>;

package/dist/types/plan/arc.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The paper arc: what a research-talk deck must open and close with.
+ *
+ * A research talk has a shape a general explainer does not. It opens on the
+ * problem and on the ground the work stands on, and it closes on what the work
+ * does NOT do and then on what to take away. DeckSmith's planner writes the
+ * opening well already — 13 of 15 committed full-deck runs open with a `title` —
+ * and the ending badly: 10 of 15 close with a `callout`, but ZERO of 15 carry
+ * two, because the limitation arrives as a subordinate clause inside the
+ * conclusion ("The idea works, but the strongest lightweight models remain
+ * ahead") rather than as its own slide. Splitting that clause into a slide is
+ * the actual behaviour change this module asks for.
+ *
+ * WHY THIS FILE EXISTS AT ALL, rather than the rule living where it is enforced:
+ * three directories read this definition and none of them can own it — the
+ * prompt (src/plan/prompt.ts) asks the model for the arc, the scan
+ * (src/verify/index.ts) reports where a plan missed it, and the cut
+ * (src/plan/select.ts) refuses to delete a beat that carries a role. Restating
+ * the rule three times is how the three fall out of step; deriving it from one
+ * table is how they cannot.
+ *
+ * WHAT THIS MODULE DELIBERATELY DOES NOT DO. It never decides that a document is
+ * a research paper. `prefs.genre` is declared by the author and nothing here
+ * sniffs it — see the field's own note in src/types.ts for the measurement that
+ * settled that. And it never requires a beat the source cannot support: RULE 3
+ * forbids inventing a baseline or a result, so a source that says nothing about
+ * prior work honestly yields no `background` beat, and this file's job is then
+ * to report the gap rather than to have manufactured one.
+ */
+import type { Prefs } from "../prefs.js";
+import type { Beat, BeatRole, Storyboard } from "../types.js";
+/** Every structural job, in the order a deck performs them. */
+export declare const ARC_ROLES: readonly BeatRole[];
+/**
+ * Roles required at a given deck length, and why the list shortens.
+ *
+ * Four reserved slides out of five is not a deck, it is a table of contents. At
+ * `--duration 60` a deck is about five beats, so asking for the full arc there
+ * is asking for something nobody could deliver, and a gate that fires on the
+ * impossible is one people learn to ignore. The thresholds:
+ *
+ *   n >= 8   the full arc. 8 is this project's own definition of a full-deck
+ *            run — the corpus count of "15 committed full-deck plans" is beats
+ *            >= 8 — not a number chosen here.
+ *   5..7     the ending only. An `intro` is what the planner already writes
+ *            unprompted 13 times in 15, and `background` is the beat most likely
+ *            to have no source material behind it, so those two are the ones to
+ *            give up first when the budget is short.
+ *   n < 5    nothing. There is no room for a shape.
+ *
+ * Read off the beat count the plan actually came back with, not off
+ * `prefs.slides`: the floor the author asked for and the deck the planner
+ * returned are different numbers, and `scanBeatCount` already owns the gap
+ * between them.
+ */
+export declare function requiredRoles(beatCount: number): readonly BeatRole[];
+/** Whether the paper arc was asked for at all. Declared, never sniffed. */
+export declare function paperArcRequested(prefs: Pick<Prefs, "genre">): boolean;
+/** The beats carrying a structural role, by role. Later duplicates are reported, not kept. */
+export declare function arcBeats(storyboard: Storyboard): Map<BeatRole, Beat[]>;
+/**
+ * Ids of every beat carrying a role — what the cut refuses to release.
+ *
+ * Takes a beat list rather than a Storyboard because the cut works over the
+ * surviving beats, not over the plan.
+ */
+export declare function arcIds(beats: readonly Beat[]): Set<string>;
+/**
+ * Where a plan departs from the arc it was asked for, as sentences.
+ *
+ * ORDER IS CHECKED, NOT JUST PRESENCE, and only where order is the point. The
+ * user's requirement is specifically that the deck END on the conclusion with
+ * limitations immediately before it — an ending is a position, not a topic — so
+ * those two are checked against the last two slots. The opening pair is checked
+ * for presence and for being early, because "the first couple of slides" is a
+ * region rather than an index, and a deck that opens title, problem, background
+ * is not wrong.
+ *
+ * Returns an empty array when the arc was not requested, when the deck is too
+ * short to carry it, or when the plan satisfied it.
+ */
+export declare function arcProblems(storyboard: Storyboard, prefs: Pick<Prefs, "genre" | "slides">): string[];

package/dist/types/plan/codex.d.ts

@@ -1,5 +1,11 @@
 import type { Prefs } from "../prefs.js";
 import { type Source, type Storyboard } from "../types.js";
+/** The schema for one run. `role` is present only when the paper arc was asked for. */
+export declare function schemaFor(prefs: Pick<Prefs, "genre">): unknown;
+/**
+ * The default-preferences schema, unchanged and still exported: `general` hides
+ * `role`, so these bytes are what they have always been.
+ */
 export declare const SCHEMA: unknown;
 export interface CodexOptions {
     /** Left unset by default: use whatever model the user's Codex is configured for. */

package/dist/types/prefs.d.ts

@@ -39,6 +39,7 @@ export interface PrefFlags {
     lang?: string;
     tone?: string;
     density?: string;
+    genre?: string;
     duration?: string | number;
     theme?: string;
     speed?: string | number;

package/dist/types/render/ffmpeg.d.ts

@@ -60,20 +60,6 @@ export interface AudioInput {
     file: string;
     delayMs: number;
 }
-/**
- * Delay every segment onto one track and sum them.
- *
- * `amix` with `normalize=0` sums rather than averaging: the default divides by
- * the input count, which on a 37-segment deck would render the narration 31 dB
- * down and sound exactly like a bug in the TTS. The segments never overlap — the
- * timing model gives each one the video's undivided attention — so summing is
- * safe. `dropout_transition=0` stops amix ramping the gain as inputs end.
- *
- * Every input is resampled and laid out identically first, because amix refuses
- * a mismatch and edge-tts emits 24 kHz mono while the video wants 48 kHz.
- * `apad` runs the track out to the video's length so the mux does not have to
- * choose between a short audio stream and `-shortest` truncating the picture.
- */
 export declare function audioGraph(inputs: readonly AudioInput[], seconds: number, 
 /**
  * ffmpeg input index of the first mp3. 1 when the video is the only other