@cueframe/kernel 0.2.41 → 0.2.42

package/dist/composition/floors.js

@@ -0,0 +1,517 @@
+import {
+  getPrimitiveCatalogMeta
+} from "../chunk-7AZLFN26.js";
+import "../chunk-7PA7FGLD.js";
+import "../chunk-2ESYSVXG.js";
+
+// ../composition/src/floors/types.ts
+function floorAdvisoryLine(advisory) {
+  return `${advisory.rule} \u2014 ${advisory.detail}. Fix: ${advisory.fix}`;
+}
+
+// ../composition/src/floors/staticHold.ts
+var DEFAULT_FPS = 30;
+var CONTINUOUS_CARD_MOTION_VARS = [
+  "--cf-frame",
+  "--cf-t",
+  "--cf-progress",
+  "--cf-ease"
+];
+var EDGE_CARD_MOTION_VARS = ["--cf-enter", "--cf-exit"];
+var CARD_EDGE_RAMP_FRAMES = 18;
+function compositionFps(composition) {
+  return composition.format.fps ?? DEFAULT_FPS;
+}
+function keyframeMotionSeconds(clip) {
+  const channels = clip.animate;
+  if (!channels) return 0;
+  let widest = 0;
+  for (const keyframes of Object.values(channels)) {
+    if (!Array.isArray(keyframes) || keyframes.length < 2) continue;
+    const times = keyframes.map((k) => k.time);
+    widest = Math.max(widest, Math.max(...times) - Math.min(...times));
+  }
+  return Math.min(widest, clip.duration);
+}
+function cardText(source) {
+  return [source.html, ...Object.values(source.tokens ?? {})].join("\n");
+}
+function cardMotionSeconds(source, duration, fps) {
+  const text = cardText(source);
+  if (CONTINUOUS_CARD_MOTION_VARS.some((name) => text.includes(name))) return duration;
+  const ramp = CARD_EDGE_RAMP_FRAMES / fps;
+  let seconds = 0;
+  for (const name of EDGE_CARD_MOTION_VARS) if (text.includes(name)) seconds += ramp;
+  return Math.min(seconds, duration);
+}
+function overlayDesignedSeconds(primitiveId, fallbackFps) {
+  const meta = getPrimitiveCatalogMeta(primitiveId);
+  if (meta === void 0 || typeof meta.durationInFrames !== "number") return null;
+  const fps = meta.fps ?? fallbackFps;
+  if (!(fps > 0)) return null;
+  return meta.durationInFrames / fps;
+}
+function analyzeHold(clip, fps, trackKind) {
+  const source = clip.source;
+  const keyframed = keyframeMotionSeconds(clip);
+  if (source.kind === "card") {
+    const moving = Math.max(keyframed, cardMotionSeconds(source, clip.duration, fps));
+    return { staticSeconds: clip.duration - moving, medium: "card" };
+  }
+  if (source.kind === "overlay") {
+    const designedSeconds = overlayDesignedSeconds(source.primitiveId, fps);
+    if (designedSeconds === null) return null;
+    const moving = Math.max(keyframed, designedSeconds);
+    return {
+      staticSeconds: clip.duration - moving,
+      medium: "overlay",
+      designedSeconds,
+      primitiveId: source.primitiveId
+    };
+  }
+  if (source.kind === "media" && (clip.kind ?? trackKind) === "image") {
+    const kenBurnsed = source.kenBurns !== void 0 && source.kenBurns !== "none";
+    if (kenBurnsed) return null;
+    return { staticSeconds: clip.duration - keyframed, medium: "still image" };
+  }
+  return null;
+}
+
+// ../composition/src/floors/clips.ts
+function visualClips(composition) {
+  const out = [];
+  for (const track of composition.tracks) {
+    if (track.kind === "audio") continue;
+    if (track.enabled === false) continue;
+    for (const item of track.contents) {
+      if (!("source" in item)) continue;
+      out.push({ clip: item, trackKind: track.kind });
+    }
+  }
+  return out;
+}
+function audioClips(composition) {
+  const out = [];
+  for (const track of composition.tracks) {
+    if (track.kind !== "audio") continue;
+    if (track.enabled === false) continue;
+    for (const item of track.contents) {
+      if (!("source" in item)) continue;
+      out.push(item);
+    }
+  }
+  return out;
+}
+function isVideoClip(clip, trackKind) {
+  return clip.kind === "video" || trackKind === "video";
+}
+function isFullFrame(clip) {
+  const r = clip.region;
+  if (r === void 0) return true;
+  return r.x <= 0.02 && r.y <= 0.02 && r.w >= 0.98 && r.h >= 0.98;
+}
+
+// ../composition/src/floors/cohesionFloors.ts
+var STATIC_HOLD_MAX_SEC = 4;
+function detectStaticHolds(composition) {
+  const fps = compositionFps(composition);
+  const advisories = [];
+  for (const { clip, trackKind } of visualClips(composition)) {
+    const hold = analyzeHold(clip, fps, trackKind);
+    if (hold === null) continue;
+    if (hold.staticSeconds <= STATIC_HOLD_MAX_SEC) continue;
+    advisories.push({
+      criterion: "editorial",
+      rule: "static-hold",
+      clipId: clip.id,
+      detail: hold.medium === "overlay" ? `overlay clip "${clip.id}" mounts \`${hold.primitiveId}\`, whose animation is designed to run ${hold.designedSeconds?.toFixed(1)}s, and holds it for ${clip.duration.toFixed(1)}s \u2014 ${hold.staticSeconds.toFixed(1)}s of that is the finished animation sitting on its last frame (max ${STATIC_HOLD_MAX_SEC}s before it reads as a slide)` : `${hold.medium} clip "${clip.id}" holds a static frame for ${hold.staticSeconds.toFixed(1)}s of its ${clip.duration.toFixed(1)}s (max ${STATIC_HOLD_MAX_SEC}s before it reads as a slide)`,
+      fix: staticHoldFix(clip.id, hold.medium)
+    });
+  }
+  return advisories;
+}
+function staticHoldFix(clipId, medium) {
+  switch (medium) {
+    case "card":
+      return `give "${clipId}" motion the renderer can actually drive \u2014 the card motion runtime sets \`--cf-progress\`, \`--cf-ease\`, \`--cf-frame\` and \`--cf-t\` on every frame, so read one of them (\`transform: translateY(calc(var(--cf-ease) * -20px))\`) instead of a CSS \`@keyframes\`, which a frame-seeking render never advances \u2014 or split the beat so no static state outlives ${STATIC_HOLD_MAX_SEC}s`;
+    case "still image":
+      return `add motion (kenBurns) to "${clipId}" or shorten it below ${STATIC_HOLD_MAX_SEC}s`;
+    case "overlay":
+      return `shorten "${clipId}" to about its primitive's designed length, cut to a different beat when the animation lands, or choose a primitive built to run this long`;
+  }
+}
+function detectSilentNarration(composition) {
+  const voClip = audioClips(composition).find(
+    (c) => c.source.kind === "media" && c.source.audioRole === "vo"
+  );
+  if (voClip === void 0) return [];
+  const wordCount = (composition.captions?.segments ?? []).reduce(
+    (n, s) => n + s.words.length,
+    0
+  );
+  if (wordCount > 0) return [];
+  return [
+    {
+      criterion: "editorial",
+      rule: "caption-spine",
+      clipId: voClip.id,
+      detail: `narration clip "${voClip.id}" (audioRole: vo, ${voClip.duration.toFixed(1)}s) has no word-timed caption layer \u2014 the spoken words appear nowhere on screen`,
+      fix: `author the caption spine with setCaptions (segments of word timings matching the VO), or captions.fromTranscript if the narration was uploaded \u2014 the persistent word-synced line is the film's strongest continuity device`
+    }
+  ];
+}
+function detectCohesionAdvisories(composition) {
+  return [...detectStaticHolds(composition), ...detectSilentNarration(composition)];
+}
+
+// ../composition/src/floors/occlusionFloor.ts
+var OCCLUSION_MIN_COVERAGE = 0.9;
+var OCCLUSION_MIN_SEC = 3;
+var OCCLUSION_DECLARED_ALPHA_MIN_SEC = 10;
+var ALPHA_POLICY_ALLOWS_OPAQUE = "allows-opaque";
+var ALPHA_POLICY_REQUIRES_TRANSPARENCY = "requires-transparency";
+function declaredAlphaPolicy(source) {
+  const bag = source.params ?? source.props;
+  if (bag === null || typeof bag !== "object") return null;
+  const manifest = bag.componentManifest;
+  if (manifest === null || typeof manifest !== "object") return null;
+  const policy = manifest.alphaPolicy;
+  if (policy === ALPHA_POLICY_ALLOWS_OPAQUE || policy === ALPHA_POLICY_REQUIRES_TRANSPARENCY) {
+    return policy;
+  }
+  return null;
+}
+function layeredVisualClips(composition) {
+  const trackCount = composition.tracks.length;
+  const out = [];
+  for (const [trackIndex, track] of composition.tracks.entries()) {
+    if (track.kind === "audio") continue;
+    if (track.enabled === false) continue;
+    const layerIndex = trackCount - trackIndex;
+    for (const item of track.contents) {
+      if (!("source" in item)) continue;
+      out.push({ clip: item, layerIndex });
+    }
+  }
+  return out;
+}
+var NOT_OPAQUE_TOKENS = /\b(?:transparent|none|currentColor)\b/i;
+var ALPHA_LEGACY = /(?:rgba|hsla)\([^)]*,\s*(?:0|0?\.\d+)\s*\)/i;
+var ALPHA_SLASH = /(?:rgba?|hsla?)\([^)]*\/\s*(?:0|0?\.\d+|\d{1,2}%)\s*\)/i;
+var ALPHA_HEX = /#(?:[0-9a-f]{3}|[0-9a-f]{6})(?:[0-9a-f]|[0-9a-f]{2})(?![0-9a-f])/i;
+function isOpaquePaint(value) {
+  const v = value.trim();
+  if (v === "") return false;
+  if (NOT_OPAQUE_TOKENS.test(v)) return false;
+  if (ALPHA_LEGACY.test(v) || ALPHA_SLASH.test(v) || ALPHA_HEX.test(v)) return false;
+  if (/^#(?:[0-9a-f]{3}|[0-9a-f]{6})\b/i.test(v)) return true;
+  if (/^(?:rgba?|hsla?)\(/i.test(v)) return true;
+  if (/gradient\(/i.test(v)) return true;
+  return /^[a-z]+$/i.test(v);
+}
+function resolveCardVar(value, tokens) {
+  return value.replace(/var\(\s*--cf-([a-z0-9_-]+)\s*(?:,[^)]*)?\)/gi, (whole, key) => {
+    const resolved = tokens?.[key];
+    return resolved === void 0 ? whole : resolved;
+  });
+}
+var FULL_EXTENT = /^(?:100%|100vw|100vh|100dvw|100dvh|auto|inherit|unset|initial)$/i;
+var BACKGROUND_DECL = /(?<![\w-])background(?:-color|-image)?\s*:\s*([^;]+)/i;
+var INLINE_STYLE_ATTR = /style\s*=\s*(?:"([^"]*)"|'([^']*)')/gi;
+var ROOT_TAG = /<[a-z][^>]*>/i;
+function maskStyleElements(html) {
+  return html.replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, (block) => " ".repeat(block.length));
+}
+function inlineStyleBlocks(html) {
+  const root = ROOT_TAG.exec(html);
+  const rootStart = root === null ? -1 : root.index;
+  const rootEnd = root === null ? -1 : root.index + root[0].length;
+  const out = [];
+  for (const attr of html.matchAll(INLINE_STYLE_ATTR)) {
+    const at = attr.index ?? 0;
+    out.push({ block: attr[1] ?? attr[2] ?? "", isRoot: at >= rootStart && at < rootEnd });
+  }
+  return out;
+}
+function declaresPartialExtent(block) {
+  for (const m of block.matchAll(/\b(?:min-|max-)?(?:width|height)\s*:\s*([^;]+)/gi)) {
+    if (!FULL_EXTENT.test(m[1].trim())) return true;
+  }
+  return false;
+}
+function claimsWholeFrame(block) {
+  if (/\bwidth\s*:\s*100%/i.test(block) && /\bheight\s*:\s*100%/i.test(block)) return true;
+  if (!/\bposition\s*:\s*(?:absolute|fixed)/i.test(block)) return false;
+  if (/\binset\s*:\s*0(?:px)?\s*(?:;|$)/i.test(block)) return true;
+  return ["top", "right", "bottom", "left"].every(
+    (edge) => new RegExp(`\\b${edge}\\s*:\\s*0(?:px)?\\s*(?:;|$)`, "i").test(block)
+  );
+}
+function cardIsOpaque(source) {
+  for (const { block, isRoot } of inlineStyleBlocks(maskStyleElements(source.html))) {
+    const decl = BACKGROUND_DECL.exec(block);
+    if (decl === null) continue;
+    if (declaresPartialExtent(block)) return false;
+    if (!isRoot && !claimsWholeFrame(block)) return false;
+    return isOpaquePaint(resolveCardVar(decl[1], source.tokens));
+  }
+  return false;
+}
+function coversFrame(clip) {
+  if (!isFullFrame(clip)) return false;
+  if (clip.position !== void 0 && (clip.position.x !== 0 || clip.position.y !== 0)) return false;
+  if (clip.scale !== void 0 && clip.scale < 1) return false;
+  if (clip.rotation !== void 0 && clip.rotation !== 0) return false;
+  return true;
+}
+function isSolidThroughout(clip) {
+  if ((clip.opacity ?? 1) < 1) return false;
+  const channel = clip.animate?.opacity;
+  if (Array.isArray(channel) && channel.some((k) => k.value < 1)) return false;
+  return true;
+}
+function occluderEvidence(clip) {
+  if (!coversFrame(clip) || !isSolidThroughout(clip)) return null;
+  if (clip.source.kind === "card") return cardIsOpaque(clip.source) ? "proven" : null;
+  if (clip.source.kind === "effect") return null;
+  return declaredAlphaPolicy(clip.source) === ALPHA_POLICY_ALLOWS_OPAQUE ? "declared" : null;
+}
+function triggerSec(evidence) {
+  return evidence === "proven" ? OCCLUSION_MIN_SEC : OCCLUSION_DECLARED_ALPHA_MIN_SEC;
+}
+function isPaintedLane(clip) {
+  return clip.source.kind !== "effect";
+}
+function detectBackdropOcclusion(composition) {
+  const layered = layeredVisualClips(composition);
+  const advisories = [];
+  for (const { clip: occluder, layerIndex } of layered) {
+    const evidence = occluderEvidence(occluder);
+    if (evidence === null) continue;
+    const start = occluder.startTime;
+    const end = start + occluder.duration;
+    const buried = [];
+    for (const { clip: victim, layerIndex: victimLayer } of layered) {
+      if (victimLayer >= layerIndex) continue;
+      if (!isPaintedLane(victim)) continue;
+      const overlap = Math.min(end, victim.startTime + victim.duration) - Math.max(start, victim.startTime);
+      if (overlap <= 0) continue;
+      const coverage = overlap / victim.duration;
+      if (coverage < OCCLUSION_MIN_COVERAGE) continue;
+      buried.push({ id: victim.id, overlap, coverage });
+    }
+    const trigger = triggerSec(evidence);
+    if (!buried.some((b) => b.overlap >= trigger)) continue;
+    const worst = buried.reduce((a, b) => b.overlap > a.overlap ? b : a);
+    const names = buried.map((b) => `"${b.id}"`).join(", ");
+    const geometry = `sits on layer ${layerIndex} for ${occluder.duration.toFixed(1)}s`;
+    const victims = `${buried.length} clip(s) below it (${names}) \u2014 each covered for \u2265${Math.round(OCCLUSION_MIN_COVERAGE * 100)}% of its own life (worst: "${worst.id}", ${worst.overlap.toFixed(1)}s, ${Math.round(worst.coverage * 100)}%)`;
+    const convention = `In CueFrame track index 0 is the TOP layer, so a full-frame ${evidence === "proven" ? "background" : "component"} authored on the first track renders OVER the film, not behind it`;
+    const move = `move "${occluder.id}" to the LAST track \u2014 track index 0 renders ON TOP and the last track is the backdrop (layerIndex = trackCount - trackIndex). \`addTrack\` APPENDS, so add a track for the backdrop and put "${occluder.id}" on it; or, if it is meant to be a takeover rather than a world, shorten it so nothing below stays hidden past ${trigger}s`;
+    advisories.push({
+      criterion: "editorial",
+      rule: "backdrop-occlusion",
+      clipId: occluder.id,
+      detail: evidence === "proven" ? `opaque full-frame card "${occluder.id}" ${geometry} and hides ${victims}. ${convention}` : `full-frame component "${occluder.id}" ${geometry}, and its manifest declares alphaPolicy "${ALPHA_POLICY_ALLOWS_OPAQUE}" \u2014 its pixels are not on the wire, so that is PERMISSION to paint opaque, not proof that it does. If it does, it hides ${victims}. ${convention}`,
+      fix: evidence === "proven" ? move : `first check whether "${occluder.id}" actually paints a full-frame opaque plate. If it draws through, nothing is wrong here \u2014 declare "${ALPHA_POLICY_REQUIRES_TRANSPARENCY}" in its manifest and this stops firing. If it does paint one, ${move}`
+    });
+  }
+  return advisories;
+}
+
+// ../composition/src/floors/craftFloors.ts
+var SFX_VARIETY_MIN_HITS = 6;
+var SFX_VARIETY_MIN_RATIO = 0.4;
+var DEAD_HOLD_MAX_SEC = 8;
+var ROOM_CHANGE_MAX = 2;
+var MONTAGE_FAST_CLIP_SEC = 1.2;
+var MONTAGE_HARD_MIN_SEC = 0.4;
+var MONTAGE_MIN_RUN = 3;
+var MONTAGE_ADJACENCY_GAP_SEC = 0.5;
+function detectSfxSameSoundReuse(composition) {
+  const sfx = audioClips(composition).filter(
+    (c) => c.source.kind === "media" && c.source.audioRole === "sfx"
+  );
+  const hits = sfx.length;
+  if (hits < SFX_VARIETY_MIN_HITS) return [];
+  const distinct = new Set(
+    sfx.map((c) => c.source.kind === "media" ? c.source.mediaId : void 0).filter(
+      (id) => id !== void 0
+    )
+  ).size;
+  if (distinct === 0) return [];
+  const ratio = distinct / hits;
+  if (ratio >= SFX_VARIETY_MIN_RATIO) return [];
+  return [
+    {
+      criterion: "editorial",
+      rule: "sfx-same-sound-reuse",
+      detail: `${hits} SFX hits draw from only ${distinct} distinct sound(s) (variety ${ratio.toFixed(2)}, min ${SFX_VARIETY_MIN_RATIO}) \u2014 the same transient repeated reads as canned`,
+      fix: `widen the SFX palette so distinct sounds \xF7 hits \u2265 ${SFX_VARIETY_MIN_RATIO} (swap repeated hits for different impacts, ticks and whooshes)`
+    }
+  ];
+}
+function detectDeadHolds(composition) {
+  const fps = compositionFps(composition);
+  const advisories = [];
+  for (const { clip, trackKind } of visualClips(composition)) {
+    const hold = analyzeHold(clip, fps, trackKind);
+    if (hold === null) continue;
+    if (hold.staticSeconds <= DEAD_HOLD_MAX_SEC) continue;
+    advisories.push({
+      criterion: "editorial",
+      rule: "dead-hold",
+      clipId: clip.id,
+      detail: `${hold.medium} clip "${clip.id}" parks one visual state for ${hold.staticSeconds.toFixed(1)}s of its ${clip.duration.toFixed(1)}s (hard max ${DEAD_HOLD_MAX_SEC}s \u2014 past this a single beat is a parked slide no matter how it is dressed)`,
+      fix: `split "${clip.id}" into multiple beats so no single visual state outlives ${DEAD_HOLD_MAX_SEC}s (and give it motion below the ${STATIC_HOLD_MAX_SEC}s slide line)`
+    });
+  }
+  return advisories;
+}
+function isRoom(clip) {
+  if (!isPaintedLane(clip)) return false;
+  if (!coversFrame(clip)) return false;
+  const source = clip.source;
+  const declared = declaredAlphaPolicy(source);
+  if (declared === "requires-transparency") return false;
+  if (declared === "allows-opaque") return true;
+  if (source.kind === "card") return cardIsOpaque(source);
+  if (source.kind !== "overlay") return false;
+  const meta = getPrimitiveCatalogMeta(source.primitiveId);
+  return meta?.category === "backgrounds" || meta?.kind === "scene";
+}
+function paintsBeneath(candidate, all) {
+  const start = candidate.clip.startTime;
+  const end = start + candidate.clip.duration;
+  return all.some(({ clip, layerIndex }) => {
+    if (layerIndex >= candidate.layerIndex) return false;
+    if (!isPaintedLane(clip)) return false;
+    return Math.min(end, clip.startTime + clip.duration) - Math.max(start, clip.startTime) > 0;
+  });
+}
+function detectRoomChanges(composition) {
+  if (visualClips(composition).some(({ clip, trackKind }) => isVideoClip(clip, trackKind))) {
+    return [];
+  }
+  const layered = layeredVisualClips(composition);
+  const backdrops = layered.filter((entry) => isRoom(entry.clip) && !paintsBeneath(entry, layered)).map((entry) => entry.clip).sort((a, b) => a.startTime - b.startTime);
+  let rooms = 0;
+  let prevEnd = -Infinity;
+  for (const clip of backdrops) {
+    if (clip.startTime >= prevEnd - 1e-6) {
+      rooms += 1;
+      prevEnd = clip.startTime + clip.duration;
+    }
+  }
+  if (rooms <= ROOM_CHANGE_MAX) return [];
+  return [
+    {
+      criterion: "editorial",
+      rule: "room-changes",
+      detail: `${rooms} sequential full-frame backdrops in a graphics-led film (max ${ROOM_CHANGE_MAX}) \u2014 cutting between that many "rooms" reads as a slide deck, not one continuous space`,
+      fix: `hold fewer distinct full-frame worlds (\u2264${ROOM_CHANGE_MAX}) and move within them, or carry a persistent element across the cuts so the space feels continuous`
+    }
+  ];
+}
+function detectMontagePacing(composition) {
+  const advisories = [];
+  const clips = visualClips(composition).filter(({ clip, trackKind }) => isVideoClip(clip, trackKind)).map(({ clip }) => clip).sort((a, b) => a.startTime - b.startTime);
+  if (clips.length === 0) return [];
+  for (const clip of clips) {
+    if (clip.duration < MONTAGE_HARD_MIN_SEC) {
+      advisories.push({
+        criterion: "editorial",
+        rule: "montage-pacing",
+        clipId: clip.id,
+        detail: `video clip "${clip.id}" is ${clip.duration.toFixed(2)}s \u2014 under ${MONTAGE_HARD_MIN_SEC}s the eye cannot register it (subliminal cut)`,
+        fix: `extend "${clip.id}" to at least ${MONTAGE_HARD_MIN_SEC}s or drop it`
+      });
+    }
+  }
+  const runs = [];
+  let run = [];
+  let prevEnd = -Infinity;
+  for (const clip of clips) {
+    const adjacent = clip.startTime <= prevEnd + MONTAGE_ADJACENCY_GAP_SEC;
+    if (adjacent && run.length > 0) {
+      run.push(clip);
+    } else {
+      if (run.length > 0) runs.push(run);
+      run = [clip];
+    }
+    prevEnd = clip.startTime + clip.duration;
+  }
+  if (run.length > 0) runs.push(run);
+  for (const r of runs) {
+    if (r.length < MONTAGE_MIN_RUN) continue;
+    let firedFast = false;
+    for (let i = 0; i + MONTAGE_MIN_RUN <= r.length && !firedFast; i++) {
+      const window = r.slice(i, i + MONTAGE_MIN_RUN);
+      if (window.every((c) => c.duration < MONTAGE_FAST_CLIP_SEC)) {
+        firedFast = true;
+        advisories.push({
+          criterion: "editorial",
+          rule: "montage-pacing",
+          clipId: window[0].id,
+          detail: `${MONTAGE_MIN_RUN}+ consecutive video clips from "${window[0].id}" each under ${MONTAGE_FAST_CLIP_SEC}s \u2014 the cuts strobe faster than the eye can follow`,
+          fix: `lengthen the run around "${window[0].id}" so cuts land \u2265${MONTAGE_FAST_CLIP_SEC}s apart, or cut fewer of them`
+        });
+      }
+    }
+  }
+  return advisories;
+}
+function detectCraftAdvisories(composition) {
+  return [
+    ...detectSfxSameSoundReuse(composition),
+    ...detectDeadHolds(composition),
+    ...detectRoomChanges(composition),
+    ...detectMontagePacing(composition)
+  ];
+}
+
+// ../composition/src/floors/index.ts
+function detectFloorAdvisories(composition) {
+  return [
+    ...detectCohesionAdvisories(composition),
+    ...detectCraftAdvisories(composition),
+    ...detectBackdropOcclusion(composition)
+  ];
+}
+function floorAdvisoryLines(composition) {
+  return detectFloorAdvisories(composition).map(floorAdvisoryLine);
+}
+export {
+  CARD_EDGE_RAMP_FRAMES,
+  DEAD_HOLD_MAX_SEC,
+  MONTAGE_FAST_CLIP_SEC,
+  MONTAGE_HARD_MIN_SEC,
+  MONTAGE_MIN_RUN,
+  OCCLUSION_DECLARED_ALPHA_MIN_SEC,
+  OCCLUSION_MIN_COVERAGE,
+  OCCLUSION_MIN_SEC,
+  ROOM_CHANGE_MAX,
+  SFX_VARIETY_MIN_HITS,
+  SFX_VARIETY_MIN_RATIO,
+  STATIC_HOLD_MAX_SEC,
+  analyzeHold,
+  cardIsOpaque,
+  cardMotionSeconds,
+  compositionFps,
+  declaredAlphaPolicy,
+  detectBackdropOcclusion,
+  detectCohesionAdvisories,
+  detectCraftAdvisories,
+  detectDeadHolds,
+  detectFloorAdvisories,
+  detectMontagePacing,
+  detectRoomChanges,
+  detectSfxSameSoundReuse,
+  detectSilentNarration,
+  detectStaticHolds,
+  floorAdvisoryLine,
+  floorAdvisoryLines,
+  keyframeMotionSeconds,
+  layeredVisualClips,
+  overlayDesignedSeconds
+};

package/dist/composition/scene.js

@@ -130,7 +130,7 @@ import {
   selectSceneBakeScale,
   verifySceneVideoPresentationIndexV1,
   verifySealedSceneShotPlanV1
-} from "../chunk-XACXNDFL.js";
+} from "../chunk-CL5Y6V6K.js";
 import {
   MIB,
   SCENE_CONTEXT_GL_BUDGET_BYTES,

package/dist/composition-ops.js

@@ -1,10 +1,10 @@
 import {
   playableSpans
-} from "./chunk-L5XECASW.js";
+} from "./chunk-D72CKEOC.js";
 import "./chunk-QH3YI3ND.js";
+import "./chunk-IYZEK6WY.js";
 import "./chunk-QISFYLBB.js";
 import "./chunk-VZ7TYX6Z.js";
-import "./chunk-IYZEK6WY.js";
 import "./chunk-DENF4TPI.js";
 import {
   createHeadlessStore,
@@ -35,7 +35,7 @@ import "./chunk-7PA7FGLD.js";
 import {
   SCENE_SLOT_MEDIA_FORMATS,
   SceneShotSpecV2
-} from "./chunk-XACXNDFL.js";
+} from "./chunk-CL5Y6V6K.js";
 import "./chunk-2L7PYYJK.js";
 import {
   introducedCaptionFaceIssues

package/dist/core/render.js

@@ -66,21 +66,21 @@ import {
   sliceTranscriptWords,
   splitIntoSentences,
   validateComposition
-} from "../chunk-L5XECASW.js";
+} from "../chunk-D72CKEOC.js";
 import {
   buildEasedZooms,
   buildPannedCenters,
   easeOutCubic
 } from "../chunk-QH3YI3ND.js";
+import "../chunk-IYZEK6WY.js";
 import "../chunk-QISFYLBB.js";
 import "../chunk-VZ7TYX6Z.js";
-import "../chunk-IYZEK6WY.js";
 import "../chunk-DENF4TPI.js";
 import "../chunk-KYRDKK2D.js";
 import "../chunk-WREYUH2E.js";
 import "../chunk-QSWONRX2.js";
 import "../chunk-7PA7FGLD.js";
-import "../chunk-XACXNDFL.js";
+import "../chunk-CL5Y6V6K.js";
 import "../chunk-2L7PYYJK.js";
 import "../chunk-AVTEPAWI.js";
 import "../chunk-2ESYSVXG.js";

package/dist/core.js

@@ -10,17 +10,17 @@ import {
   ensureEven,
   extractCaptionWordsFromDoc,
   isEmphasized
-} from "./chunk-L5XECASW.js";
+} from "./chunk-D72CKEOC.js";
 import "./chunk-QH3YI3ND.js";
+import "./chunk-IYZEK6WY.js";
 import "./chunk-QISFYLBB.js";
 import "./chunk-VZ7TYX6Z.js";
-import "./chunk-IYZEK6WY.js";
 import "./chunk-DENF4TPI.js";
 import "./chunk-KYRDKK2D.js";
 import "./chunk-WREYUH2E.js";
 import "./chunk-QSWONRX2.js";
 import "./chunk-7PA7FGLD.js";
-import "./chunk-XACXNDFL.js";
+import "./chunk-CL5Y6V6K.js";
 import "./chunk-2L7PYYJK.js";
 import "./chunk-AVTEPAWI.js";
 import "./chunk-2ESYSVXG.js";

package/dist/mcp/adapter.js

@@ -2,7 +2,7 @@ import {
   querySchemaShape,
   serializeQuery,
   waitForJob
-} from "../chunk-JNOM4FW3.js";
+} from "../chunk-J53SGAWP.js";
 import {
   CURATED_TOOLS
 } from "../chunk-5YO4LAB7.js";
@@ -16,7 +16,7 @@ import {
   opById,
   safeParse,
   sniffImageMediaType
-} from "../chunk-GA6NRDK3.js";
+} from "../chunk-DQRJJ2YN.js";
 import "../chunk-2ESYSVXG.js";
 
 // ../mcp/src/adapter.ts

package/dist/mcp/core.js

@@ -18,7 +18,7 @@ import {
   text,
   textWithData,
   withMedia
-} from "../chunk-GA6NRDK3.js";
+} from "../chunk-DQRJJ2YN.js";
 import "../chunk-2ESYSVXG.js";
 export {
   __resetPreviewCache,

package/dist/mcp/scene-shot.d.ts

@@ -0,0 +1 @@
+export * from "../_members/mcp/sceneShot.js";

package/dist/mcp/scene-shot.js

@@ -0,0 +1,18 @@
+import {
+  SCENE_SHOT_LIMITS,
+  SCENE_SHOT_RESOURCE_DESCRIPTION,
+  SCENE_SHOT_RESOURCE_URI,
+  SCENE_SHOT_RULES,
+  sceneBrandTokens,
+  sceneShotContract
+} from "../chunk-P472GIBJ.js";
+import "../chunk-DQRJJ2YN.js";
+import "../chunk-2ESYSVXG.js";
+export {
+  SCENE_SHOT_LIMITS,
+  SCENE_SHOT_RESOURCE_DESCRIPTION,
+  SCENE_SHOT_RESOURCE_URI,
+  SCENE_SHOT_RULES,
+  sceneBrandTokens,
+  sceneShotContract
+};

package/dist/mcp/server.js

@@ -7,10 +7,11 @@ import {
   registerRawTools,
   registerSkillPrompts,
   titleCase
-} from "../chunk-BLDL2EKL.js";
-import "../chunk-JNOM4FW3.js";
+} from "../chunk-BUK4P6AW.js";
+import "../chunk-P472GIBJ.js";
+import "../chunk-J53SGAWP.js";
 import "../chunk-5YO4LAB7.js";
-import "../chunk-GA6NRDK3.js";
+import "../chunk-DQRJJ2YN.js";
 import "../chunk-2ESYSVXG.js";
 export {
   RAW_EXCLUDED_OPERATION_IDS,

package/dist/mcp.js

@@ -7,10 +7,11 @@ import {
   buildServer,
   registerCuratedTools,
   registerRawTools
-} from "./chunk-BLDL2EKL.js";
-import "./chunk-JNOM4FW3.js";
+} from "./chunk-BUK4P6AW.js";
+import "./chunk-P472GIBJ.js";
+import "./chunk-J53SGAWP.js";
 import "./chunk-5YO4LAB7.js";
-import "./chunk-GA6NRDK3.js";
+import "./chunk-DQRJJ2YN.js";
 import "./chunk-2ESYSVXG.js";
 export {
   API_URLS,