@cueframe/kernel 0.0.1

package/dist/composition/audio.js

@@ -0,0 +1,63 @@
+import {
+  AMBIENCE_BED,
+  AMBIENCE_TRACK_ID,
+  DEFAULT_SFX_INTENSITY,
+  MUSIC_BED,
+  MUSIC_PACK_ENTRIES,
+  MUSIC_PACK_VERSION,
+  MUSIC_TRACK_ID,
+  ROLE_DEFAULT_GAIN_DB,
+  ROLE_HIERARCHY,
+  SFX_DENSITY,
+  SFX_TRACK_ID,
+  SPEECH_COLLISION,
+  assembleAudioPalette,
+  compositionHasVo,
+  detectMixHierarchyInversion,
+  detectNoAudioTrack,
+  effectiveClipGainDb,
+  getMusicPackEntry,
+  getSfxPackEntry,
+  musicPackR2Key,
+  orgSfxPalette,
+  pickSfx,
+  roleDefaultGainDb,
+  sfxByFamily,
+  sfxPackR2Key,
+  sfxTransients
+} from "../chunk-JMURQODM.js";
+import {
+  SFX_PACK_ENTRIES,
+  SFX_PACK_VERSION
+} from "../chunk-7PA7FGLD.js";
+import "../chunk-2ESYSVXG.js";
+export {
+  AMBIENCE_BED,
+  AMBIENCE_TRACK_ID,
+  DEFAULT_SFX_INTENSITY,
+  MUSIC_BED,
+  MUSIC_PACK_ENTRIES,
+  MUSIC_PACK_VERSION,
+  MUSIC_TRACK_ID,
+  ROLE_DEFAULT_GAIN_DB,
+  ROLE_HIERARCHY,
+  SFX_DENSITY,
+  SFX_PACK_ENTRIES,
+  SFX_PACK_VERSION,
+  SFX_TRACK_ID,
+  SPEECH_COLLISION,
+  assembleAudioPalette,
+  compositionHasVo,
+  detectMixHierarchyInversion,
+  detectNoAudioTrack,
+  effectiveClipGainDb,
+  getMusicPackEntry,
+  getSfxPackEntry,
+  musicPackR2Key,
+  orgSfxPalette,
+  pickSfx,
+  roleDefaultGainDb,
+  sfxByFamily,
+  sfxPackR2Key,
+  sfxTransients
+};

package/dist/composition/autozoom.d.ts

@@ -0,0 +1 @@
+export * from "../_members/composition/autozoom/index.js";

package/dist/composition/autozoom.js

@@ -0,0 +1,76 @@
+import "../chunk-2ESYSVXG.js";
+
+// ../composition/src/autozoom/index.ts
+var STYLE = {
+  subtle: { zoom: 0.8, prePad: 0.5, postPad: 1.2, minZoom: 1.2, mergeGap: 1 },
+  standard: { zoom: 0.67, prePad: 0.4, postPad: 1, minZoom: 1, mergeGap: 0.8 },
+  punchy: { zoom: 0.55, prePad: 0.3, postPad: 0.8, minZoom: 0.8, mergeGap: 0.6 }
+};
+var median = (xs) => {
+  const s = [...xs].sort((a, b) => a - b);
+  const m = Math.floor(s.length / 2);
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+};
+var neutral = (startSec, endSec) => ({
+  startSec,
+  endSec,
+  intent: "auto-zoom:neutral",
+  focus: { mode: "frame-center" },
+  zoom: 1
+});
+function tile(anchors, durationSec, t) {
+  if (durationSec <= 0 || anchors.length === 0) return [];
+  const sorted = [...anchors].sort((a, b) => a.t - b.t);
+  const groups = [];
+  let cur = [sorted[0]];
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i].t - sorted[i - 1].t <= t.mergeGap) cur.push(sorted[i]);
+    else {
+      groups.push(cur);
+      cur = [sorted[i]];
+    }
+  }
+  groups.push(cur);
+  const windows = groups.map((g) => ({
+    start: Math.max(0, g[0].t - t.prePad),
+    end: Math.min(durationSec, g[g.length - 1].t + t.postPad),
+    x: median(g.map((e) => e.x)),
+    y: median(g.map((e) => e.y))
+  })).filter((w) => w.end - w.start >= t.minZoom);
+  if (windows.length === 0) return [];
+  const merged = [windows[0]];
+  for (let i = 1; i < windows.length; i++) {
+    const prev = merged[merged.length - 1];
+    if (windows[i].start <= prev.end) prev.end = Math.max(prev.end, windows[i].end);
+    else merged.push(windows[i]);
+  }
+  const out = [];
+  let cursor = 0;
+  for (const w of merged) {
+    if (w.start > cursor) out.push(neutral(cursor, w.start));
+    out.push({
+      startSec: w.start,
+      endSec: w.end,
+      intent: "auto-zoom:punch-in",
+      focus: { mode: "point", x: w.x, y: w.y },
+      zoom: t.zoom
+    });
+    cursor = w.end;
+  }
+  if (cursor < durationSec) out.push(neutral(cursor, durationSec));
+  return out;
+}
+function autoZoom(points, durationSec, style = "standard") {
+  return tile(points, durationSec, STYLE[style]);
+}
+function autoZoomFromActivity(activity, durationSec, style = "standard", thresholds = {}) {
+  const minC = thresholds.minConcentration ?? 0.6;
+  const maxCh = thresholds.maxChangePct ?? 0.12;
+  const anchors = activity.filter((s) => s.concentration >= minC && s.changePct <= maxCh);
+  return tile(anchors, durationSec, STYLE[style]);
+}
+export {
+  STYLE,
+  autoZoom,
+  autoZoomFromActivity
+};

package/dist/composition/brand-kit.d.ts

@@ -0,0 +1 @@
+export * from "../_members/composition/brand-kit.js";

package/dist/composition/brand-kit.js

@@ -0,0 +1,34 @@
+import "../chunk-2ESYSVXG.js";
+
+// ../composition/src/brand-kit.ts
+var DEFAULT_BRAND_KIT = {
+  name: "CueFrame",
+  description: "AI-native video editor. Spend less time editing, more time creating stories that matter.",
+  tagline: "Your Story Deserves Better Than a Timeline",
+  colors: {
+    primary: "#7C3AED",
+    secondary: "#4F46E5",
+    accent: "#7C3AED",
+    background: "#121212",
+    text: "#ffffff"
+  },
+  extraColors: [
+    { hex: "#1a1a1a", label: "Surface", usage: "Cards, elevated backgrounds" },
+    { hex: "#262626", label: "Muted", usage: "Borders, subtle backgrounds" },
+    { hex: "#a3a3a3", label: "Muted Text", usage: "Secondary text, captions" }
+  ],
+  // Vendored families only (`VENDORED_FONT_FAMILIES`): the picker lists exactly
+  // those, and the render sandbox has no font egress, so a default outside the
+  // list is a value the user cannot re-select and a face that rasterizes as
+  // the generic fallback. The previous defaults ('DM Serif Display', 'Geist')
+  // were both.
+  headingFont: { fontFamily: "Instrument Serif", fontWeight: 400 },
+  bodyFont: { fontFamily: "Inter", fontWeight: 400 },
+  syncCaptions: false,
+  captionProfile: {},
+  customFonts: [],
+  voiceGuidelines: "Premium and sophisticated. Focus on storytelling over technical complexity. Approachable but confident. Emphasize the creative process, not the tool. Minimal, clear language."
+};
+export {
+  DEFAULT_BRAND_KIT
+};

package/dist/composition/brief.d.ts

@@ -0,0 +1 @@
+export * from "../_members/composition/brief/contract.js";

package/dist/composition/brief.js

@@ -0,0 +1,112 @@
+import "../chunk-2ESYSVXG.js";
+
+// ../composition/src/brief/contract.ts
+var BEAT_CONTIGUITY_TOLERANCE_S = 0.75;
+var BEAT_DURATION_TOLERANCE_S = 0.5;
+var BRIEF_DURATION_TOLERANCE_S = 1.5;
+var BEAT_MAX_LOSS_FRACTION = 0.5;
+function unionLength(spans) {
+  const sorted = [...spans].filter((s) => s.endSec > s.startSec).sort((a, b) => a.startSec - b.startSec);
+  let total = 0;
+  let cur = null;
+  for (const s of sorted) {
+    if (!cur || s.startSec > cur.endSec) {
+      if (cur) total += cur.endSec - cur.startSec;
+      cur = { startSec: s.startSec, endSec: s.endSec };
+    } else if (s.endSec > cur.endSec) {
+      cur.endSec = s.endSec;
+    }
+  }
+  if (cur) total += cur.endSec - cur.startSec;
+  return total;
+}
+function overlap(a, b) {
+  return Math.max(0, Math.min(a.endSec, b.endSec) - Math.max(a.startSec, b.startSec));
+}
+var s1 = (n) => n.toFixed(1);
+function planBriefViolations(plan, contract) {
+  if (contract.beats.length === 0) return [];
+  const errors = [];
+  for (const beat of contract.beats) {
+    if (!beat.graphic) continue;
+    const clipBeat = {
+      startSec: beat.startSec - contract.windowStartSec,
+      endSec: beat.endSec - contract.windowStartSec
+    };
+    const role = beat.graphic.role;
+    const sameRole = (plan.graphics ?? []).filter((g) => g.role === role);
+    const match = sameRole.find(
+      (g) => overlap(clipBeat, { startSec: g.atSec, endSec: g.atSec + g.durSec }) > 0
+    );
+    if (!match) {
+      const where = sameRole.length === 0 ? `your plan has NO '${role}' graphics request at all` : `your plan's '${role}' request(s) (${sameRole.map((g) => `${s1(g.atSec)}\u2013${s1(g.atSec + g.durSec)}s`).join(", ")}) never overlap the beat`;
+      errors.push(
+        `brief: beat "${beat.id}" (${s1(clipBeat.startSec)}\u2013${s1(clipBeat.endSec)}s clip-relative) MANDATES a '${role}' graphic \u2014 ${where}. The customer pinned this graphic; add a graphics entry { role: '${role}', atSec within ${s1(clipBeat.startSec)}\u2013${s1(clipBeat.endSec)}, durSec, copy, intent }` + (beat.graphic.items?.length ? ` with copy.items carrying VERBATIM: ${beat.graphic.items.map((i) => `"${i}"`).join(", ")}` : "") + `.`
+      );
+      continue;
+    }
+    const wanted = beat.graphic.items ?? [];
+    if (wanted.length > 0) {
+      const norm = (s) => s.trim().toLowerCase();
+      const have = new Set((match.copy?.items ?? []).map(norm));
+      const missing = wanted.filter((w) => !have.has(norm(w)));
+      if (missing.length > 0) {
+        errors.push(
+          `brief: beat "${beat.id}" \u2014 the '${role}' graphic "${match.id}" is planned but its copy.items drop the customer's mandated item(s): ${missing.map((i) => `"${i}"`).join(", ")}. These are the customer's words; carry each one verbatim in copy.items.`
+        );
+      }
+    }
+  }
+  const deletions = [
+    ...plan.framing.filter((f) => f.action === "trim").map((f) => ({
+      startSec: f.startSec,
+      endSec: f.endSec,
+      kind: "trim",
+      reason: f.intent ?? "(no reason given)"
+    })),
+    ...(plan.cuts ?? []).map((c) => ({
+      startSec: c.startSec,
+      endSec: c.endSec,
+      kind: "cut",
+      reason: c.reason ?? "(no reason given)"
+    }))
+  ];
+  if (deletions.length === 0) return errors;
+  for (const beat of contract.beats) {
+    const clipBeat = {
+      startSec: beat.startSec - contract.windowStartSec,
+      endSec: beat.endSec - contract.windowStartSec
+    };
+    const hits = deletions.map((d) => ({ d, lost: overlap(clipBeat, d) })).filter((h) => h.lost > 0);
+    const lost = unionLength(hits.map((h) => h.d).map((d) => ({
+      startSec: Math.max(d.startSec, clipBeat.startSec),
+      endSec: Math.min(d.endSec, clipBeat.endSec)
+    })));
+    const beatLen = Math.max(1e-6, clipBeat.endSec - clipBeat.startSec);
+    if (lost / beatLen <= BEAT_MAX_LOSS_FRACTION) continue;
+    const why = hits.map((h) => `${h.d.kind} "${h.d.reason}" (\u2212${s1(h.lost)}s)`).join("; ");
+    errors.push(
+      `brief: beat "${beat.id}" (${s1(beat.startSec)}\u2013${s1(beat.endSec)}s source, ${s1(beatLen)}s long) \u2014 your plan DELETES ${s1(lost)}s of it (${Math.round(lost / beatLen * 100)}%) via ${why}. The customer PINNED this beat and it would not survive. Trimming dead air inside a beat is fine; ERASING the beat is not \u2014 that is content, and the brief owns content. A span with nothing to track is NOT filler: use action:'keep' (SHOW as-is, no reframe).`
+    );
+  }
+  const deleted = unionLength(
+    deletions.map((d) => ({
+      startSec: Math.max(0, d.startSec),
+      endSec: Math.min(contract.targetDurationSec, d.endSec)
+    }))
+  );
+  const surviving = contract.targetDurationSec - deleted;
+  if (Math.abs(surviving - contract.targetDurationSec) > BRIEF_DURATION_TOLERANCE_S) {
+    errors.push(
+      `brief: durationSec contract \u2014 your plan leaves ${s1(surviving)}s but the brief pins ${s1(contract.targetDurationSec)}s (tolerance \xB1${BRIEF_DURATION_TOLERANCE_S}s). You deleted ${s1(deleted)}s. The pinned beats ARE the video \u2014 there is no filler to cut. Re-plan with action:'keep' instead of 'trim' for any span you cannot track.`
+    );
+  }
+  return errors;
+}
+export {
+  BEAT_CONTIGUITY_TOLERANCE_S,
+  BEAT_DURATION_TOLERANCE_S,
+  BEAT_MAX_LOSS_FRACTION,
+  BRIEF_DURATION_TOLERANCE_S,
+  planBriefViolations
+};

package/dist/composition/depth.d.ts

@@ -0,0 +1 @@
+export * from "../_members/composition/depth.js";

package/dist/composition/depth.js

@@ -0,0 +1,12 @@
+import "../chunk-2ESYSVXG.js";
+
+// ../composition/src/depth.ts
+function isBehindSubjectDepthSource(source) {
+  if (!source || typeof source !== "object") return false;
+  const kind = source.kind;
+  if (kind !== "overlay" && kind !== "alpha-layer") return false;
+  return source.zPlane === "behind-subject";
+}
+export {
+  isBehindSubjectDepthSource
+};

package/dist/composition/fixtures.d.ts

@@ -0,0 +1 @@
+export * from "../_members/composition/fixtures/index.js";

package/dist/composition/fixtures.js

@@ -0,0 +1,154 @@
+import "../chunk-2ESYSVXG.js";
+
+// ../composition/src/fixtures/index.ts
+var minimalComposition = {
+  v: 1,
+  format: { aspectRatio: "9:16", fps: 30, resolution: "fhd" },
+  tracks: [
+    {
+      id: "V1",
+      kind: "video",
+      contents: [
+        {
+          id: "clip-1",
+          startTime: 0,
+          duration: 10,
+          source: {
+            kind: "media",
+            mediaId: "kx0000000000000000000000"
+          }
+        }
+      ]
+    }
+  ]
+};
+var overlappingClips = {
+  v: 1,
+  format: { aspectRatio: "16:9", fps: 30 },
+  tracks: [
+    {
+      id: "V1",
+      kind: "video",
+      contents: [
+        {
+          id: "clip-1",
+          startTime: 0,
+          duration: 10,
+          source: {
+            kind: "media",
+            mediaId: "kx0000000000000000000000"
+          }
+        },
+        {
+          id: "clip-2",
+          startTime: 5,
+          duration: 10,
+          source: {
+            kind: "media",
+            mediaId: "kx1111111111111111111111"
+          }
+        }
+      ]
+    }
+  ]
+};
+var transitionWithoutPredecessor = {
+  v: 1,
+  format: { aspectRatio: "9:16", fps: 30 },
+  tracks: [
+    {
+      id: "V1",
+      kind: "video",
+      contents: [
+        {
+          id: "clip-1",
+          startTime: 0,
+          duration: 10,
+          source: {
+            kind: "media",
+            mediaId: "kx0000000000000000000000"
+          },
+          transitionIn: { type: "fade", duration: 1 }
+        }
+      ]
+    }
+  ]
+};
+var overlappingSceneMarkers = {
+  v: 1,
+  format: { aspectRatio: "9:16", fps: 30 },
+  tracks: [
+    {
+      id: "V1",
+      kind: "video",
+      contents: [
+        {
+          id: "clip-1",
+          startTime: 0,
+          duration: 30,
+          source: {
+            kind: "media",
+            mediaId: "kx0000000000000000000000"
+          }
+        }
+      ]
+    }
+  ],
+  markers: [
+    { id: "s1", kind: "scene", startTime: 0, endTime: 15, name: "intro" },
+    { id: "s2", kind: "scene", startTime: 10, endTime: 25, name: "middle" }
+  ]
+};
+var idCollision = {
+  v: 1,
+  format: { aspectRatio: "9:16", fps: 30 },
+  tracks: [
+    {
+      id: "V1",
+      kind: "video",
+      contents: [
+        {
+          id: "shared-id",
+          startTime: 0,
+          duration: 5,
+          source: {
+            kind: "media",
+            mediaId: "kx0000000000000000000000"
+          }
+        }
+      ]
+    }
+  ],
+  markers: [{ id: "shared-id", kind: "note", startTime: 2 }]
+};
+var clipWithExcludedRanges = {
+  v: 1,
+  format: { aspectRatio: "9:16", fps: 30 },
+  tracks: [
+    {
+      id: "V1",
+      kind: "video",
+      contents: [
+        {
+          id: "clip-1",
+          startTime: 0,
+          duration: 4,
+          source: {
+            kind: "media",
+            mediaId: "kx0000000000000000000000",
+            trim: { start: 0, end: 5 },
+            excludedRanges: [{ start: 1, end: 2, reason: "filler" }]
+          }
+        }
+      ]
+    }
+  ]
+};
+export {
+  clipWithExcludedRanges,
+  idCollision,
+  minimalComposition,
+  overlappingClips,
+  overlappingSceneMarkers,
+  transitionWithoutPredecessor
+};

package/dist/composition/fonts.d.ts

@@ -0,0 +1 @@
+export * from "../_members/composition/fonts.js";

package/dist/composition/fonts.js

@@ -0,0 +1,74 @@
+import "../chunk-2ESYSVXG.js";
+
+// ../composition/src/fonts.ts
+var VENDORED_FONT_FAMILIES = [
+  "Inter",
+  "Space Mono",
+  "Montserrat",
+  "Roboto",
+  "Poppins",
+  "Oswald",
+  "Playfair Display",
+  "Bebas Neue",
+  "Instrument Serif",
+  "National Park",
+  "Bricolage Grotesque",
+  "Schibsted Grotesk"
+];
+var ALIASED_FONT_FAMILIES = ["Georgia"];
+var AVAILABLE_LOWER = new Set(
+  [...VENDORED_FONT_FAMILIES, ...ALIASED_FONT_FAMILIES].map((f) => f.toLowerCase())
+);
+function isAvailableFontFamily(family) {
+  return AVAILABLE_LOWER.has(family.trim().replace(/^['"]|['"]$/g, "").toLowerCase());
+}
+function parseFontStack(value) {
+  return value.split(",").map((f) => f.trim().replace(/^['"]|['"]$/g, "").trim()).filter(Boolean);
+}
+var FONT_FAMILY_CSS = /font-family\s*:\s*((?:'[^']*'|"[^"]*"|[^;}"'])+?)\s*(?:;|}|"|$)/gi;
+var FONT_FAMILY_KEY = /fontfamily$/i;
+var MAX_NAMED = 6;
+function collectFontStacks(value, out) {
+  if (Array.isArray(value)) {
+    for (const v of value) collectFontStacks(v, out);
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof v === "string") {
+      if (FONT_FAMILY_KEY.test(k)) out.push(v);
+      for (const m of v.matchAll(FONT_FAMILY_CSS)) out.push(m[1]);
+      continue;
+    }
+    collectFontStacks(v, out);
+  }
+}
+function detectUnavailableFonts(value) {
+  const stacks = [];
+  collectFontStacks(value, stacks);
+  if (stacks.length === 0) return [];
+  const offenders = /* @__PURE__ */ new Map();
+  for (const raw of stacks) {
+    if (raw.includes("$brand:")) continue;
+    const families = parseFontStack(raw);
+    if (families.length === 0) continue;
+    if (families.some((f) => f.includes("${"))) continue;
+    if (families.some(isAvailableFontFamily)) continue;
+    offenders.set(families[0], (offenders.get(families[0]) ?? 0) + 1);
+  }
+  if (offenders.size === 0) return [];
+  const names = [...offenders.keys()];
+  const shown = names.slice(0, MAX_NAMED).map((n) => `\`${n}\``).join(", ");
+  const elided = names.length > MAX_NAMED ? ` (+${names.length - MAX_NAMED} more)` : "";
+  const requests = [...offenders.values()].reduce((a, b) => a + b, 0);
+  return [
+    `font_not_available \u2014 ${requests} font request${requests === 1 ? "" : "s"} name ${shown}${elided}, and nothing else in those stacks is vendored either. Only the vendored faces are guaranteed present in the render, so naming a family alone gets you the generic fallback (Liberation Sans) \u2014 no error, just the wrong typeface. Guaranteed: ${VENDORED_FONT_FAMILIES.join(", ")} (plus Georgia). Note that putting the family on a brand kit does NOT make it available \u2014 brand fonts resolve against the same vendored set.`
+  ];
+}
+export {
+  ALIASED_FONT_FAMILIES,
+  VENDORED_FONT_FAMILIES,
+  detectUnavailableFonts,
+  isAvailableFontFamily,
+  parseFontStack
+};

package/dist/composition/graphics-plan.d.ts

@@ -0,0 +1 @@
+export * from "../_members/composition/graphics-plan/index.js";