@bendyline/squisq 2.0.1 → 2.2.0

package/dist/markdown/index.d.ts

@@ -1,6 +1,6 @@
-import { V as ParseOptions, m as MarkdownDocument, W as StringifyOptions, H as HeadingAttributes, d as HtmlNode, I as MarkdownNode } from '../types-BwMPl2CB.js';
-export { a as HeadingTemplateAnnotation, b as HtmlComment, c as HtmlElement, e as HtmlText, M as MarkdownBlockNode, f as MarkdownBlockquote, g as MarkdownBreak, h as MarkdownCodeBlock, i as MarkdownContainerDirective, j as MarkdownDefinitionDescription, k as MarkdownDefinitionList, l as MarkdownDefinitionTerm, n as MarkdownEmphasis, o as MarkdownFootnoteDefinition, p as MarkdownFootnoteReference, q as MarkdownHeading, r as MarkdownHtmlBlock, s as MarkdownImage, t as MarkdownImageReference, u as MarkdownInlineCode, v as MarkdownInlineHtml, w as MarkdownInlineMath, x as MarkdownInlineNode, y as MarkdownLeafDirective, z as MarkdownLink, A as MarkdownLinkDefinition, B as MarkdownLinkReference, C as MarkdownList, E as MarkdownListItem, F as MarkdownMathBlock, G as MarkdownMention, J as MarkdownParagraph, K as MarkdownPoint, L as MarkdownSourcePosition, N as MarkdownStrikethrough, O as MarkdownStrong, P as MarkdownTable, Q as MarkdownTableCell, R as MarkdownTableRow, S as MarkdownText, T as MarkdownTextDirective, U as MarkdownThematicBreak } from '../types-BwMPl2CB.js';
-export { B as BLOCK_META_KEY_DESCRIPTORS, a as BlockMetaKeyDescriptor, K as KNOWN_BLOCK_META_KEYS, b as KnownBlockMetaKey, p as parseTimeSeconds } from '../annotationCoercion-Dr_DY9Hx.js';
+import { Y as ParseOptions, n as MarkdownDocument, Z as StringifyOptions, H as HeadingAttributes, e as HtmlNode, K as MarkdownNode } from '../types-CUNc9biN.js';
+export { D as DEFAULT_MARKDOWN_SAFETY_LIMITS, b as HeadingTemplateAnnotation, c as HtmlComment, d as HtmlElement, f as HtmlText, M as MarkdownBlockNode, g as MarkdownBlockquote, h as MarkdownBreak, i as MarkdownCodeBlock, j as MarkdownContainerDirective, k as MarkdownDefinitionDescription, l as MarkdownDefinitionList, m as MarkdownDefinitionTerm, o as MarkdownEmphasis, p as MarkdownFootnoteDefinition, q as MarkdownFootnoteReference, r as MarkdownHeading, s as MarkdownHtmlBlock, t as MarkdownImage, u as MarkdownImageReference, v as MarkdownInlineCode, w as MarkdownInlineHtml, x as MarkdownInlineMath, y as MarkdownInlineNode, z as MarkdownLeafDirective, A as MarkdownLimitError, B as MarkdownLink, C as MarkdownLinkDefinition, E as MarkdownLinkReference, F as MarkdownList, G as MarkdownListItem, I as MarkdownMathBlock, J as MarkdownMention, L as MarkdownParagraph, N as MarkdownPoint, O as MarkdownSafetyLimits, P as MarkdownSourcePosition, Q as MarkdownStrikethrough, R as MarkdownStrong, S as MarkdownTable, T as MarkdownTableCell, U as MarkdownTableRow, V as MarkdownText, W as MarkdownTextDirective, X as MarkdownThematicBreak, a3 as assertMarkdownDocumentWithinLimits, a4 as assertMarkdownSourceWithinLimits, a9 as resolveMarkdownSafetyLimits } from '../types-CUNc9biN.js';
+export { B as BLOCK_META_KEY_DESCRIPTORS, a as BlockMetaKeyDescriptor, K as KNOWN_BLOCK_META_KEYS, b as KnownBlockMetaKey, p as parseTimeSeconds } from '../annotationCoercion-PtRQhk5V.js';
 
 /**
  * Markdown → JSON Parser
@@ -296,6 +296,59 @@ declare function sanitizeUrl(url: string | null | undefined, kind?: UrlKind, opt
  */
 declare function sanitizeHtmlNodes(nodes: HtmlNode[]): HtmlNode[];
 
+/**
+ * Caller-owned policy for resources referenced by a document.
+ *
+ * The core package deliberately does not decide whether a document is trusted.
+ * Interactive hosts can keep the browser-compatible default, restrict remote
+ * hosts, or provide a local-only policy. Headless/server callers should use the
+ * local-only policy unless they have an explicit, audited allow-list.
+ */
+interface ResourcePolicy {
+    /** Permit http(s) and protocol-relative URLs. Default: true. */
+    allowRemote?: boolean;
+    /** Permit relative and root-relative URLs. Default: true. */
+    allowRelative?: boolean;
+    /** Permit blob: URLs. Default: true. */
+    allowBlob?: boolean;
+    /** Permit image/audio/video data: URLs. Default: true. */
+    allowData?: boolean;
+    /** Exact hosts or `*.example.com` suffixes allowed for remote URLs. */
+    allowedHosts?: readonly string[];
+    /** Maximum bytes read by one bounded fetch. Default: 64 MiB. */
+    maxBytes?: number;
+    /** Maximum time for one bounded fetch. Default: 15 seconds. */
+    timeoutMs?: number;
+}
+declare const DEFAULT_RESOURCE_MAX_BYTES: number;
+declare const DEFAULT_RESOURCE_TIMEOUT_MS = 15000;
+declare const DEFAULT_INTERACTIVE_RESOURCE_POLICY: Readonly<Required<ResourcePolicy>>;
+declare const LOCAL_ONLY_RESOURCE_POLICY: Readonly<Required<ResourcePolicy>>;
+declare class ResourcePolicyError extends Error {
+    readonly code: 'RESOURCE_BLOCKED' | 'RESOURCE_TOO_LARGE' | 'RESOURCE_TIMEOUT';
+    constructor(code: ResourcePolicyError['code'], message: string);
+}
+interface FetchResourceBytesOptions {
+    policy?: ResourcePolicy;
+    signal?: AbortSignal;
+    /** Optional fetch implementation for tests or non-browser runtimes. */
+    fetch?: typeof globalThis.fetch;
+    /** Reject successful responses whose Content-Type does not match a prefix. */
+    contentTypePrefixes?: readonly string[];
+}
+interface FetchedResource {
+    bytes: Uint8Array;
+    contentType: string;
+    finalUrl: string;
+}
+/** Return whether a document resource URL is admitted by a policy. */
+declare function isResourceUrlAllowed(input: string | null | undefined, policy?: ResourcePolicy): boolean;
+/**
+ * Fetch a document-controlled resource without buffering unbounded data.
+ * Redirect destinations are revalidated after fetch follows them.
+ */
+declare function fetchResourceBytes(input: string, options?: FetchResourceBytesOptions): Promise<FetchedResource>;
+
 /**
  * Markdown Tree Utilities
  *
@@ -360,9 +413,10 @@ declare function countNodes(node: MarkdownNode): number;
 /**
  * Parse a YAML frontmatter string into a key-value record.
  *
- * Handles simple `key: value` pairs common in markdown frontmatter.
- * Values are trimmed; quoted strings have their quotes removed.
- * Returns `null` if parsing fails or the input is empty.
+ * Handles the subset documented above: nested mappings, block sequences,
+ * quoted and block scalars, booleans/null, and conservatively-coerced
+ * numbers. Returns `null` when the input is empty or carries no mapping
+ * keys at all.
  *
  * @param yaml - The raw YAML string (without the `---` delimiters)
  * @returns A record of string keys to parsed values, or null
@@ -378,6 +432,15 @@ declare function parseFrontmatter(yaml: string): Record<string, unknown> | null;
 declare function formatBlockScalar(value: string): string;
 /** Quote a frontmatter scalar so it round-trips cleanly through `parseFrontmatter`. */
 declare function formatFrontmatterValue(value: string | number | boolean): string;
+/**
+ * Serialize a frontmatter record to YAML (without the `---` delimiters).
+ *
+ * The write half of the round-trip pair documented above: nested objects
+ * become nested block mappings and arrays become block sequences, so
+ * structured frontmatter reads back as the same structure with the same
+ * types. Returns an empty string when nothing is writable.
+ */
+declare function formatFrontmatterYaml(frontmatter: Record<string, unknown>): string;
 /**
  * Update a markdown source string's YAML frontmatter block, applying the
  * given key/value updates. A `null` or `undefined` value removes the key.
@@ -386,10 +449,11 @@ declare function formatFrontmatterValue(value: string | number | boolean): strin
  * exists, the source is returned unchanged.
  *
  * Existing key order is preserved; new keys are appended in the order
- * they appear in `updates`. The simple parser used here handles plain
- * `key: value` pairs only — comments, multi-line scalars, and nested
- * structures are left untouched (we only rewrite lines whose key matches
- * one in `updates`).
+ * they appear in `updates`. Rewriting is **node-aware**: a key whose value
+ * is a block scalar or a nested map/sequence owns its indented body, so
+ * removing or replacing it takes the whole node with it, and body lines are
+ * never mistaken for top-level keys (an indented `name: X` inside another
+ * key's block scalar stays put even when `name` is being updated).
  *
  * @param source - The markdown source string.
  * @param updates - Map of key → new value (or null/undefined to remove).
@@ -435,4 +499,4 @@ declare function readFrontmatterThemeId(frontmatter: Record<string, unknown> | u
  */
 declare function plainTextFromInlineHtml(html: string): string;
 
-export { HeadingAttributes, HtmlNode, type HtmlPolicy, MarkdownDocument, MarkdownNode, ParseOptions, type SanitizeUrlOptions, StringifyOptions, type TrailingAnnotationMatch, type UrlKind, countNodes, createDocument, extractPlainText, findNodesByType, formatBlockScalar, formatFrontmatterValue, fromMdast, getChildren, inferDocumentTitle, matchTrailingPandocAttr, matchTrailingTemplateAnnotation, needsQuoting, parseFrontmatter, parseHtmlToNodes, parseMarkdown, parsePandocAttrTokens, plainTextFromInlineHtml, quoteAttrValue, readFrontmatterThemeId, sanitizeHtmlNodes, sanitizeUrl, serializePandocAttributes, setFrontmatterValues, splitKeyValueToken, stringifyHtmlNodes, stringifyMarkdown, toMdast, tokenizeAttrTokens, unquoteAttrValue, walkMarkdownTree };
+export { DEFAULT_INTERACTIVE_RESOURCE_POLICY, DEFAULT_RESOURCE_MAX_BYTES, DEFAULT_RESOURCE_TIMEOUT_MS, type FetchResourceBytesOptions, type FetchedResource, HeadingAttributes, HtmlNode, type HtmlPolicy, LOCAL_ONLY_RESOURCE_POLICY, MarkdownDocument, MarkdownNode, ParseOptions, type ResourcePolicy, ResourcePolicyError, type SanitizeUrlOptions, StringifyOptions, type TrailingAnnotationMatch, type UrlKind, countNodes, createDocument, extractPlainText, fetchResourceBytes, findNodesByType, formatBlockScalar, formatFrontmatterValue, formatFrontmatterYaml, fromMdast, getChildren, inferDocumentTitle, isResourceUrlAllowed, matchTrailingPandocAttr, matchTrailingTemplateAnnotation, needsQuoting, parseFrontmatter, parseHtmlToNodes, parseMarkdown, parsePandocAttrTokens, plainTextFromInlineHtml, quoteAttrValue, readFrontmatterThemeId, sanitizeHtmlNodes, sanitizeUrl, serializePandocAttributes, setFrontmatterValues, splitKeyValueToken, stringifyHtmlNodes, stringifyMarkdown, toMdast, tokenizeAttrTokens, unquoteAttrValue, walkMarkdownTree };

package/dist/markdown/index.js

@@ -1,15 +1,27 @@
 import {
+  DEFAULT_INTERACTIVE_RESOURCE_POLICY,
+  DEFAULT_RESOURCE_MAX_BYTES,
+  DEFAULT_RESOURCE_TIMEOUT_MS,
+  LOCAL_ONLY_RESOURCE_POLICY,
+  ResourcePolicyError,
+  fetchResourceBytes,
+  isResourceUrlAllowed,
   sanitizeHtmlNodes,
   sanitizeUrl,
   stringifyMarkdown
-} from "../chunk-R2GC6RLD.js";
+} from "../chunk-3IGPAPQ7.js";
 import {
+  DEFAULT_MARKDOWN_SAFETY_LIMITS,
+  MarkdownLimitError,
+  assertMarkdownDocumentWithinLimits,
+  assertMarkdownSourceWithinLimits,
   fromMdast,
   parseMarkdown,
   parsePandocAttrTokens,
+  resolveMarkdownSafetyLimits,
   serializePandocAttributes,
   toMdast
-} from "../chunk-66QO7XFB.js";
+} from "../chunk-ACZOVWX3.js";
 import {
   BLOCK_META_KEY_DESCRIPTORS,
   KNOWN_BLOCK_META_KEYS,
@@ -21,8 +33,8 @@ import {
   splitKeyValueToken,
   tokenizeAttrTokens,
   unquoteAttrValue
-} from "../chunk-R2YZTCLO.js";
-import "../chunk-DBS6RIFL.js";
+} from "../chunk-ZQKZSJAX.js";
+import "../chunk-7N4G32LG.js";
 import {
   countNodes,
   createDocument,
@@ -30,6 +42,7 @@ import {
   findNodesByType,
   formatBlockScalar,
   formatFrontmatterValue,
+  formatFrontmatterYaml,
   getChildren,
   inferDocumentTitle,
   parseFrontmatter,
@@ -39,20 +52,32 @@ import {
   setFrontmatterValues,
   stringifyHtmlNodes,
   walkMarkdownTree
-} from "../chunk-AMIR72JP.js";
-import "../chunk-QE7TWGVT.js";
+} from "../chunk-BCCXTMN5.js";
+import "../chunk-4VOD55SX.js";
 export {
   BLOCK_META_KEY_DESCRIPTORS,
+  DEFAULT_INTERACTIVE_RESOURCE_POLICY,
+  DEFAULT_MARKDOWN_SAFETY_LIMITS,
+  DEFAULT_RESOURCE_MAX_BYTES,
+  DEFAULT_RESOURCE_TIMEOUT_MS,
   KNOWN_BLOCK_META_KEYS,
+  LOCAL_ONLY_RESOURCE_POLICY,
+  MarkdownLimitError,
+  ResourcePolicyError,
+  assertMarkdownDocumentWithinLimits,
+  assertMarkdownSourceWithinLimits,
   countNodes,
   createDocument,
   extractPlainText,
+  fetchResourceBytes,
   findNodesByType,
   formatBlockScalar,
   formatFrontmatterValue,
+  formatFrontmatterYaml,
   fromMdast,
   getChildren,
   inferDocumentTitle,
+  isResourceUrlAllowed,
   matchTrailingPandocAttr,
   matchTrailingTemplateAnnotation,
   needsQuoting,
@@ -64,6 +89,7 @@ export {
   plainTextFromInlineHtml,
   quoteAttrValue,
   readFrontmatterThemeId,
+  resolveMarkdownSafetyLimits,
   sanitizeHtmlNodes,
   sanitizeUrl,
   serializePandocAttributes,
@@ -76,4 +102,3 @@ export {
   unquoteAttrValue,
   walkMarkdownTree
 };
-//# sourceMappingURL=index.js.map

package/dist/materializePageSection-wSLA2A1g.d.ts

@@ -0,0 +1,223 @@
+import { B as Block, at as PageSectionKind, ar as PageEmphasis, b3 as ThemeColorScheme, ap as PageBackground, b1 as Theme, bq as ViewportConfig, p as CustomTemplateDefinition, aR as StartBlockConfig, F as Doc, b4 as ThemePageStyle } from './Doc-BubIpWsp.js';
+import { M as MarkdownBlockNode } from './types-CUNc9biN.js';
+
+/**
+ * PageSection — the framework-agnostic block model for Page (linear) mode.
+ *
+ * Where `materializeBlockLayers` turns a block into fixed-viewport SVG
+ * `Layer[]` (slides, video frames, spatial canvases), `materializePageSection`
+ * turns the same block into a `PageSection`: a variable-height, content-slot
+ * description that HTML renderers lay out reflowably. React's page view and
+ * any string-HTML exporter consume this same structure, so neither re-derives
+ * content from blocks.
+ *
+ * Inherently spatial content (diagram/tree/timeline/map/drawing/layout,
+ * authored layers, custom templates) stays SVG: those sections carry the
+ * source block in a `canvas` media slot and consumers embed the result of
+ * `materializeBlockLayers` responsively. Core never emits markup.
+ */
+
+/**
+ * Rich text content for a slot. `text` is always present (plain text);
+ * `markdown` carries the original body nodes when the block has them, so
+ * renderers can show real rich text with the plain string as fallback.
+ */
+interface PageRichText {
+    text: string;
+    markdown?: MarkdownBlockNode[];
+}
+/** Which spatial pipeline a canvas-embed section renders through. */
+type PageSpatialKind = 'diagram' | 'tree' | 'timeline' | 'map' | 'drawing' | 'layout' | 'custom' | 'authored';
+/** Media content for a section slot. */
+type PageMedia = {
+    type: 'image';
+    src: string;
+    alt: string;
+    credit?: string;
+    license?: string;
+    width?: number;
+    height?: number;
+} | {
+    type: 'video';
+    src: string;
+    posterSrc?: string;
+    alt: string;
+    clipStart?: number;
+    clipEnd?: number;
+    credit?: string;
+    license?: string;
+} | {
+    type: 'canvas';
+    spatial: PageSpatialKind;
+    /**
+     * The block to pass to `materializeBlockLayers` (already merged with
+     * derived inputs/params for annotated blocks). Read-only reference.
+     */
+    block: Block;
+    /** Intrinsic aspect for the responsive embed frame. */
+    aspect: {
+        width: number;
+        height: number;
+    };
+};
+/** One entry in a multi-item section (stats, cards, gallery tiles, list rows). */
+interface PageSectionItem {
+    title?: string;
+    body?: string;
+    /** Large numeral / value for stat and comparison items. */
+    value?: string | number;
+    media?: PageMedia;
+    /** Per-item color-scheme name (e.g. twoColumn halves). */
+    accentScheme?: string;
+}
+/** Structured diagnostics for sections that fell back (unknown template …). */
+interface PageSectionDiagnostic {
+    code: 'unknown-template';
+    template: string;
+    message: string;
+}
+/** Where a section's content came from. */
+type PageSectionSource = 'template' | 'prose' | 'authored' | 'custom-template' | 'cover' | 'fallback';
+/**
+ * One variable-height page section. The `kind` selects the layout family;
+ * `slots` carry the content; `emphasis`/`accent`/`background` carry the
+ * theme's art-direction decisions for this position in the sequence.
+ */
+interface PageSection {
+    kind: PageSectionKind;
+    /** Layout variant within the kind (e.g. quote-band: plain|display|full-bleed|editorial). */
+    variant?: string;
+    /** Source block id ('' for the synthesized cover hero). */
+    blockId: string;
+    /** Canonical source template id (post-alias); absent for prose/cover/authored. */
+    template?: string;
+    slots: {
+        /** Kicker text above the title (theme decides visibility/treatment). */
+        eyebrow?: string;
+        title?: string;
+        subtitle?: string;
+        body?: PageRichText;
+        /**
+         * Authored rich body nodes not consumed by the selected template. Page
+         * renderers place this after the template-specific layout so images,
+         * video/audio HTML, and Mermaid fences are never silently discarded.
+         */
+        richContent?: PageRichText;
+        media?: PageMedia;
+        items?: PageSectionItem[];
+        table?: {
+            headers: string[];
+            rows: string[][];
+            align?: (('left' | 'right' | 'center') | null)[];
+        };
+        milestone?: {
+            date: string;
+            description: string;
+            footer?: string;
+            mood?: 'neutral' | 'somber' | 'celebratory';
+        };
+        attribution?: string;
+        caption?: string;
+        /** Small print: source citation, term origin, comparison unit. */
+        meta?: string;
+        /** Heading depth for prose sections (1..6). */
+        headingLevel?: number;
+    };
+    emphasis: PageEmphasis;
+    /** Resolved accent for this section; block-level colorScheme wins over rotation. */
+    accent: {
+        schemeName?: string;
+        scheme?: ThemeColorScheme;
+        role: 'primary' | 'rotation' | 'block' | 'none';
+    };
+    background: PageBackground;
+    /** Pre-order position among this doc's sections. */
+    index: number;
+    totalSections: number;
+    /** Nesting depth of the source block (0 for top-level and the cover). */
+    depth: number;
+    source: PageSectionSource;
+    diagnostic?: PageSectionDiagnostic;
+    /** Freeform theme hints from pageStyle overrides (e.g. dropCap, frame). */
+    hints?: Record<string, string | number | boolean>;
+}
+/** Result wrapper mirroring `BlockLayerMaterialization`'s shape. */
+interface PageSectionMaterialization {
+    section: PageSection;
+    /** The source block; undefined for the synthesized cover hero. */
+    block?: Block;
+    source: PageSectionSource;
+    diagnostic?: PageSectionDiagnostic;
+}
+
+/**
+ * Canonical block-to-page-section materialization — the Page (linear) mode
+ * sibling of `materializeBlockLayers`.
+ *
+ * `materializePageSections(doc, …)` is the primary entry point: it walks the
+ * block tree pre-order, extracts a `PageSection` per block (cover hero,
+ * typed template sections, prose, canvas embeds, visible fallbacks), and
+ * then applies the theme's art direction across the sequence — background
+ * rhythm, accent rotation, and the emphasis curve are sequence-scoped
+ * decisions that per-block calls cannot make.
+ *
+ * Failures are data, not console side effects: an unknown template becomes
+ * a visible `callout` section with a structured diagnostic (mirroring
+ * `materializeBlockLayers`' fallback posture).
+ */
+
+/**
+ * Page-mode hints a transform style may carry (`TransformStyleConfig.page`).
+ * Defined here (not in `transform/`) so the doc pipeline stays independent
+ * of the transform module.
+ */
+interface PageTransformHints {
+    /** Overrides `pageStyle.tokens.sectionSpacing` for this rendition. */
+    spacing?: 'compact' | 'comfortable' | 'generous';
+    /** 'front-loaded' promotes the first sections' emphasis one step. */
+    emphasisCurve?: 'even' | 'front-loaded';
+}
+/** Options shared by the per-block and doc-level entry points. */
+interface MaterializePageSectionOptions {
+    /** Theme whose `pageStyle` art-directs the sections. */
+    theme?: Theme;
+    /** Aspect reference for canvas embeds. Defaults to the landscape preset. */
+    viewport?: ViewportConfig;
+    /** Zero-based position in the section sequence (per-block calls). */
+    blockIndex?: number;
+    /** Total sections in the sequence (per-block calls). */
+    totalBlocks?: number;
+    /** Document-scoped custom templates (render as canvas embeds). */
+    customTemplates?: readonly CustomTemplateDefinition[];
+}
+/** Doc-level options. */
+interface MaterializePageSectionsOptions extends MaterializePageSectionOptions {
+    /**
+     * Cover hero: pass the doc's `startBlock` to synthesize a leading hero
+     * section, `false`/undefined to omit. (The caller decides — the editor's
+     * Cover toggle maps here.)
+     */
+    cover?: StartBlockConfig | false;
+    /** Page hints from the active transform style, if any. */
+    transformPage?: PageTransformHints;
+}
+/**
+ * Resolve the effective page style for a theme: explicit `theme.pageStyle`
+ * wins, else a derived default. Transform hints overlay spacing.
+ * Never returns undefined.
+ */
+declare function resolvePageStyle(theme?: Theme, hints?: PageTransformHints): ThemePageStyle;
+/**
+ * Materialize one block in isolation. Sequence-scoped art direction
+ * (background rhythm, accent rotation, emphasis curve) does not apply —
+ * use `materializePageSections` for whole-document rendering.
+ */
+declare function materializePageSection(block: Block, options?: MaterializePageSectionOptions): PageSectionMaterialization;
+/**
+ * Materialize a whole document into its ordered page sections, applying
+ * the theme's art direction across the sequence. The primary entry point
+ * for Page (linear) mode renderers and exporters.
+ */
+declare function materializePageSections(doc: Doc, options?: MaterializePageSectionsOptions): PageSectionMaterialization[];
+
+export { type MaterializePageSectionOptions as M, type PageMedia as P, type MaterializePageSectionsOptions as a, type PageRichText as b, type PageSection as c, type PageSectionDiagnostic as d, type PageSectionItem as e, type PageSectionMaterialization as f, type PageSectionSource as g, type PageSpatialKind as h, type PageTransformHints as i, materializePageSections as j, materializePageSection as m, resolvePageStyle as r };

package/dist/narration/index.d.ts

@@ -1,5 +1,5 @@
-import { F as Doc, e as AudioBookmark } from '../Doc-ylqWKDc_.js';
-import '../types-BwMPl2CB.js';
+import { F as Doc, e as AudioBookmark } from '../Doc-BubIpWsp.js';
+import '../types-CUNc9biN.js';
 
 /**
  * Shared types + tuning configs for the narration engine.
@@ -175,6 +175,12 @@ interface PacingConfig {
 }
 declare const DEFAULT_PACING_CONFIG: PacingConfig;
 interface AlignConfig {
+    /** Maximum take duration accepted by the batch aligner. */
+    maxDurationSec: number;
+    /** Maximum PCM samples accepted by the batch aligner. */
+    maxPcmSamples: number;
+    /** Maximum script tokens accepted by the batch aligner. */
+    maxScriptTokens: number;
     /** Fine analysis hop for the offline pass (s). */
     hopSec: number;
     /** Non-speech runs at least this long become GAP events (s). */
@@ -549,6 +555,8 @@ interface AlignInput {
     script: NarrationScript;
     /** Live prompter trace recorded during the take, if any. */
     trace?: NarrationTrace;
+    /** Cancel before expensive alignment phases. */
+    signal?: AbortSignal;
 }
 declare function alignNarration(input: AlignInput, config?: Partial<AlignConfig>): NarrationAlignment;
 
@@ -592,7 +600,12 @@ interface NarrationTimingJsonV3 {
     /** Per-word timings: { id: `word-${i}`, time, charOffset, textFragment }. */
     bookmarks: AudioBookmark[];
     blocks: NarrationTimingBlock[];
-    /** Start skew of the companion camera recording, when one exists. */
+    /**
+     * SIGNED start skew of the companion camera recording, when one exists:
+     * `cameraStart - audioStart`, in seconds. Negative when the camera pipeline
+     * began first — which is reachable, since the two `MediaRecorder`s report
+     * their start asynchronously and independently.
+     */
     cameraOffsetSec?: number;
     /** Provenance of the timing data. */
     generator?: {

package/dist/narration/index.js

@@ -23,7 +23,7 @@ import {
   reanchorSession,
   traceWordPosAt,
   vadStep
-} from "../chunk-CY2R2VPR.js";
+} from "../chunk-DYPMOPIW.js";
 import {
   buildNarrationScript,
   buildNarrationTimingJson,
@@ -33,18 +33,18 @@ import {
   wordIndexAtChar,
   wordIndexAtTime,
   wordPosAtExpectedSyllables
-} from "../chunk-X6DUONGT.js";
-import "../chunk-TUWMK62B.js";
-import "../chunk-5UYI3RJB.js";
-import "../chunk-W4O2TX5I.js";
-import "../chunk-5J4HKRJF.js";
-import "../chunk-R2YZTCLO.js";
-import "../chunk-AMIR72JP.js";
-import "../chunk-QE7TWGVT.js";
-import "../chunk-4X3JQXNM.js";
-import "../chunk-3E5F2XMR.js";
-import "../chunk-V543AI2F.js";
-import "../chunk-FVTQSNR7.js";
+} from "../chunk-7ARJZYQY.js";
+import "../chunk-PUS54YU6.js";
+import "../chunk-FDYDYL77.js";
+import "../chunk-C33GTPUZ.js";
+import "../chunk-BAOV476U.js";
+import "../chunk-ZQKZSJAX.js";
+import "../chunk-BCCXTMN5.js";
+import "../chunk-4VOD55SX.js";
+import "../chunk-XOFT65EX.js";
+import "../chunk-67L6WRJN.js";
+import "../chunk-QKPXHDLR.js";
+import "../chunk-XRW6P7IF.js";
 export {
   DEFAULT_ALIGN_CONFIG,
   DEFAULT_FEATURE_CONFIG,
@@ -79,4 +79,3 @@ export {
   wordIndexAtTime,
   wordPosAtExpectedSyllables
 };
-//# sourceMappingURL=index.js.map

package/dist/random/index.d.ts

@@ -14,7 +14,16 @@
 declare class SeededRandom {
     private state;
     constructor(seed: number);
-    /** Random float in [0, 1). */
+    /**
+     * Random float in [0, 1).
+     *
+     * The state increment wraps to 32 bits, as Mulberry32 specifies. Leaving it
+     * unwrapped (the shape of the widely-copied reference snippet) keeps the
+     * state as an ever-growing float: the bitwise ops below still coerce it
+     * mod 2^32, so the OUTPUT is identical — until the state passes 2^53 and
+     * `+= 0x6d2b79f5` stops being exact. From that point the low bits rot and
+     * the sequence silently drifts from Mulberry32 (measured: draw 4,917,758).
+     */
     next(): number;
     /** Random integer in [0, max). */
     nextInt(max: number): number;
@@ -37,7 +46,7 @@ declare class SeededRandom {
         item: T;
         weight: number;
     }[]): T | undefined;
-    /** Current internal state (for debugging / serialization). */
+    /** Current internal state as a uint32 (for debugging / serialization). */
     getState(): number;
     /** Create an independent sub-stream keyed by a modifier. */
     derive(modifier: string | number): SeededRandom;

package/dist/random/index.js

@@ -1,10 +1,9 @@
-import "../chunk-V543AI2F.js";
+import "../chunk-QKPXHDLR.js";
 import {
   SeededRandom,
   hashString
-} from "../chunk-FVTQSNR7.js";
+} from "../chunk-XRW6P7IF.js";
 export {
   SeededRandom,
   hashString
 };
-//# sourceMappingURL=index.js.map

package/dist/recommend/index.d.ts

@@ -1,4 +1,4 @@
-import { M as MarkdownBlockNode } from '../types-BwMPl2CB.js';
+import { M as MarkdownBlockNode } from '../types-CUNc9biN.js';
 
 /**
  * Block template recommendations.

package/dist/recommend/index.js

@@ -1,11 +1,10 @@
-import "../chunk-ZLQKNOZQ.js";
+import "../chunk-XWNNA3KE.js";
 import {
   profileBlockContents,
   recommendTemplatesForBlock
-} from "../chunk-5UYI3RJB.js";
-import "../chunk-AMIR72JP.js";
+} from "../chunk-FDYDYL77.js";
+import "../chunk-BCCXTMN5.js";
 export {
   profileBlockContents,
   recommendTemplatesForBlock
 };
-//# sourceMappingURL=index.js.map