@bendyline/squisq 2.11.4 → 2.11.6

package/dist/{chunk-RXYKU6EX.js → chunk-Y4D6TDZT.js}

@@ -1,10 +1,156 @@
-import {
-  cloneAndFreezeData
-} from "./chunk-BAOV476U.js";
 import {
   isTransitionType
 } from "./chunk-4VOD55SX.js";
 
+// src/schemas/Viewport.ts
+var VIEWPORT_PRESETS = {
+  /** 16:9 landscape (default, 1080p) */
+  landscape: { width: 1920, height: 1080, name: "16:9 Landscape" },
+  /** 9:16 portrait (vertical video, stories) */
+  portrait: { width: 1080, height: 1920, name: "9:16 Portrait" },
+  /** 1:1 square (social media) */
+  square: { width: 1080, height: 1080, name: "1:1 Square" },
+  /** 4:3 standard */
+  standard: { width: 1440, height: 1080, name: "4:3 Standard" }
+};
+function getViewport(viewport) {
+  if (typeof viewport === "string") {
+    return VIEWPORT_PRESETS[viewport];
+  }
+  return viewport;
+}
+var REFERENCE_DIAGONAL = Math.sqrt(1920 * 1920 + 1080 * 1080);
+function calculateFontScale(viewport) {
+  const currentDiagonal = Math.sqrt(
+    viewport.width * viewport.width + viewport.height * viewport.height
+  );
+  return currentDiagonal / REFERENCE_DIAGONAL;
+}
+function getViewportOrientation(viewport) {
+  const ratio = viewport.width / viewport.height;
+  if (Math.abs(ratio - 1) < 0.05) return "square";
+  return ratio > 1 ? "landscape" : "portrait";
+}
+function getAspectRatioString(viewport) {
+  const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+  const divisor = gcd(viewport.width, viewport.height);
+  return `${viewport.width / divisor}:${viewport.height / divisor}`;
+}
+
+// src/schemas/LayoutStrategy.ts
+var LAYOUT_CONFIGS = {
+  landscape: {
+    primaryY: "35%",
+    secondaryY: "55%",
+    tertiaryY: "75%",
+    titleScale: 1,
+    bodyScale: 1,
+    columnLeftX: "25%",
+    columnRightX: "75%",
+    columnTopY: "35%",
+    columnBottomY: "65%",
+    stackColumns: false,
+    maxTextWidth: "80%",
+    horizontalPadding: "10%",
+    captionY: "85%",
+    captionScale: 1
+  },
+  portrait: {
+    // Content positioned higher for thumb-reach zone on mobile
+    primaryY: "25%",
+    secondaryY: "42%",
+    tertiaryY: "58%",
+    // Titles scale down for narrower width; body text scales up to fill vertical space
+    titleScale: 0.7,
+    bodyScale: 1.5,
+    // Stacked columns instead of side-by-side
+    columnLeftX: "50%",
+    columnRightX: "50%",
+    columnTopY: "30%",
+    columnBottomY: "55%",
+    stackColumns: true,
+    // Wider relative to viewport to use available space
+    maxTextWidth: "90%",
+    horizontalPadding: "5%",
+    captionY: "75%",
+    captionScale: 0.85
+  },
+  square: {
+    primaryY: "30%",
+    secondaryY: "50%",
+    tertiaryY: "70%",
+    titleScale: 0.85,
+    bodyScale: 0.9,
+    columnLeftX: "25%",
+    columnRightX: "75%",
+    columnTopY: "35%",
+    columnBottomY: "65%",
+    stackColumns: false,
+    maxTextWidth: "85%",
+    horizontalPadding: "7.5%",
+    captionY: "82%",
+    captionScale: 0.9
+  }
+};
+function getLayoutHints(orientation) {
+  return LAYOUT_CONFIGS[orientation];
+}
+function scaledFontSize(basePx, viewport, orientation, isTitle = false) {
+  const fontScale = calculateFontScale(viewport);
+  const layout = getLayoutHints(orientation);
+  const typeScale = isTitle ? layout.titleScale : layout.bodyScale;
+  return Math.round(basePx * fontScale * typeScale);
+}
+function getTwoColumnPositions(orientation) {
+  const layout = getLayoutHints(orientation);
+  if (layout.stackColumns) {
+    return {
+      left: { x: "50%", y: layout.columnTopY },
+      right: { x: "50%", y: layout.columnBottomY }
+    };
+  }
+  return {
+    left: { x: layout.columnLeftX, y: "50%" },
+    right: { x: layout.columnRightX, y: "50%" }
+  };
+}
+function getSafeTextBounds(orientation) {
+  const layout = getLayoutHints(orientation);
+  return {
+    left: layout.horizontalPadding,
+    right: layout.horizontalPadding,
+    top: "10%",
+    bottom: "10%"
+  };
+}
+
+// src/schemas/BlockTemplates.ts
+var DEFAULT_DOC_FONT = 'system-ui, -apple-system, "Segoe UI", Roboto, sans-serif';
+var DEFAULT_TITLE_FONT = 'Georgia, "Times New Roman", serif';
+function isTemplateBlock(block) {
+  return "template" in block && typeof block.template === "string";
+}
+function createTemplateContext(theme, blockIndex, totalBlocks, viewport = VIEWPORT_PRESETS.landscape) {
+  const orientation = getViewportOrientation(viewport);
+  const overrides = theme.renderStyle.layoutOverrides;
+  const baseLayout = getLayoutHints(orientation);
+  return {
+    theme,
+    blockIndex,
+    totalBlocks,
+    viewport,
+    fontScale: calculateFontScale(viewport),
+    orientation,
+    layout: overrides ? { ...baseLayout, ...overrides } : baseLayout
+  };
+}
+function scaledFontSize2(basePx, context, isTitle = false) {
+  return scaledFontSize(basePx, context.viewport, context.orientation, isTitle);
+}
+function isPersistentLayerTemplate(layer) {
+  return "template" in layer && typeof layer.template === "string";
+}
+
 // src/schemas/CustomTemplates.ts
 var LAYER_TYPES = /* @__PURE__ */ new Set([
   "image",
@@ -1177,6 +1323,52 @@ ${summary}${more}`);
   return result.theme;
 }
 
+// src/internal/immutable.ts
+function cloneData(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  const existing = seen.get(value);
+  if (existing !== void 0) return existing;
+  const tag = Object.prototype.toString.call(value);
+  if (tag === "[object ArrayBuffer]") {
+    const source2 = new Uint8Array(value);
+    const copy2 = new Uint8Array(source2.byteLength);
+    copy2.set(source2);
+    return copy2.buffer;
+  }
+  if (tag === "[object Date]") {
+    return new Date(Date.prototype.getTime.call(value));
+  }
+  if (Array.isArray(value)) {
+    const copy2 = [];
+    seen.set(value, copy2);
+    for (const item of value) copy2.push(cloneData(item, seen));
+    return copy2;
+  }
+  const source = value;
+  const copy = {};
+  seen.set(value, copy);
+  for (const key of Object.keys(source)) {
+    Object.defineProperty(copy, key, {
+      value: cloneData(source[key], seen),
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  return copy;
+}
+function deepFreezeData(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object" || seen.has(value)) return value;
+  seen.add(value);
+  for (const key of Object.keys(value)) {
+    deepFreezeData(value[key], seen);
+  }
+  return Object.freeze(value);
+}
+function cloneAndFreezeData(value) {
+  return deepFreezeData(cloneData(value));
+}
+
 // src/schemas/Theme.ts
 var FRONTMATTER_CUSTOM_THEMES_KEY = "squisq-custom-themes";
 function deepMerge(target, source) {
@@ -2772,6 +2964,21 @@ function matchFontFamily(name) {
 }
 
 export {
+  VIEWPORT_PRESETS,
+  getViewport,
+  calculateFontScale,
+  getViewportOrientation,
+  getAspectRatioString,
+  getLayoutHints,
+  scaledFontSize,
+  getTwoColumnPositions,
+  getSafeTextBounds,
+  DEFAULT_DOC_FONT,
+  DEFAULT_TITLE_FONT,
+  isTemplateBlock,
+  createTemplateContext,
+  scaledFontSize2,
+  isPersistentLayerTemplate,
   validateCustomTemplateDefinition,
   isCustomTemplateDefinition,
   FRONTMATTER_CUSTOM_TEMPLATES_KEY,
@@ -2806,6 +3013,8 @@ export {
   PAGE_ACCENT_STRATEGIES,
   validateTheme,
   assertTheme,
+  cloneData,
+  cloneAndFreezeData,
   FRONTMATTER_CUSTOM_THEMES_KEY,
   createTheme,
   LIGHT_SURFACE,

package/dist/chunk-ZP5F7LUH.js

@@ -0,0 +1,223 @@
+import {
+  SeededRandom
+} from "./chunk-XRW6P7IF.js";
+
+// src/generate/mediaMatching.ts
+var DEFAULT_STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "been",
+  "being",
+  "but",
+  "by",
+  "can",
+  "could",
+  "did",
+  "do",
+  "does",
+  "each",
+  "for",
+  "from",
+  "had",
+  "has",
+  "have",
+  "he",
+  "how",
+  "if",
+  "in",
+  "into",
+  "is",
+  "it",
+  "its",
+  "more",
+  "most",
+  "of",
+  "on",
+  "or",
+  "other",
+  "our",
+  "should",
+  "some",
+  "such",
+  "than",
+  "that",
+  "the",
+  "their",
+  "them",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "those",
+  "through",
+  "to",
+  "under",
+  "until",
+  "was",
+  "we",
+  "were",
+  "when",
+  "where",
+  "which",
+  "while",
+  "who",
+  "why",
+  "will",
+  "with",
+  "would",
+  "you",
+  "your"
+]);
+function extractKeywords(text, options = {}) {
+  if (!text) return [];
+  const stopwords = new Set(DEFAULT_STOPWORDS);
+  for (const word of options.stopwords ?? []) stopwords.add(word.toLowerCase());
+  const minimum = options.minWordLength ?? 3;
+  const words = text.toLowerCase().replace(/[.,;:!?\u2018\u2019'"()[\]{}\u2014\u2013-]/g, " ").replace(/\s+/g, " ").trim().split(" ").filter(Boolean);
+  const result = /* @__PURE__ */ new Set();
+  const eligible = (word) => word.length >= minimum && !stopwords.has(word);
+  for (const word of words) if (eligible(word)) result.add(word);
+  if (options.includeBigrams ?? true) {
+    for (let index = 0; index < words.length - 1; index += 1) {
+      if (eligible(words[index]) && eligible(words[index + 1])) {
+        result.add(`${words[index]}_${words[index + 1]}`);
+      }
+    }
+  }
+  return [...result];
+}
+function calculateKeywordAffinity(first, second) {
+  if (first.length === 0 || second.length === 0) return 0;
+  const firstSet = new Set(first);
+  const secondSet = new Set(second);
+  let overlap = 0;
+  for (const keyword of firstSet) {
+    if (secondSet.has(keyword)) overlap += keyword.includes("_") ? 2 : 1;
+  }
+  return Math.min(1, overlap / Math.min(firstSet.size, secondSet.size));
+}
+function matchByKeywordAffinity(mediaKeywords, targets, minimumScore = 0) {
+  const candidates = [];
+  for (let mediaIndex = 0; mediaIndex < mediaKeywords.length; mediaIndex += 1) {
+    for (const target of targets) {
+      const score = calculateKeywordAffinity(mediaKeywords[mediaIndex], target.keywords);
+      if (score >= minimumScore && score > 0)
+        candidates.push({ mediaIndex, targetKey: target.key, score });
+    }
+  }
+  candidates.sort((left, right) => right.score - left.score || left.mediaIndex - right.mediaIndex);
+  const assignments = [];
+  const assignedMedia = /* @__PURE__ */ new Set();
+  const targetCounts = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    if (assignedMedia.has(candidate.mediaIndex)) continue;
+    const target = targets.find((item) => item.key === candidate.targetKey);
+    const capacity = target?.capacity ?? 1;
+    if ((targetCounts.get(candidate.targetKey) ?? 0) >= capacity) continue;
+    assignments.push(candidate);
+    assignedMedia.add(candidate.mediaIndex);
+    targetCounts.set(candidate.targetKey, (targetCounts.get(candidate.targetKey) ?? 0) + 1);
+  }
+  return {
+    assignments,
+    unmatchedMedia: mediaKeywords.map((_, index) => index).filter((index) => !assignedMedia.has(index))
+  };
+}
+var CLIP_DEFAULTS = {
+  clipCount: 3,
+  minClipDuration: 8,
+  maxClipDuration: 20,
+  introSkipFraction: 0.1,
+  outroSkipFraction: 0.1,
+  seed: 42
+};
+function selectSafeZoneClips(source, options = {}) {
+  const settings = { ...CLIP_DEFAULTS, ...options };
+  if (source.duration <= 0 || settings.clipCount <= 0) return [];
+  const safeStart = source.duration * settings.introSkipFraction;
+  const safeEnd = source.duration * (1 - settings.outroSkipFraction);
+  const safeDuration = safeEnd - safeStart;
+  if (safeDuration < settings.minClipDuration) {
+    return [toClip(source, 0, Math.min(source.duration, settings.maxClipDuration))];
+  }
+  const count = Math.min(settings.clipCount, Math.floor(safeDuration / settings.minClipDuration));
+  const random = new SeededRandom(settings.seed);
+  const interval = safeDuration / count;
+  return Array.from({ length: count }, (_, index) => {
+    const intervalStart = safeStart + index * interval;
+    const intervalEnd = intervalStart + interval;
+    const requestedDuration = settings.minClipDuration + random.next() * (settings.maxClipDuration - settings.minClipDuration);
+    const clipDuration = Math.min(requestedDuration, interval, safeDuration);
+    const jitter = (random.next() - 0.5) * interval * 0.5;
+    const center = Math.max(
+      intervalStart + clipDuration / 2,
+      Math.min(intervalEnd - clipDuration / 2, (intervalStart + intervalEnd) / 2 + jitter)
+    );
+    const start = Math.max(safeStart, center - clipDuration / 2);
+    return toClip(source, start, Math.min(safeEnd, start + clipDuration));
+  });
+}
+function selectTranscriptClips(source, transcript, matchText, options = {}) {
+  const settings = { ...CLIP_DEFAULTS, ...options };
+  const safeStart = source.duration * settings.introSkipFraction;
+  const safeEnd = source.duration * (1 - settings.outroSkipFraction);
+  const matchKeywords = extractKeywords(matchText);
+  const ranked = transcript.filter((segment) => segment.startTime >= safeStart && segment.endTime <= safeEnd).map((segment) => ({
+    segment,
+    score: calculateKeywordAffinity(
+      matchKeywords,
+      segment.keywords ?? extractKeywords(segment.text)
+    )
+  })).filter(({ score }) => score > 0).sort((left, right) => right.score - left.score);
+  const selected = [];
+  for (const { segment } of ranked) {
+    if (selected.length >= settings.clipCount) break;
+    const center = (segment.startTime + segment.endTime) / 2;
+    if (selected.every(
+      (item) => Math.abs((item.startTime + item.endTime) / 2 - center) >= settings.minClipDuration
+    )) {
+      selected.push(segment);
+    }
+  }
+  const clips = selected.map((segment) => {
+    const center = (segment.startTime + segment.endTime) / 2;
+    const duration = Math.min(
+      settings.maxClipDuration,
+      Math.max(settings.minClipDuration, segment.endTime - segment.startTime + 4)
+    );
+    const start = Math.max(safeStart, center - duration / 2);
+    return toClip(source, start, Math.min(safeEnd, start + duration));
+  });
+  if (clips.length < settings.clipCount) {
+    clips.push(
+      ...selectSafeZoneClips(source, {
+        ...settings,
+        clipCount: settings.clipCount - clips.length,
+        seed: settings.seed + clips.length
+      })
+    );
+  }
+  return clips;
+}
+function toClip(source, start, end) {
+  return {
+    ...source,
+    clipStart: Math.round(start * 100) / 100,
+    clipEnd: Math.round(end * 100) / 100,
+    sourceDuration: source.duration
+  };
+}
+
+export {
+  extractKeywords,
+  calculateKeywordAffinity,
+  matchByKeywordAffinity,
+  selectSafeZoneClips,
+  selectTranscriptClips
+};

package/dist/doc/index.js

@@ -70,7 +70,8 @@ import {
   validateMarkdownDoc,
   validateMarkdownSource,
   writeDashboardLayoutsToFrontmatter
-} from "../chunk-NV7LNKS2.js";
+} from "../chunk-GRGLZF4A.js";
+import "../chunk-764WHWKM.js";
 import {
   ASCII_CHAR_H,
   ASCII_CHAR_W,
@@ -192,7 +193,7 @@ import {
   wrapWithPersistentLayers,
   writeCustomTemplatesToFrontmatter,
   writeCustomThemesToFrontmatter
-} from "../chunk-LI547QHN.js";
+} from "../chunk-WAGJK36Q.js";
 import {
   PATH_SHAPE_KINDS,
   anchorPoint,
@@ -229,26 +230,24 @@ import {
   parseAsciiTimelineWithStats,
   parseTree,
   parseWrappedFlowTimeline
-} from "../chunk-PJRVODWW.js";
+} from "../chunk-C3NAY5YP.js";
 import "../chunk-GAZKTT4R.js";
 import {
   DEFAULT_THEME,
   FRONTMATTER_CUSTOM_TEMPLATES_KEY,
   FRONTMATTER_CUSTOM_THEMES_KEY,
-  getAvailableThemes,
-  getThemeSummaries,
-  resolveTheme
-} from "../chunk-RXYKU6EX.js";
-import {
   VIEWPORT_PRESETS,
   createTemplateContext,
+  getAvailableThemes,
   getLayoutHints,
+  getThemeSummaries,
   getTwoColumnPositions,
   getViewport,
   getViewportOrientation,
   isTemplateBlock,
+  resolveTheme,
   scaledFontSize2 as scaledFontSize
-} from "../chunk-BAOV476U.js";
+} from "../chunk-Y4D6TDZT.js";
 import "../chunk-CW24CH7I.js";
 import {
   CONTAINER_TEMPLATES,
@@ -259,8 +258,7 @@ import {
 import "../chunk-7N4G32LG.js";
 import "../chunk-X7BNDUNI.js";
 import "../chunk-4VOD55SX.js";
-import "../chunk-XOFT65EX.js";
-import "../chunk-67L6WRJN.js";
+import "../chunk-GHOPHGOK.js";
 import "../chunk-XRW6P7IF.js";
 export {
   ASCII_CHAR_H,

package/dist/generate/index.d.ts

@@ -30,4 +30,64 @@ interface MapOptions {
  */
 declare function mapElementToBlock(element: ExtractedElement, options: MapOptions): TemplateBlock;
 
-export { ExtractedElement, type MapOptions, mapElementToBlock };
+/**
+ * Generic Media Matching and Clip Selection
+ *
+ * Provides domain-neutral keyword affinity, greedy section matching, and
+ * safe-zone/transcript-aware video clip selection. Host applications supply
+ * their own editorial metadata and policy before or after these primitives.
+ */
+interface KeywordExtractionOptions {
+    stopwords?: Iterable<string>;
+    minWordLength?: number;
+    includeBigrams?: boolean;
+}
+declare function extractKeywords(text: string, options?: KeywordExtractionOptions): string[];
+declare function calculateKeywordAffinity(first: readonly string[], second: readonly string[]): number;
+interface AffinityTarget<Key extends string = string> {
+    key: Key;
+    keywords: readonly string[];
+    capacity?: number;
+}
+interface AffinityAssignment<Key extends string = string> {
+    mediaIndex: number;
+    targetKey: Key;
+    score: number;
+}
+interface AffinityMatchResult<Key extends string = string> {
+    assignments: AffinityAssignment<Key>[];
+    unmatchedMedia: number[];
+}
+/** Greedily assign each media item once to the highest-affinity target. */
+declare function matchByKeywordAffinity<Key extends string = string>(mediaKeywords: ReadonlyArray<readonly string[]>, targets: ReadonlyArray<AffinityTarget<Key>>, minimumScore?: number): AffinityMatchResult<Key>;
+interface ClipSource {
+    src: string;
+    duration: number;
+    posterSrc?: string;
+    alt?: string;
+    credit?: string;
+    license?: string;
+}
+interface SelectedClip extends ClipSource {
+    clipStart: number;
+    clipEnd: number;
+    sourceDuration: number;
+}
+interface ClipSelectionOptions {
+    clipCount?: number;
+    minClipDuration?: number;
+    maxClipDuration?: number;
+    introSkipFraction?: number;
+    outroSkipFraction?: number;
+    seed?: number;
+}
+declare function selectSafeZoneClips(source: ClipSource, options?: ClipSelectionOptions): SelectedClip[];
+interface TranscriptSegmentSource {
+    startTime: number;
+    endTime: number;
+    text: string;
+    keywords?: readonly string[];
+}
+declare function selectTranscriptClips(source: ClipSource, transcript: ReadonlyArray<TranscriptSegmentSource>, matchText: string, options?: ClipSelectionOptions): SelectedClip[];
+
+export { type AffinityAssignment, type AffinityMatchResult, type AffinityTarget, type ClipSelectionOptions, type ClipSource, ExtractedElement, type KeywordExtractionOptions, type MapOptions, type SelectedClip, type TranscriptSegmentSource, calculateKeywordAffinity, extractKeywords, mapElementToBlock, matchByKeywordAffinity, selectSafeZoneClips, selectTranscriptClips };

package/dist/generate/index.js

@@ -1,10 +1,23 @@
+import {
+  calculateKeywordAffinity,
+  extractKeywords,
+  matchByKeywordAffinity,
+  selectSafeZoneClips,
+  selectTranscriptClips
+} from "../chunk-ZP5F7LUH.js";
 import {
   extractContent,
   mapElementToBlock,
   stripMarkdown
-} from "../chunk-NKNMGIIN.js";
+} from "../chunk-SVN7T6BK.js";
+import "../chunk-XRW6P7IF.js";
 export {
+  calculateKeywordAffinity,
   extractContent,
+  extractKeywords,
   mapElementToBlock,
+  matchByKeywordAffinity,
+  selectSafeZoneClips,
+  selectTranscriptClips,
   stripMarkdown
 };

package/dist/index.d.ts

@@ -12,11 +12,11 @@ export { LocalForageAdapter, LocalForageAdapterOptions, LocalStorageAdapter, Mem
 export { C as ContentContainer, a as ContentEntry, M as MemoryContentContainer, f as findDocumentPath } from './ContentContainer-B2w9sUoL.js';
 export { DEFAULT_INTERACTIVE_RESOURCE_POLICY, DEFAULT_RESOURCE_MAX_BYTES, DEFAULT_RESOURCE_TIMEOUT_MS, DEFAULT_WRAP_WIDTH, FetchResourceBytesOptions, FetchedResource, HtmlPolicy, LOCAL_ONLY_RESOURCE_POLICY, MARKDOWN_SOURCE_TRANSFORMS, MarkdownSourceEdit, MarkdownSourceTransform, MarkdownSourceTransformId, MarkdownSourceTransformOptions, MarkdownSourceTransformResult, MarkdownWrapState, ResourcePolicy, ResourcePolicyError, SanitizeUrlOptions, TrailingAnnotationMatch, UrlKind, applyMarkdownSourceTransform, cleanupMarkdownSource, countNodes, createDocument, detectMarkdownWrapState, extractPlainText, fetchResourceBytes, findNodesByType, formatBlockScalar, formatFrontmatterValue, formatFrontmatterYaml, fromMdast, getChildren, inferDocumentTitle, isResourceUrlAllowed, matchTrailingPandocAttr, matchTrailingTemplateAnnotation, needsQuoting, parseFrontmatter, parseHtmlToNodes, parseMarkdown, parsePandocAttrTokens, plainTextFromInlineHtml, quoteAttrValue, readFrontmatterThemeId, sanitizeHtmlNodes, sanitizeUrl, serializePandocAttributes, setFrontmatterValues, splitFrontmatterBlock, splitKeyValueToken, stringifyHtmlNodes, stringifyMarkdown, toMdast, tokenizeAttrTokens, unquoteAttrValue, unwrapMarkdownSource, walkMarkdownTree, wrapMarkdownSource } from './markdown/index.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-Ckqpu33y.js';
-export { DEFAULT_WORDS_PER_SECOND, NarrationTimeEstimate, NarrationTimeOptions, ReadingTimeEstimate, ReadingTimeOptions, calculatePrefixDuration, countSpokenWords, estimateNarrationDuration, estimateNarrationTime, estimateReadingTime, estimateSpokenWordCount, estimateTimeFromText } from './timing/index.js';
+export { BuildCaptionTrackOptions, CaptionSegmentSource, DEFAULT_WORDS_PER_SECOND, NarrationTimeEstimate, NarrationTimeOptions, ReadingTimeEstimate, ReadingTimeOptions, buildCaptionTrack, calculatePrefixDuration, countSpokenWords, estimateNarrationDuration, estimateNarrationTime, estimateReadingTime, estimateSpokenWordCount, estimateTimeFromText } from './timing/index.js';
 export { SeededRandom, hashString } from './random/index.js';
 export { C as ComparisonData, D as DateData, a as DefinitionData, E as ExtractedElement, b as ExtractionOptions, c as ExtractionResult, d as ExtractionType, F as FactData, I as ImpactLineData, L as ListData, Q as QuoteData, S as StatData, e as extractContent, s as stripMarkdown } from './contentExtractor-BNfVJV2U.js';
-export { MapOptions, mapElementToBlock } from './generate/index.js';
-export { AnalyzedBlock, BlockImage, DEFAULT_TRANSFORM_STYLE_ID, TransformImage, TransformOptions, TransformResult, TransformStyleConfig, TransformStyleId, TransformStyleInput, TransformStyleRegistry, TransformStyleSummary, analyzeBlocks, applyTransform, createTransformStyleRegistry, extractDocImages, getTransformStyleIds, getTransformStyleSummaries, resolveTransformStyle } from './transform/index.js';
+export { AffinityAssignment, AffinityMatchResult, AffinityTarget, ClipSelectionOptions, ClipSource, KeywordExtractionOptions, MapOptions, SelectedClip, TranscriptSegmentSource, calculateKeywordAffinity, extractKeywords, mapElementToBlock, matchByKeywordAffinity, selectSafeZoneClips, selectTranscriptClips } from './generate/index.js';
+export { AnalyzedBlock, BlockImage, DEFAULT_TRANSFORM_STYLE_ID, NarratedSegmentInput, NarratedSegmentResult, NarratedSegmentTransformOptions, NarratedSegmentVideo, TransformImage, TransformOptions, TransformResult, TransformStyleConfig, TransformStyleId, TransformStyleInput, TransformStyleRegistry, TransformStyleSummary, allocateTiming, analyzeBlocks, applyTransform, createTransformStyleRegistry, extractDocImages, getTransformStyleIds, getTransformStyleSummaries, resolveTransformStyle, transformNarratedSegment } from './transform/index.js';
 export { C as CoalesceOptions, P as PrunePolicy, R as RevertFailureReason, a as RevertOptions, b as RevertResult, S as SaveVersionOptions, c as SaveVersionResult, V as Version } from './types-8QjefM9J.js';
 export { DATA_BACKUP_PREFIX, DocumentVersionManager, DocumentVersionManagerOptions, VERSIONS_PREFIX, VERSION_TIMESTAMP_PATTERN, buildDataBackupPath, buildVersionPath, coalesceVersions, formatVersionTimestamp, getDocBasename, listVersions, parseVersionPath, parseVersionTimestamp, pruneVersions, readVersion, revertToVersion, saveVersion } from './versions/index.js';
 export { BuildJsonFormTokensOptions, ControlKind, InferSchemaOptions, JsonFormValidationError, JsonFormValidator, SquisqAnnotatedSchema, SquisqHints, SquisqWhen, appendPointer, arrayItemKind, buildJsonFormTokens, chooseControl, escapePointerSegment, evaluateWhen, getByPointer, inferSchema, isSafeConditionRegex, pointerSegments, primaryType, resolveFlag, resolveJsonFormTheme, resolveRef, setByPointer, toPointer } from './jsonForm/index.js';
@@ -26,5 +26,6 @@ export { IconSuggestion, canonicalIconToken, iconGlyph, looksLikeIconToken, reso
 export { BlockContentProfile, RecommendationResult, profileBlockContents, recommendTemplatesForBlock } from './recommend/index.js';
 export { AdvanceCoverage, AlignConfig, AlignInput, BandpassState, BuildAdvanceTimingOptions, BuildNarrationTimingOptions, BuildScriptOptions, DEFAULT_ALIGN_CONFIG, DEFAULT_FEATURE_CONFIG, DEFAULT_NUCLEI_CONFIG, DEFAULT_PACING_CONFIG, DEFAULT_VAD_CONFIG, EMPTY_ADVANCE_LOG, FeatureConfig, FeatureState, FrameFeatures, NarrationAlignment, NarrationBlockRange, NarrationScript, NarrationSessionConfig, NarrationSessionState, NarrationTimingBlock, NarrationTimingJsonV3, NarrationTimingMethod, NarrationTrace, NucleiConfig, NucleiState, PacingConfig, PacingState, PacingTick, ScriptBlockRange, ScriptToken, SlideAdvance, SlideAdvanceLog, TraceSample, VadConfig, VadState, WordTiming, advanceCoverage, alignNarration, bandpassRun, buildAdvanceTimingJson, buildNarrationScript, buildNarrationTimingJson, createBandpass, createFeatureState, createNarrationSession, createNucleiState, createPacingState, createVadState, detectSyllableOnsets, downsampleTrace, estimateSyllables, expectedSyllablesAt, extractFrameFeatures, featureStep, narrationSessionStep, nucleiStep, pacingStep, parseNarrationTimingJson, reanchorPacing, reanchorSession, recordSlideShown, traceWordPosAt, vadStep, wordIndexAtChar, wordIndexAtTime, wordPosAtExpectedSyllables } from './narration/index.js';
 export { FenceRenderContext, FenceRenderer, FenceRendererMap, fenceRendererLangs } from './fence/index.js';
-export { BlankProtectedSpansOptions, BlankedText, DEFAULT_PROOF_SETTINGS, JoinedSegments, LINT_KIND_CATEGORIES, PROOF_DIALECTS, PROOF_FRONTMATTER_KEYS, PROOF_JOIN_SEPARATOR, ProofCategory, ProofDialect, ProofFinding, ProofRange, ProofSuggestion, ProofSuggestionKind, ProofingSettings, SegmentSpan, blankProtectedSpans, buildJoinedText, categorizeLintKind, dropMaskedFindings, formatProofDictionary, mapJoinedSpanToSegment, parseProofDictionary, readProofingSettings, resolveProofDialect } from './proof/index.js';
+export { P as PROOF_DIALECTS, a as ProofCategory, b as ProofDialect, c as ProofFinding, d as ProofRange, e as ProofSuggestion, f as ProofSuggestionKind } from './types-BQWu0gzi.js';
+export { BlankProtectedSpansOptions, BlankedText, DEFAULT_PROOF_SETTINGS, JoinedSegments, LINT_KIND_CATEGORIES, PROOF_FRONTMATTER_KEYS, PROOF_JOIN_SEPARATOR, ProofingSettings, SegmentSpan, blankProtectedSpans, buildJoinedText, categorizeLintKind, dropMaskedFindings, formatProofDictionary, mapJoinedSpanToSegment, parseProofDictionary, readProofingSettings, resolveProofDialect } from './proof/index.js';
 import './viewState-lTZS-hP_.js';