@bendyline/squisq 2.13.14 → 2.13.16

package/dist/{materializePageSection-CWxou4mX.d.ts → materializePageSection-HIoRYiZu.d.ts}

@@ -1,4 +1,4 @@
-import { k as Block, aY as PageSectionKind, aW as PageEmphasis, bJ as ThemeColorScheme, aU as PageBackground, bH as Theme, cc as ViewportConfig, D as CustomTemplateDefinition, a$ as PageVariant, br as StartBlockConfig, T as Doc, bK as ThemePageStyle } from './Doc-BhvotZx_.js';
+import { k as Block, b0 as PageSectionKind, a_ as PageEmphasis, bP as ThemeColorScheme, aY as PageBackground, bN as Theme, cj as ViewportConfig, D as CustomTemplateDefinition, b3 as PageVariant, bw as StartBlockConfig, U as Doc, bQ as ThemePageStyle } from './Doc-DLfTam0R.js';
 import { M as MarkdownBlockNode } from './types-Zk8qYuaT.js';
 
 /** A prominent number found inside a short stat-like string. */
@@ -15,7 +15,7 @@ interface NumberHighlightMatch {
 
 declare const PRESENTATION_KEY = "squisq-presentation";
 /** The layouts a summary (a headline and up to four points) can fill. */
-declare const PRESENTATION_LAYOUTS: readonly ["title", "divider", "statement", "emphasis", "quote", "stat", "definition", "list", "comparison", "steps", "image", "cards", "process", "cycle", "layers"];
+declare const PRESENTATION_LAYOUTS: readonly ["title", "divider", "statement", "emphasis", "quote", "stat", "definition", "list", "comparison", "steps", "image", "cards", "process", "cycle", "layers", "stats", "pyramid", "funnel", "hub", "venn", "matrix"];
 type PresentationLayout = (typeof PRESENTATION_LAYOUTS)[number];
 /** Shows a section's own block, with the template its author chose, instead of
  * a summary. A section shown this way is one slide for its whole narration. */
@@ -27,12 +27,26 @@ declare function presentationStat(headline: string, points: readonly string[]):
     line: string;
     index: number;
 } | null;
-/** Whether a summary can fill a layout: enough points for a list, steps,
- * cards, a process, a cycle (three) or a comparison; a prominent number for a key number; a short headline for a big
- * statement; and, for a quote, a headline found word for word in
- * `passage`, the source text the slide summarizes. An image slide also needs a
- * picture, which callers check. */
+/** Whether a summary can fill a layout: the items a drawn layout takes
+ * (`conceptItemsProblem`: three stages for a cycle, a figure in every key
+ * number, four ideas for a matrix…); enough points for a list, steps or a
+ * comparison; a prominent number for a key number; a short headline for a big
+ * statement; and, for a quote, a headline found word for word in `passage`,
+ * the source text the slide summarizes. An image slide also needs a picture,
+ * which callers check. */
 declare function presentationLayoutFits(layout: PresentationLayout, headline: string, points: readonly string[], passage: string): boolean;
+/** Why a summary cannot fill a layout, as a sentence its author can act on
+ * (a person reading a designer's help, a model reading a correction), or
+ * `undefined` when it can. */
+declare function presentationLayoutProblem(layout: PresentationLayout, headline: string, points: readonly string[], passage: string): string | undefined;
+/** What a slide must have for a layout to apply, as a designer's help says it
+ * ("at least 2 points", "exactly 4 points"), or `undefined` when any slide
+ * will do. It states what `presentationLayoutProblem` checks, so a picker's
+ * help and the plan agree. `points` names a slide's points in the host's own
+ * word ("highlights"). */
+declare function presentationLayoutNeeds(layout: PresentationLayout, wording?: {
+    points?: string;
+}): string | undefined;
 interface PresentationBeat {
     id: string;
     sourceStart: number;
@@ -45,7 +59,19 @@ interface PresentationBeat {
     media?: string[];
     /** Left out of the deck; the slide shown before it stays on screen instead. */
     hidden?: true;
+    /** A hub only: the one to three words its ideas share, written inside it. */
+    center?: string;
+    /** A matrix only: what grows from left to right, named along the foot. */
+    xAxis?: string;
+    /** A matrix only: what grows from bottom to top, named up the side. */
+    yAxis?: string;
 }
+/** What a layout draws beyond its headline and points. */
+type PresentationBeatExtras = Pick<PresentationBeat, 'center' | 'xAxis' | 'yAxis'>;
+/** The extras of `source` that `layout` draws, trimmed; ones it does not draw,
+ * empty ones and ones too long to set are left out. Read loosely, so a model's
+ * reply and a saved beat pass through the same door. */
+declare function presentationBeatExtras(layout: string, source: unknown): PresentationBeatExtras;
 interface PresentationPlan {
     version: 1;
     sourceText: string;
@@ -57,10 +83,97 @@ declare const PRESENTATION_LIMITS: {
     readonly beats: 80;
     readonly serializedCharacters: 160000;
     readonly mediaPerBeat: 4;
+    /** The most points a summary slide holds. */
+    readonly points: 4;
+    /** The longest a hub's centre or a matrix's axis name may be. */
+    readonly extraCharacters: 40;
 };
 declare function parsePresentationPlan(input: unknown): PresentationPlan | null;
 declare function serializePresentationPlan(plan: PresentationPlan): string;
 
+/**
+ * Concept specs — what each concept template takes, as data.
+ *
+ * The ten concept templates draw a handful of ideas, and every product that
+ * lets an author choose one has to say the same things about it: how many
+ * items it takes, how an item is written, what order they come in, and what
+ * the template draws when it is given something else. Those facts used to be
+ * restated wherever they were needed (a prompt's "3–5", a validator's table,
+ * a picker's help text, each template's own fallback) and the copies drifted.
+ * This module is the one statement of them:
+ *
+ * - {@link CONCEPT_SPECS}: per template, the items an author should write and
+ *   the inputs it takes beyond them. The authoring guide renders its counts
+ *   from here ({@link conceptItemCount}), so a prompt and a check agree.
+ * - {@link conceptItemsProblem}: whether a set of items meets that contract,
+ *   as a sentence an author or a repair prompt can act on.
+ * - {@link conceptDowngrade}: what a template draws instead when it cannot
+ *   draw its own picture. The templates call it, so it cannot disagree with
+ *   them, and `markdownToDoc` reports it (`template-shape-unmet`).
+ *
+ * Pure text in, plain data out.
+ *
+ * Related: `conceptItems.ts` (how one item is read), `conceptBlocks.ts` and
+ * `conceptShapes.ts` (the drawings), `authoringGuide.ts` (what authors are told).
+ */
+
+/** Every template that draws a handful of ideas. */
+declare const CONCEPT_TEMPLATES: readonly ["cards", "process", "cycle", "layers", "stats", "pyramid", "funnel", "hub", "venn", "matrix"];
+type ConceptTemplateName = (typeof CONCEPT_TEMPLATES)[number];
+/** The most ideas a concept template draws; more are shown as the list they are. */
+declare const CONCEPT_MAX_DRAWN = 6;
+/** An input a concept template takes beyond `title` and `items`. */
+interface ConceptSpecInput {
+    key: string;
+    /** What an author writes there, as a guide lists it. */
+    guide: string;
+}
+interface ConceptSpec {
+    /** The fewest and the most items an author should write. */
+    items: readonly [min: number, max: number];
+    /** How an item is written: a label and its detail, or a figure and what it measures. */
+    itemForm: 'label-detail' | 'figure-caption';
+    /** The order the items are written in, when the drawing depends on it. */
+    order?: string;
+    /** Inputs beyond `title` and `items`. */
+    inputs?: readonly ConceptSpecInput[];
+}
+declare const CONCEPT_SPECS: Readonly<Record<ConceptTemplateName, ConceptSpec>>;
+/** The concept template a name denotes, or `undefined`. */
+declare function conceptTemplate(template: string): ConceptTemplateName | undefined;
+interface ConceptItemsOptions {
+    /**
+     * The most items the author's surface holds, when that is fewer than the
+     * template takes (a summary slide holds four points).
+     */
+    max?: number;
+}
+/** How many items a template takes, as a guide says it: "2–4", or "exactly 4". */
+declare function conceptItemCount(template: ConceptTemplateName, options?: ConceptItemsOptions): string;
+/**
+ * Why `items` do not meet a template's contract, or `undefined` when they do:
+ * too few or too many, a key number without a figure, a Venn diagram without
+ * the item that names what its sets share. The sentence is written for the
+ * author, so a validator can log it and a repair prompt can quote it.
+ */
+declare function conceptItemsProblem(template: ConceptTemplateName, items: readonly unknown[] | undefined, options?: ConceptItemsOptions): string | undefined;
+/** What a concept template draws when it cannot draw its own picture, and why. */
+interface ConceptDowngrade {
+    drawsAs: ConceptTemplateName | 'list';
+    /** Completes "…, so it is drawn as <drawsAs>": "a matrix places exactly four items and this has three". */
+    reason: string;
+}
+/**
+ * What a template draws instead of its own picture for these items, or
+ * `undefined` when it draws itself. A template never draws a broken diagram:
+ * a matrix without four ideas, a Venn diagram without two sets and key
+ * numbers without a figure draw as cards; a cycle too short or too wordy for
+ * a ring draws as a process; more than six ideas are shown as a list.
+ */
+declare function conceptDowngrade(template: ConceptTemplateName, items: readonly unknown[] | undefined): ConceptDowngrade | undefined;
+/** The template that draws these items: `template` itself unless it is downgraded. */
+declare function conceptDrawsAs(template: ConceptTemplateName, items: readonly unknown[] | undefined): ConceptTemplateName | 'list';
+
 /**
  * PageSection — the framework-agnostic block model for Page (linear) mode.
  *
@@ -300,4 +413,4 @@ declare function materializePageSection(block: Block, options?: MaterializePageS
  */
 declare function materializePageSections(doc: Doc, options?: MaterializePageSectionsOptions): PageSectionMaterialization[];
 
-export { AUTHORED_PRESENTATION_LAYOUT as A, type MaterializePageSectionOptions as M, PRESENTATION_KEY as P, type MaterializePageSectionsOptions as a, PRESENTATION_LAYOUTS as b, PRESENTATION_LIMITS as c, type PageMedia as d, type PageRichText as e, type PageSection as f, type PageSectionDiagnostic as g, type PageSectionItem as h, type PageSectionMaterialization as i, type PageSectionSource as j, type PageSpatialKind as k, type PageTransformHints as l, type PresentationBeat as m, type PresentationBeatLayout as n, type PresentationLayout as o, type PresentationPlan as p, materializePageSection as q, materializePageSections as r, parsePresentationPlan as s, presentationLayoutFits as t, presentationStat as u, resolvePageStyle as v, serializePresentationPlan as w };
+export { AUTHORED_PRESENTATION_LAYOUT as A, conceptItemCount as B, CONCEPT_MAX_DRAWN as C, conceptItemsProblem as D, conceptTemplate as E, materializePageSection as F, materializePageSections as G, parsePresentationPlan as H, presentationBeatExtras as I, presentationLayoutFits as J, presentationLayoutNeeds as K, presentationLayoutProblem as L, type MaterializePageSectionOptions as M, presentationStat as N, resolvePageStyle as O, PRESENTATION_KEY as P, serializePresentationPlan as Q, CONCEPT_SPECS as a, CONCEPT_TEMPLATES as b, type ConceptDowngrade as c, type ConceptItemsOptions as d, type ConceptSpec as e, type ConceptSpecInput as f, type ConceptTemplateName as g, type MaterializePageSectionsOptions as h, PRESENTATION_LAYOUTS as i, PRESENTATION_LIMITS as j, type PageMedia as k, type PageRichText as l, type PageSection as m, type PageSectionDiagnostic as n, type PageSectionItem as o, type PageSectionMaterialization as p, type PageSectionSource as q, type PageSpatialKind as r, type PageTransformHints as s, type PresentationBeat as t, type PresentationBeatExtras as u, type PresentationBeatLayout as v, type PresentationLayout as w, type PresentationPlan as x, conceptDowngrade as y, conceptDrawsAs as z };

package/dist/mediaEdit/index.d.ts

@@ -1,5 +1,5 @@
-import { ap as MediaCut, T as Doc, an as MediaClip, cI as MediaFxOpId, cJ as MediaFxChain } from '../Doc-BhvotZx_.js';
-export { cK as MEDIA_EDIT_PARAMS, cL as MEDIA_FX_ORDER, cM as MEDIA_FX_SPECS, ao as MediaCrop, cN as MediaEditParamKey, cO as MediaEditParamValues, aq as MediaEdits, cP as MediaFxOp, cQ as formatMediaNumber, cR as hasRenderableFx, cS as mediaEditHtmlAttribute, cT as mediaEditValuesFromAttributes, cU as mediaEditValuesFromParams, cV as mediaRenderKey, cW as normalizeMediaCrop, cX as normalizeMediaCuts, cY as parseMediaCrop, cZ as parseMediaCuts, c_ as parseMediaEdits, c$ as parseMediaFx, d0 as serializeMediaCrop, d1 as serializeMediaCuts, d2 as serializeMediaEdits, d3 as serializeMediaFx } from '../Doc-BhvotZx_.js';
+import { at as MediaCut, U as Doc, ar as MediaClip, cQ as MediaFxOpId, cR as MediaFxChain } from '../Doc-DLfTam0R.js';
+export { cS as MEDIA_EDIT_PARAMS, cT as MEDIA_FX_ORDER, cU as MEDIA_FX_SPECS, as as MediaCrop, cV as MediaEditParamKey, cW as MediaEditParamValues, au as MediaEdits, cX as MediaFxOp, cY as canonicalMediaFx, cZ as formatMediaNumber, c_ as hasRenderableFx, c$ as mediaEditHtmlAttribute, d0 as mediaEditValuesFromAttributes, d1 as mediaEditValuesFromParams, d2 as mediaRecipeHash, d3 as mediaRenderKey, d4 as normalizeMediaCrop, d5 as normalizeMediaCuts, d6 as parseMediaCrop, d7 as parseMediaCuts, d8 as parseMediaEdits, d9 as parseMediaFx, da as serializeMediaCrop, db as serializeMediaCuts, dc as serializeMediaEdits, dd as serializeMediaFx } from '../Doc-DLfTam0R.js';
 import '../types-Zk8qYuaT.js';
 
 /**
@@ -175,6 +175,157 @@ declare function mediaRenderKeyFor(src: string, fx: string | undefined): string
  */
 declare function selectMediaRendersForGc(index: ReadonlyMap<string, MediaRenderEntry>, referencedKeys: ReadonlySet<string>, manifests: ReadonlyMap<string, MediaRenderManifest>, now?: Date, olderThanDays?: number): string[];
 
+/**
+ * Baked clips — a clip with its whole recipe applied, as one ordinary media
+ * file.
+ *
+ * The player, video export and the CLI apply a recipe as they play: they skip
+ * cuts, set the gain, swap in the processed audio. A script-free HTML page or
+ * another app cannot. For those the recipe is BAKED: trim, cuts, cleaned-up
+ * sound, gain, fades and crop are rendered into a single file that any player
+ * plays as is.
+ *
+ * A baked file is a cache, like an `fx` render. The recipe in the markdown
+ * stays the source of truth, the source file is never touched, and a bake is
+ * made only on demand (an export that needs it, "Save edited copy") — never
+ * merely because a recipe changed. It lives in the same `.mediaEdits/` folder:
+ *
+ *   .mediaEdits/<stem>.<key>.baked.<ext>    the baked clip
+ *   .mediaEdits/<stem>.<key>.baked.json     its manifest
+ *
+ * `<key>` is {@link mediaBakeKey}: 12 hex digits over the source path and
+ * everything in the recipe that changes the result. The extra `.baked`
+ * segment keeps these apart from `fx` renders, so neither index sees the
+ * other's files.
+ *
+ * Pure and dependency-free.
+ */
+
+/** Engine identifier. It is part of the key: a new engine version re-bakes. */
+declare const MEDIA_BAKE_ENGINE = "squisq-media-bake/1";
+/** Manifest schema version. */
+declare const MEDIA_BAKE_MANIFEST_VERSION = 1;
+/**
+ * Fade applied on each side of a cut so the join does not click. The player
+ * and the export mix use the same length.
+ */
+declare const MEDIA_CUT_EDGE_FADE_SEC = 0.01;
+/** The parts of a clip that decide its baked file. */
+type MediaBakeClip = Pick<MediaClip, 'src' | 'kind' | 'clipStart' | 'clipEnd' | 'edits'>;
+/** The clip's cuts that fall inside its trim window — the only ones that matter. */
+declare function mediaBakeCuts(clip: MediaBakeClip): MediaCut[];
+/**
+ * True when a player that cannot apply a recipe would play this clip wrongly:
+ * it has cuts, cleaned-up audio, a gain, fades, or (video) a crop. A trim
+ * alone does not count — a plain player honors it as a media fragment.
+ */
+declare function needsMediaBake(clip: MediaBakeClip): boolean;
+/** True when baking would produce anything other than a copy of the source. */
+declare function canBakeMedia(clip: MediaBakeClip): boolean;
+/**
+ * Canonical text of everything that decides a clip's baked file. Recipe
+ * fields that do not change the result (`group`, unknown `fx` tokens, a crop
+ * on audio, cuts outside the trim) are left out, so they never force a
+ * re-bake.
+ */
+declare function mediaBakeSpec(clip: MediaBakeClip): string;
+/** Stable key naming the baked file of a clip. 12 hex digits. */
+declare function mediaBakeKey(clip: MediaBakeClip): string;
+declare function mediaBakeFilePath(src: string, key: string, extension: string): string;
+declare function mediaBakeManifestPath(src: string, key: string): string;
+interface ParsedMediaBakePath {
+    stem: string;
+    key: string;
+    extension: string;
+    isManifest: boolean;
+}
+/**
+ * Recognize a baked clip or its manifest, with or without a leading media
+ * folder (`notes_files/.mediaEdits/take.1a2b3c4d5e6f.baked.m4a`).
+ */
+declare function parseMediaBakePath(path: string): ParsedMediaBakePath | null;
+declare function isMediaBakePath(path: string): boolean;
+/** A baked clip found in a listing. */
+type MediaBakeEntry = MediaRenderEntry;
+/** Index a media listing by bake key. A baked file without a manifest is still indexed. */
+declare function buildMediaBakeIndex(entries: ReadonlyArray<{
+    name: string;
+    size: number;
+}>): Map<string, MediaBakeEntry>;
+interface MediaBakeManifest {
+    version: typeof MEDIA_BAKE_MANIFEST_VERSION;
+    /** The source reference exactly as the document writes it. */
+    src: string;
+    key: string;
+    /** The canonical recipe text the key was made from ({@link mediaBakeSpec}). */
+    spec: string;
+    /** Baked file path, relative to the media root. */
+    file: string;
+    mimeType: string;
+    /** Source byte size at bake time (staleness check), when known. */
+    sourceSize: number | null;
+    /** Length of the baked clip in seconds. */
+    duration: number | null;
+    engine: string;
+    /** ISO-8601 creation time. */
+    createdAt: string;
+}
+/** Validate manifest JSON; null when malformed or from an unknown version. */
+declare function parseMediaBakeManifest(text: string): MediaBakeManifest | null;
+declare function serializeMediaBakeManifest(manifest: MediaBakeManifest): string;
+/**
+ * True when a baked clip no longer matches its source: the source file's size
+ * differs from bake time (a re-recorded take under the same name).
+ */
+declare function isMediaBakeStale(manifest: MediaBakeManifest, current: {
+    sourceSize?: number | null;
+}): boolean;
+/**
+ * Baked clips (and their manifests) of the given sources that no current
+ * recipe asks for. Unlike `fx` renders these are removed at once rather than
+ * aged out: a baked video is large, is made again on demand, and playback
+ * never depends on it. A file without a manifest cannot be attributed to a
+ * source, so it is left alone.
+ */
+declare function selectSupersededMediaBakes(index: ReadonlyMap<string, MediaBakeEntry>, manifests: ReadonlyMap<string, MediaBakeManifest>, sources: ReadonlySet<string>, referencedKeys: ReadonlySet<string>): string[];
+/** `take.webm` + `m4a` → `take-edited.m4a`: the file name of an edited copy. */
+declare function mediaBakeCopyName(src: string, extension: string): string;
+/** The edited copy's path beside its source (`notes_files/audio/take-edited.m4a`). */
+declare function mediaBakeCopyPath(src: string, extension: string): string;
+/** Kept source ranges as whole-frame offsets from `windowStart`, for slicing decoded audio. */
+declare function mediaBakeFrameRanges(kept: readonly MediaCut[], windowStart: number, sampleRate: number): Array<[number, number]>;
+interface MediaBakeAudioStageOptions {
+    /**
+     * The frames to keep, as offsets from the first frame fed: ascending and
+     * non-overlapping (see {@link mediaBakeFrameRanges}).
+     */
+    ranges: ReadonlyArray<readonly [number, number]>;
+    sampleRate: number;
+    /** Clip gain in dB. */
+    gainDb?: number;
+    /** Fade-in seconds at the start of the baked clip. */
+    fadeInSec?: number;
+    /** Fade-out seconds at the end of the baked clip. */
+    fadeOutSec?: number;
+}
+interface MediaBakeAudioStage {
+    /** Frames the baked clip will hold. */
+    readonly totalFrames: number;
+    /**
+     * Feed the next decoded block (planar, consecutive from the window start).
+     * Returns the part of it the baked clip keeps, with gain, fades and the
+     * cut-edge fades applied — or null when the whole block is cut.
+     */
+    process(block: readonly Float32Array[]): Float32Array[] | null;
+}
+/**
+ * What a recipe's timeline ops do to sound: drop the cut ranges, close the
+ * gaps, apply the gain and the two fades, and fade each join a few
+ * milliseconds either side so it does not click — the same result the player
+ * and the export mix produce live.
+ */
+declare function createMediaBakeAudioStage(options: MediaBakeAudioStageOptions): MediaBakeAudioStage;
+
 /**
  * Breath detection for spoken-word recordings.
  *
@@ -464,4 +615,4 @@ declare const PAUSE_TIGHTEN_DEFAULTS: Readonly<{
 /** Cuts that shorten every long pause in the take. */
 declare function detectPauseCuts(frames: readonly BreathFrame[], options?: PauseTightenOptions): MediaCut[];
 
-export { type BreathAnalyzer, type BreathDetectOptions, type BreathFrame, type BreathRegion, type DenoiseStage, type Denoiser, type DenoiserFactory, type Limiter, type LimiterOptions, type LoudnessMeter, MEDIA_FX_ENGINE, MEDIA_FX_LOUDNESS_TOLERANCE, MEDIA_FX_SAMPLE_RATE, MEDIA_FX_TRUE_PEAK_CEILING_DB, MEDIA_RENDER_DIR, MEDIA_RENDER_GC_AGE_DAYS, MEDIA_RENDER_MANIFEST_VERSION, MediaCut, type MediaFxAnalysis, MediaFxChain, MediaFxOpId, type MediaFxOptions, type MediaFxRenderOptions, type MediaFxRenderResult, type MediaFxSource, type MediaRenderAnalysis, type MediaRenderEntry, type MediaRenderManifest, type MediaTimeMap, type MediaTimeMapInput, PAUSE_TIGHTEN_DEFAULTS, type ParsedMediaRenderPath, type PauseTightenOptions, type Resampler, analyzeMediaFx, applyBreathEnvelope, breathGainAt, buildMediaRenderIndex, collectDocMediaClips, correctedLoudnessAnalysis, createBreathAnalyzer, createDenoiseStage, createLimiter, createLoudnessMeter, createMediaTimeMap, createResampler, detectBreaths, detectPauseCuts, integratedLoudnessFromSteps, isMediaRenderPath, mediaClipRenderKey, mediaRenderFilePath, mediaRenderKeyFor, mediaRenderManifestPath, mediaRenderStaleness, mediaRenderStem, parseMediaRenderManifest, parseMediaRenderPath, referencedMediaRenderKeys, renderMediaFx, selectMediaRendersForGc, serializeMediaRenderManifest };
+export { type BreathAnalyzer, type BreathDetectOptions, type BreathFrame, type BreathRegion, type DenoiseStage, type Denoiser, type DenoiserFactory, type Limiter, type LimiterOptions, type LoudnessMeter, MEDIA_BAKE_ENGINE, MEDIA_BAKE_MANIFEST_VERSION, MEDIA_CUT_EDGE_FADE_SEC, MEDIA_FX_ENGINE, MEDIA_FX_LOUDNESS_TOLERANCE, MEDIA_FX_SAMPLE_RATE, MEDIA_FX_TRUE_PEAK_CEILING_DB, MEDIA_RENDER_DIR, MEDIA_RENDER_GC_AGE_DAYS, MEDIA_RENDER_MANIFEST_VERSION, type MediaBakeAudioStage, type MediaBakeAudioStageOptions, type MediaBakeClip, type MediaBakeEntry, type MediaBakeManifest, MediaCut, type MediaFxAnalysis, MediaFxChain, MediaFxOpId, type MediaFxOptions, type MediaFxRenderOptions, type MediaFxRenderResult, type MediaFxSource, type MediaRenderAnalysis, type MediaRenderEntry, type MediaRenderManifest, type MediaTimeMap, type MediaTimeMapInput, PAUSE_TIGHTEN_DEFAULTS, type ParsedMediaBakePath, type ParsedMediaRenderPath, type PauseTightenOptions, type Resampler, analyzeMediaFx, applyBreathEnvelope, breathGainAt, buildMediaBakeIndex, buildMediaRenderIndex, canBakeMedia, collectDocMediaClips, correctedLoudnessAnalysis, createBreathAnalyzer, createDenoiseStage, createLimiter, createLoudnessMeter, createMediaBakeAudioStage, createMediaTimeMap, createResampler, detectBreaths, detectPauseCuts, integratedLoudnessFromSteps, isMediaBakePath, isMediaBakeStale, isMediaRenderPath, mediaBakeCopyName, mediaBakeCopyPath, mediaBakeCuts, mediaBakeFilePath, mediaBakeFrameRanges, mediaBakeKey, mediaBakeManifestPath, mediaBakeSpec, mediaClipRenderKey, mediaRenderFilePath, mediaRenderKeyFor, mediaRenderManifestPath, mediaRenderStaleness, mediaRenderStem, needsMediaBake, parseMediaBakeManifest, parseMediaBakePath, parseMediaRenderManifest, parseMediaRenderPath, referencedMediaRenderKeys, renderMediaFx, selectMediaRendersForGc, selectSupersededMediaBakes, serializeMediaBakeManifest, serializeMediaRenderManifest };

package/dist/mediaEdit/index.js

@@ -5,16 +5,18 @@ import {
 } from "../chunk-NEWNNLWN.js";
 import {
   createMediaTimeMap
-} from "../chunk-JSGIWW35.js";
+} from "../chunk-MTIR5PWF.js";
 import {
   MEDIA_EDIT_PARAMS,
   MEDIA_FX_ORDER,
   MEDIA_FX_SPECS,
+  canonicalMediaFx,
   formatMediaNumber,
   hasRenderableFx,
   mediaEditHtmlAttribute,
   mediaEditValuesFromAttributes,
   mediaEditValuesFromParams,
+  mediaRecipeHash,
   mediaRenderKey,
   normalizeMediaCrop,
   normalizeMediaCuts,
@@ -26,7 +28,7 @@ import {
   serializeMediaCuts,
   serializeMediaEdits,
   serializeMediaFx
-} from "../chunk-L7QZORLB.js";
+} from "../chunk-37RLFDIT.js";
 
 // src/mediaEdit/renderStore.ts
 var MEDIA_RENDER_DIR = ".mediaEdits";
@@ -173,6 +175,220 @@ function selectMediaRendersForGc(index, referencedKeys, manifests, now = /* @__P
   return paths;
 }
 
+// src/mediaEdit/bake.ts
+var MEDIA_BAKE_ENGINE = "squisq-media-bake/1";
+var MEDIA_BAKE_MANIFEST_VERSION = 1;
+var MEDIA_CUT_EDGE_FADE_SEC = 0.01;
+var BAKE_EXTENSIONS = /* @__PURE__ */ new Set(["mp4", "webm", "m4a", "wav"]);
+function mediaBakeCuts(clip) {
+  return normalizeMediaCuts(
+    clip.edits?.cuts ?? [],
+    Math.max(0, clip.clipStart ?? 0),
+    clip.clipEnd ?? Number.POSITIVE_INFINITY
+  );
+}
+function needsMediaBake(clip) {
+  const edits = clip.edits;
+  if (!edits) return false;
+  return mediaBakeCuts(clip).length > 0 || hasRenderableFx(edits.fx) || Boolean(edits.gain) || Boolean(edits.fadeIn) || Boolean(edits.fadeOut) || clip.kind === "video" && edits.crop != null;
+}
+function canBakeMedia(clip) {
+  return needsMediaBake(clip) || (clip.clipStart ?? 0) > 0 || clip.clipEnd != null;
+}
+function mediaBakeSpec(clip) {
+  const edits = clip.edits;
+  const seconds = (value) => value ? formatMediaNumber(value) : "";
+  return [
+    MEDIA_BAKE_ENGINE,
+    clip.src,
+    clip.kind,
+    `trim=${seconds(clip.clipStart)}-${clip.clipEnd != null ? formatMediaNumber(clip.clipEnd) : ""}`,
+    `cuts=${serializeMediaCuts(mediaBakeCuts(clip))}`,
+    `fx=${hasRenderableFx(edits?.fx) ? canonicalMediaFx(edits.fx) : ""}`,
+    `gain=${edits?.gain ? formatMediaNumber(edits.gain, 2) : ""}`,
+    `fadeIn=${seconds(edits?.fadeIn)}`,
+    `fadeOut=${seconds(edits?.fadeOut)}`,
+    `crop=${clip.kind === "video" && edits?.crop ? serializeMediaCrop(edits.crop) : ""}`
+  ].join("\n");
+}
+function mediaBakeKey(clip) {
+  return mediaRecipeHash(mediaBakeSpec(clip));
+}
+function mediaBakeFilePath(src, key, extension) {
+  return `${MEDIA_RENDER_DIR}/${mediaRenderStem(src)}.${key}.baked.${extension}`;
+}
+function mediaBakeManifestPath(src, key) {
+  return `${MEDIA_RENDER_DIR}/${mediaRenderStem(src)}.${key}.baked.json`;
+}
+function parseMediaBakePath(path) {
+  const segments = path.split("/");
+  const dirIndex = segments.length - 2;
+  if (dirIndex < 0 || segments[dirIndex] !== MEDIA_RENDER_DIR) return null;
+  const match = segments[segments.length - 1].match(/^(.+)\.([0-9a-f]{12})\.baked\.([a-z0-9]+)$/);
+  if (!match) return null;
+  const extension = match[3];
+  const isManifest = extension === "json";
+  if (!isManifest && !BAKE_EXTENSIONS.has(extension)) return null;
+  return { stem: match[1], key: match[2], extension, isManifest };
+}
+function isMediaBakePath(path) {
+  return parseMediaBakePath(path) != null;
+}
+function buildMediaBakeIndex(entries) {
+  const manifests = /* @__PURE__ */ new Map();
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const parsed = parseMediaBakePath(entry.name);
+    if (!parsed) continue;
+    if (parsed.isManifest) manifests.set(parsed.key, entry.name);
+    else {
+      index.set(parsed.key, {
+        key: parsed.key,
+        path: entry.name,
+        manifestPath: null,
+        size: entry.size
+      });
+    }
+  }
+  for (const [key, entry] of index) entry.manifestPath = manifests.get(key) ?? null;
+  return index;
+}
+function parseMediaBakeManifest(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!raw || typeof raw !== "object") return null;
+  const m = raw;
+  const str = (v) => typeof v === "string";
+  const numOrNull = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+  if (m.version !== MEDIA_BAKE_MANIFEST_VERSION) return null;
+  if (!str(m.src) || !str(m.key) || !str(m.spec) || !str(m.file) || !str(m.mimeType)) return null;
+  if (!str(m.engine) || !str(m.createdAt)) return null;
+  return {
+    version: MEDIA_BAKE_MANIFEST_VERSION,
+    src: m.src,
+    key: m.key,
+    spec: m.spec,
+    file: m.file,
+    mimeType: m.mimeType,
+    sourceSize: numOrNull(m.sourceSize),
+    duration: numOrNull(m.duration),
+    engine: m.engine,
+    createdAt: m.createdAt
+  };
+}
+function serializeMediaBakeManifest(manifest) {
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+function isMediaBakeStale(manifest, current) {
+  return current.sourceSize != null && manifest.sourceSize != null && current.sourceSize !== manifest.sourceSize;
+}
+function selectSupersededMediaBakes(index, manifests, sources, referencedKeys) {
+  const paths = [];
+  for (const [key, entry] of index) {
+    if (referencedKeys.has(key)) continue;
+    const manifest = manifests.get(key);
+    if (!manifest || !sources.has(manifest.src)) continue;
+    paths.push(entry.path);
+    if (entry.manifestPath) paths.push(entry.manifestPath);
+  }
+  return paths;
+}
+function mediaBakeCopyName(src, extension) {
+  const base = src.split(/[?#]/, 1)[0].split("/").pop() || "media";
+  const stem = base.replace(/\.[^.]+$/, "") || "media";
+  return `${stem}-edited.${extension}`;
+}
+function mediaBakeCopyPath(src, extension) {
+  const path = src.split(/[?#]/, 1)[0];
+  const slash = path.lastIndexOf("/");
+  const name = mediaBakeCopyName(src, extension);
+  return slash < 0 ? name : `${path.slice(0, slash + 1)}${name}`;
+}
+function mediaBakeFrameRanges(kept, windowStart, sampleRate) {
+  const ranges = [];
+  for (const range of kept) {
+    const start = Math.max(0, Math.round((range.start - windowStart) * sampleRate));
+    const end = Math.round((range.end - windowStart) * sampleRate);
+    if (end > start) ranges.push([start, end]);
+  }
+  return ranges;
+}
+function createMediaBakeAudioStage(options) {
+  const { ranges, sampleRate } = options;
+  const gain = options.gainDb ? Math.pow(10, options.gainDb / 20) : 1;
+  const totalFrames = ranges.reduce((sum, [start, end]) => sum + (end - start), 0);
+  const fadeIn = Math.min(totalFrames, Math.round((options.fadeInSec ?? 0) * sampleRate));
+  const fadeOut = Math.min(totalFrames, Math.round((options.fadeOutSec ?? 0) * sampleRate));
+  const edge = Math.max(1, Math.round(MEDIA_CUT_EDGE_FADE_SEC * sampleRate));
+  const joins = [];
+  let cumulative = 0;
+  for (let i = 0; i < ranges.length - 1; i++) {
+    cumulative += ranges[i][1] - ranges[i][0];
+    joins.push(cumulative);
+  }
+  const levelAt = (frame, joinIndex2) => {
+    let level = gain;
+    if (frame < fadeIn) level *= frame / fadeIn;
+    if (frame >= totalFrames - fadeOut) level *= (totalFrames - frame) / fadeOut;
+    const join = joins[joinIndex2];
+    if (join !== void 0) {
+      const distance = frame < join ? join - 1 - frame : frame - join;
+      if (distance < edge) level *= distance / edge;
+    }
+    return level;
+  };
+  let fed = 0;
+  let played = 0;
+  let rangeIndex = 0;
+  let joinIndex = 0;
+  return {
+    totalFrames,
+    process(block) {
+      const length = block[0]?.length ?? 0;
+      const blockStart = fed;
+      const blockEnd = fed + length;
+      fed = blockEnd;
+      const slices = [];
+      let kept = 0;
+      while (rangeIndex < ranges.length) {
+        const [rangeStart, rangeEnd] = ranges[rangeIndex];
+        if (rangeStart >= blockEnd) break;
+        const from = Math.max(rangeStart, blockStart);
+        const to = Math.min(rangeEnd, blockEnd);
+        if (to > from) {
+          slices.push([from - blockStart, to - blockStart]);
+          kept += to - from;
+        }
+        if (rangeEnd > blockEnd) break;
+        rangeIndex++;
+      }
+      if (kept === 0) return null;
+      const out = block.map(() => new Float32Array(kept));
+      let at = 0;
+      for (const [from, to] of slices) {
+        for (let c = 0; c < block.length; c++) out[c].set(block[c].subarray(from, to), at);
+        at += to - from;
+      }
+      const first = played;
+      const last = played + kept;
+      played = last;
+      for (let i = 0; i < kept; i++) {
+        const frame = first + i;
+        while (joinIndex < joins.length && joins[joinIndex] + edge <= frame) joinIndex++;
+        const level = levelAt(frame, joinIndex);
+        if (level === 1) continue;
+        for (const channel of out) channel[i] *= level;
+      }
+      return out;
+    }
+  };
+}
+
 // src/mediaEdit/dsp/breath.ts
 var HOP_SEC = 0.01;
 var FRAME_SEC = 0.02;
@@ -932,6 +1148,9 @@ function detectPauseCuts(frames, options = {}) {
   return cuts;
 }
 export {
+  MEDIA_BAKE_ENGINE,
+  MEDIA_BAKE_MANIFEST_VERSION,
+  MEDIA_CUT_EDGE_FADE_SEC,
   MEDIA_EDIT_PARAMS,
   MEDIA_FX_ENGINE,
   MEDIA_FX_LOUDNESS_TOLERANCE,
@@ -946,13 +1165,17 @@ export {
   analyzeMediaFx,
   applyBreathEnvelope,
   breathGainAt,
+  buildMediaBakeIndex,
   buildMediaRenderIndex,
+  canBakeMedia,
+  canonicalMediaFx,
   collectDocMediaClips,
   correctedLoudnessAnalysis,
   createBreathAnalyzer,
   createDenoiseStage,
   createLimiter,
   createLoudnessMeter,
+  createMediaBakeAudioStage,
   createMediaTimeMap,
   createResampler,
   detectBreaths,
@@ -960,19 +1183,33 @@ export {
   formatMediaNumber,
   hasRenderableFx,
   integratedLoudnessFromSteps,
+  isMediaBakePath,
+  isMediaBakeStale,
   isMediaRenderPath,
+  mediaBakeCopyName,
+  mediaBakeCopyPath,
+  mediaBakeCuts,
+  mediaBakeFilePath,
+  mediaBakeFrameRanges,
+  mediaBakeKey,
+  mediaBakeManifestPath,
+  mediaBakeSpec,
   mediaClipRenderKey,
   mediaEditHtmlAttribute,
   mediaEditValuesFromAttributes,
   mediaEditValuesFromParams,
+  mediaRecipeHash,
   mediaRenderFilePath,
   mediaRenderKey,
   mediaRenderKeyFor,
   mediaRenderManifestPath,
   mediaRenderStaleness,
   mediaRenderStem,
+  needsMediaBake,
   normalizeMediaCrop,
   normalizeMediaCuts,
+  parseMediaBakeManifest,
+  parseMediaBakePath,
   parseMediaCrop,
   parseMediaCuts,
   parseMediaEdits,
@@ -982,6 +1219,8 @@ export {
   referencedMediaRenderKeys,
   renderMediaFx,
   selectMediaRendersForGc,
+  selectSupersededMediaBakes,
+  serializeMediaBakeManifest,
   serializeMediaCrop,
   serializeMediaCuts,
   serializeMediaEdits,

package/dist/narration/index.d.ts

@@ -1,4 +1,4 @@
-import { T as Doc, bb as PresentationSlideMark, f as AudioBookmark } from '../Doc-BhvotZx_.js';
+import { U as Doc, bf as PresentationSlideMark, f as AudioBookmark } from '../Doc-DLfTam0R.js';
 import { d as BuildAdvance } from '../types-Zk8qYuaT.js';
 
 /**