@cueframe/kernel 0.0.1

package/dist/nle-export.d.ts

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

package/dist/nle-export.js

@@ -0,0 +1,313 @@
+import "./chunk-G3PBH53P.js";
+import {
+  getPrimitiveText
+} from "./chunk-MC5DLSEV.js";
+import "./chunk-H5LMJKZU.js";
+import "./chunk-FUWJOVVK.js";
+import "./chunk-UEI3NLNK.js";
+import "./chunk-GULDS3VE.js";
+import "./chunk-7DHP4ESU.js";
+import "./chunk-MFHXCHRI.js";
+import "./chunk-NDKERSXY.js";
+import "./chunk-P43IE4WB.js";
+import "./chunk-6QJ3V3VS.js";
+import "./chunk-JD77Y2WM.js";
+import "./chunk-EAUSEGB7.js";
+import "./chunk-WZTTZHNR.js";
+import "./chunk-DLF4WVSE.js";
+import "./chunk-U4V4FZGE.js";
+import "./chunk-AWT3P5ZN.js";
+import "./chunk-QGAWDLYX.js";
+import "./chunk-MVEE6HEC.js";
+import "./chunk-ZSZABOE5.js";
+import "./chunk-BDMTUEEZ.js";
+import "./chunk-EMGFZ3PR.js";
+import "./chunk-S3P5BFFL.js";
+import "./chunk-ZFEXATWN.js";
+import "./chunk-N67PDTKQ.js";
+import "./chunk-DSNG6WLU.js";
+import "./chunk-YA3OR2KK.js";
+import "./chunk-CX2IIQ4R.js";
+import "./chunk-5I7VDCAC.js";
+import "./chunk-JF4JJAFP.js";
+import "./chunk-6CMVBTTP.js";
+import "./chunk-QH3YI3ND.js";
+import "./chunk-TWQOKKAF.js";
+import "./chunk-JRQVPFLF.js";
+import "./chunk-JMURQODM.js";
+import "./chunk-7PA7FGLD.js";
+import "./chunk-KYRDKK2D.js";
+import "./chunk-DENF4TPI.js";
+import "./chunk-WREYUH2E.js";
+import "./chunk-37NJ27UU.js";
+import "./chunk-2ESYSVXG.js";
+
+// ../nle-export/src/srt.ts
+function formatMs(totalMs) {
+  const ms = Math.max(0, Math.round(totalMs));
+  const h = Math.floor(ms / 36e5);
+  const m = Math.floor(ms % 36e5 / 6e4);
+  const s = Math.floor(ms % 6e4 / 1e3);
+  const msPart = ms % 1e3;
+  const pad = (n, w = 2) => String(n).padStart(w, "0");
+  return `${pad(h)}:${pad(m)}:${pad(s)},${pad(msPart, 3)}`;
+}
+function generateSrt(input) {
+  const { spine, assets, transcriptsBySourceId, sequence } = input;
+  const seqFps = sequence.fpsNum / sequence.fpsDen;
+  const assetById = new Map(assets.map((a) => [a.id, a]));
+  const cues = [];
+  for (const item of spine) {
+    const asset = assetById.get(item.assetId);
+    if (!asset) continue;
+    const transcript = transcriptsBySourceId[asset.sourceId];
+    if (!transcript?.length) continue;
+    const assetFps = asset.fpsNum / asset.fpsDen;
+    const sourceInSec = asset.originInFrames / assetFps;
+    const sourceOutSec = asset.originOutFrames / assetFps;
+    const timelineOffsetSec = item.timelineStartFrames / seqFps;
+    for (const cue of transcript) {
+      if (cue.endSec <= sourceInSec || cue.startSec >= sourceOutSec) continue;
+      const clampStart = Math.max(cue.startSec, sourceInSec);
+      const clampEnd = Math.min(cue.endSec, sourceOutSec);
+      cues.push({
+        startMs: (clampStart - sourceInSec + timelineOffsetSec) * 1e3,
+        endMs: (clampEnd - sourceInSec + timelineOffsetSec) * 1e3,
+        text: cue.text
+      });
+    }
+  }
+  cues.sort((a, b) => a.startMs - b.startMs);
+  if (cues.length === 0) return "";
+  return cues.map(
+    (c, i) => `${i + 1}
+${formatMs(c.startMs)} --> ${formatMs(c.endMs)}
+${c.text}
+`
+  ).join("\n");
+}
+
+// ../nle-export/src/compact-timeline.ts
+function compactTimeline(clips, deletedRanges) {
+  const byClip = /* @__PURE__ */ new Map();
+  for (const r of deletedRanges) {
+    if (!byClip.has(r.clipId)) byClip.set(r.clipId, []);
+    byClip.get(r.clipId).push(r);
+  }
+  const survivors = [];
+  const sortedClips = [...clips].sort((a, b) => a.timelineStart - b.timelineStart);
+  for (const clip of sortedClips) {
+    const clipDuration = clip.sourceOut - clip.sourceIn;
+    const ranges = (byClip.get(clip.id) ?? []).map((r) => ({
+      start: Math.max(0, Math.min(r.startSec, clipDuration)),
+      end: Math.max(0, Math.min(r.endSec, clipDuration))
+    })).filter((r) => r.end > r.start).sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const r of ranges) {
+      const last = merged[merged.length - 1];
+      if (last && r.start <= last.end) last.end = Math.max(last.end, r.end);
+      else merged.push({ ...r });
+    }
+    const keep = [];
+    let cursor = 0;
+    for (const r of merged) {
+      if (r.start > cursor) keep.push({ start: cursor, end: r.start });
+      cursor = r.end;
+    }
+    if (cursor < clipDuration) keep.push({ start: cursor, end: clipDuration });
+    const anySplit = merged.length > 0;
+    keep.forEach((seg, idx) => {
+      survivors.push({
+        id: anySplit ? `${clip.id}__${idx}` : clip.id,
+        originalClipId: anySplit ? clip.id : void 0,
+        poolItemId: clip.poolItemId,
+        sourceIn: clip.sourceIn + seg.start,
+        sourceOut: clip.sourceIn + seg.end,
+        transitionIn: clip.transitionIn,
+        transitionDuration: clip.transitionDuration,
+        durationSec: seg.end - seg.start
+      });
+    });
+  }
+  let tlCursor = 0;
+  return survivors.map((s) => {
+    const timelineStart = tlCursor;
+    const timelineEnd = tlCursor + s.durationSec;
+    tlCursor = timelineEnd;
+    const { durationSec: _d, ...rest } = s;
+    const result = {
+      id: rest.id,
+      poolItemId: rest.poolItemId,
+      sourceIn: rest.sourceIn,
+      sourceOut: rest.sourceOut,
+      timelineStart,
+      timelineEnd
+    };
+    if (rest.originalClipId !== void 0) result.originalClipId = rest.originalClipId;
+    if (rest.transitionIn !== void 0) result.transitionIn = rest.transitionIn;
+    if (rest.transitionDuration !== void 0) result.transitionDuration = rest.transitionDuration;
+    return result;
+  });
+}
+
+// ../nle-export/src/types.ts
+var CompositionValidationError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "CompositionValidationError";
+  }
+};
+
+// ../nle-export/src/composition-to-input.ts
+var EPSILON = 1e-6;
+function sequenceRational(fps) {
+  if (Math.abs(fps - 29.97) < 0.01) return { fpsNum: 3e4, fpsDen: 1001 };
+  if (Math.abs(fps - 23.976) < 0.01) return { fpsNum: 24e3, fpsDen: 1001 };
+  if (Math.abs(fps - 59.94) < 0.01) return { fpsNum: 6e4, fpsDen: 1001 };
+  return { fpsNum: Math.round(fps), fpsDen: 1 };
+}
+function compositionToClipExportInput(composition, trimmedRefs) {
+  const originalSorted = [...composition.clips].sort((a, b) => a.timelineStart - b.timelineStart);
+  for (let i = 0; i < originalSorted.length - 1; i++) {
+    const cur = originalSorted[i], next = originalSorted[i + 1];
+    if (next.timelineStart < cur.timelineEnd - EPSILON) {
+      throw new CompositionValidationError(
+        "Composition spine overlaps \u2014 clips must not share timeline time in v1",
+        { kind: "overlap", detail: `${cur.id} overlaps ${next.id}` }
+      );
+    }
+    if (next.timelineStart > cur.timelineEnd + EPSILON) {
+      throw new CompositionValidationError(
+        "Composition spine has a gap \u2014 clips must be contiguous in v1",
+        { kind: "gap", detail: `${cur.id} ends at ${cur.timelineEnd}, ${next.id} starts at ${next.timelineStart}` }
+      );
+    }
+  }
+  const compacted = compactTimeline(composition.clips, composition.deletedRanges);
+  const sorted = [...compacted].sort((a, b) => a.timelineStart - b.timelineStart);
+  function findRef(clip) {
+    const match = trimmedRefs.find((r) => {
+      if (r.sourceId !== clip.poolItemId) return false;
+      const expectedIn = Math.round(clip.sourceIn * r.mediaItemFps);
+      const expectedOut = Math.round(clip.sourceOut * r.mediaItemFps);
+      return r.inFramesAtSourceRate === expectedIn && r.outFramesAtSourceRate === expectedOut;
+    });
+    if (!match) {
+      throw new CompositionValidationError(
+        "Missing trimmedRef for clip",
+        { kind: "missing-trim", detail: `clip ${clip.id} (${clip.poolItemId} ${clip.sourceIn}-${clip.sourceOut}s)` }
+      );
+    }
+    return match;
+  }
+  const assetOrder = [];
+  const refForClip = /* @__PURE__ */ new Map();
+  for (const clip of sorted) {
+    const ref = findRef(clip);
+    refForClip.set(clip.id, ref);
+    const key = `${ref.sourceId}::${ref.inFramesAtSourceRate}::${ref.outFramesAtSourceRate}`;
+    if (!assetOrder.includes(key)) assetOrder.push(key);
+  }
+  const assetIdByKey = /* @__PURE__ */ new Map();
+  const refByKey = /* @__PURE__ */ new Map();
+  for (const clip of sorted) {
+    const ref = refForClip.get(clip.id);
+    const key = `${ref.sourceId}::${ref.inFramesAtSourceRate}::${ref.outFramesAtSourceRate}`;
+    if (!refByKey.has(key)) refByKey.set(key, ref);
+  }
+  const assets = assetOrder.map((key, i) => {
+    const id = `a${i + 1}`;
+    assetIdByKey.set(key, id);
+    const ref = refByKey.get(key);
+    return {
+      id,
+      relPath: `media/${id}.mp4`,
+      displayName: ref.displayName,
+      sourceId: ref.sourceId,
+      originInFrames: ref.inFramesAtSourceRate,
+      originOutFrames: ref.outFramesAtSourceRate,
+      fpsNum: ref.sourceFpsNum,
+      fpsDen: ref.sourceFpsDen,
+      width: composition.width,
+      height: composition.height,
+      durationSec: ref.durationSec
+    };
+  });
+  const { fpsNum, fpsDen } = sequenceRational(composition.fps);
+  const seqFps = fpsNum / fpsDen;
+  const spineIdByOriginalClipId = /* @__PURE__ */ new Map();
+  const spine = sorted.map((clip, idx) => {
+    const ref = refForClip.get(clip.id);
+    const sourceFps = ref.sourceFpsNum / ref.sourceFpsDen;
+    const key = `${ref.sourceId}::${ref.inFramesAtSourceRate}::${ref.outFramesAtSourceRate}`;
+    const spineId = `s${idx + 1}`;
+    const originalId = clip.originalClipId ?? clip.id;
+    if (!spineIdByOriginalClipId.has(originalId)) {
+      spineIdByOriginalClipId.set(originalId, spineId);
+    }
+    const inFrames = Math.round(ref.handleBeforeSec * sourceFps);
+    const clipLen = Math.round((clip.sourceOut - clip.sourceIn) * sourceFps);
+    return {
+      id: spineId,
+      assetId: assetIdByKey.get(key),
+      inFrames,
+      outFrames: inFrames + clipLen,
+      timelineStartFrames: Math.round(clip.timelineStart * seqFps),
+      timelineDurationFrames: Math.round((clip.timelineEnd - clip.timelineStart) * seqFps)
+    };
+  });
+  const markers = [];
+  if (composition.metadata?.cueframe?.hook) {
+    markers.push({
+      startFrames: 0,
+      durationFrames: 1,
+      name: composition.metadata.cueframe.hook,
+      kind: "hook"
+    });
+  }
+  for (const label of composition.sceneLabels) {
+    const spineItemId = spineIdByOriginalClipId.get(label.clipId);
+    if (!spineItemId) continue;
+    const spineItem = spine.find((s) => s.id === spineItemId);
+    const timelineSec = spineItem.timelineStartFrames / seqFps + label.startSec;
+    markers.push({
+      startFrames: Math.round(timelineSec * seqFps),
+      durationFrames: 1,
+      name: label.text,
+      kind: "scene",
+      spineItemId
+    });
+  }
+  const textOverlays = composition.overlays.map((o) => ({
+    text: getPrimitiveText({ template: o.template, params: o.params ?? {} }) ?? "",
+    startFrames: o.startFrame,
+    durationFrames: o.durationInFrames
+  }));
+  const durationFrames = spine.reduce(
+    (sum, s) => Math.max(sum, s.timelineStartFrames + s.timelineDurationFrames),
+    0
+  );
+  return {
+    title: composition.metadata?.cueframe?.hook ?? "Clip Export",
+    hook: composition.metadata?.cueframe?.hook,
+    sequence: { fpsNum, fpsDen, width: composition.width, height: composition.height, durationFrames },
+    assets,
+    spine,
+    markers,
+    textOverlays,
+    audioTracks: []
+  };
+}
+
+// ../nle-export/src/xml-utils.ts
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "clip";
+}
+export {
+  CompositionValidationError,
+  compactTimeline,
+  compositionToClipExportInput,
+  generateSrt,
+  slugify
+};

package/dist/perception.d.ts

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

package/dist/perception.js

@@ -0,0 +1,145 @@
+import "./chunk-2ESYSVXG.js";
+
+// ../perception/src/audioQuality.ts
+var AUDIO_QUALITY_VERSION = "audio-quality-v1-2026.06.21";
+var clamp01 = (x) => x < 0 ? 0 : x > 1 ? 1 : x;
+function audioQualitySignal(m) {
+  const IDEAL = -16;
+  const FLOOR = -50;
+  const HOT = -6;
+  let loud;
+  if (m.integratedLufs <= FLOOR) loud = 0;
+  else if (m.integratedLufs <= IDEAL) loud = (m.integratedLufs - FLOOR) / (IDEAL - FLOOR);
+  else if (m.integratedLufs >= HOT) loud = 0.35;
+  else loud = 1 - 0.65 * (m.integratedLufs - IDEAL) / (HOT - IDEAL);
+  loud = clamp01(loud);
+  const clipPenalty = m.truePeakDbtp <= -3 ? 1 : m.truePeakDbtp >= 0 ? 0.2 : 1 - 0.8 * (m.truePeakDbtp + 3) / 3;
+  const clarityMul = m.clarity === void 0 ? 1 : 0.4 + 0.6 * clamp01(m.clarity);
+  const value = clamp01(loud * clipPenalty * clarityMul);
+  const confidence = m.clarity === void 0 ? 0.75 : 0.95;
+  const evidence = `${m.integratedLufs.toFixed(1)} LUFS, ${m.truePeakDbtp.toFixed(1)} dBTP` + (m.loudnessRangeLu !== void 0 ? `, LRA ${m.loudnessRangeLu.toFixed(1)}` : "") + (m.clarity !== void 0 ? `, clarity ${m.clarity.toFixed(2)}` : "");
+  return { value, rawScore: m.integratedLufs, confidence, evidence };
+}
+
+// ../perception/src/activeSpeaker.ts
+var ACTIVE_SPEAKER_VERSION = "active-speaker-v1-2026.06.21";
+var clamp012 = (x) => x < 0 ? 0 : x > 1 ? 1 : x;
+function activeSpeakerSignal(series, sourceInSec, sourceOutSec) {
+  if (!series || series.probs.length === 0 || series.fps <= 0) return null;
+  const f0 = Math.max(0, Math.floor((sourceInSec - series.windowStartSec) * series.fps));
+  const f1 = Math.min(series.probs.length, Math.ceil((sourceOutSec - series.windowStartSec) * series.fps));
+  if (f1 <= f0) return null;
+  let sum = 0;
+  let present = 0;
+  for (let f = f0; f < f1; f++) {
+    const p = series.probs[f];
+    if (p === null || p === void 0) continue;
+    sum += clamp012(p);
+    present++;
+  }
+  const totalFrames = f1 - f0;
+  if (present === 0) return null;
+  const rawScore = sum / present;
+  const value = clamp012(rawScore);
+  const coverage = present / totalFrames;
+  const confidence = clamp012(0.3 + 0.7 * coverage);
+  const evidence = `speaking ${rawScore.toFixed(2)}, ${present}/${totalFrames} frames faced`;
+  return { value, rawScore, confidence, evidence };
+}
+
+// ../perception/src/energyBeat.ts
+var ENERGY_BEAT_VERSION = "energy-beat-v1-2026.06.21";
+var STILL_DELTA = 4e-3;
+var DYNAMIC_DELTA = 0.09;
+var clamp013 = (x) => x < 0 ? 0 : x > 1 ? 1 : x;
+function energyBeatSignal(series, sourceInSec, sourceOutSec) {
+  if (!series || series.deltas.length === 0 || series.fps <= 0) return null;
+  const f0 = Math.max(0, Math.floor((sourceInSec - series.windowStartSec) * series.fps));
+  const f1 = Math.min(series.deltas.length, Math.ceil((sourceOutSec - series.windowStartSec) * series.fps));
+  if (f1 <= f0) return null;
+  let sum = 0;
+  let present = 0;
+  for (let f = f0; f < f1; f++) {
+    const d = series.deltas[f];
+    if (d === null || d === void 0) continue;
+    sum += clamp013(d);
+    present++;
+  }
+  const totalFrames = f1 - f0;
+  if (present === 0) return null;
+  const rawScore = sum / present;
+  const value = clamp013((rawScore - STILL_DELTA) / (DYNAMIC_DELTA - STILL_DELTA));
+  const coverage = present / totalFrames;
+  const confidence = clamp013(0.3 + 0.7 * coverage);
+  const evidence = `motion ${rawScore.toFixed(4)}, ${present}/${totalFrames} frames decoded`;
+  return { value, rawScore, confidence, evidence };
+}
+
+// ../perception/src/visualQuality.ts
+var VISUAL_QUALITY_VERSION = "visual-quality-v1-2026.06.21";
+var BLUR_VAR = 3e-4;
+var SHARP_VAR = 6e-3;
+var IDEAL_LUMA = 0.45;
+var LUMA_TOLERANCE = 0.4;
+var CLIP_PENALTY_AT = 0.25;
+var clamp014 = (x) => x < 0 ? 0 : x > 1 ? 1 : x;
+function visualQualitySignal(m) {
+  if (m === void 0) return null;
+  if (!Number.isFinite(m.laplacianVariance) || !Number.isFinite(m.meanLuma)) return null;
+  const sharpness = clamp014((m.laplacianVariance - BLUR_VAR) / (SHARP_VAR - BLUR_VAR));
+  const lumaErr = Math.abs(m.meanLuma - IDEAL_LUMA);
+  let exposure = clamp014(1 - lumaErr / LUMA_TOLERANCE);
+  if (m.clippedFraction !== void 0) {
+    const clipPenalty = clamp014(1 - clamp014(m.clippedFraction) / CLIP_PENALTY_AT);
+    exposure *= clipPenalty;
+  }
+  const value = clamp014(sharpness * exposure);
+  const confidence = m.clippedFraction === void 0 ? 0.75 : 0.95;
+  const evidence = `sharpness ${sharpness.toFixed(2)}, exposure ${exposure.toFixed(2)} (lapVar ${m.laplacianVariance.toFixed(4)}, luma ${m.meanLuma.toFixed(2)}` + (m.clippedFraction !== void 0 ? `, clip ${m.clippedFraction.toFixed(3)}` : "") + ")";
+  return { value, rawScore: m.laplacianVariance, confidence, evidence };
+}
+
+// ../perception/src/identityMatch.ts
+var IDENTITY_MATCH_VERSION = "identity-match-v1-2026.06.21";
+var IDENTITY_MATCH_COSINE = 0.4;
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || a.length !== b.length) return 0;
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb);
+  if (denom <= 0) return 0;
+  return dot / denom;
+}
+function matchPerson(reference, anglePeople, cosineThreshold = IDENTITY_MATCH_COSINE) {
+  if (anglePeople.length === 0) return { present: false, bestCosine: -1, matchedFaceId: null };
+  let bestCosine = -1;
+  let matchedFaceId = null;
+  for (const p of anglePeople) {
+    const c = cosineSimilarity(reference, p.embedding);
+    if (c > bestCosine) {
+      bestCosine = c;
+      matchedFaceId = p.faceId;
+    }
+  }
+  return { present: bestCosine >= cosineThreshold, bestCosine, matchedFaceId };
+}
+export {
+  ACTIVE_SPEAKER_VERSION,
+  AUDIO_QUALITY_VERSION,
+  ENERGY_BEAT_VERSION,
+  IDENTITY_MATCH_COSINE,
+  IDENTITY_MATCH_VERSION,
+  VISUAL_QUALITY_VERSION,
+  activeSpeakerSignal,
+  audioQualitySignal,
+  cosineSimilarity,
+  energyBeatSignal,
+  matchPerson,
+  visualQualitySignal
+};

package/dist/plane/conformance.d.ts

@@ -0,0 +1 @@
+export * from "../_members/plane/conformance.js";

package/dist/plane/conformance.js

@@ -0,0 +1,13 @@
+import {
+  CONFORMANCE_COMPOSITION,
+  CONFORMANCE_DURATION_SEC,
+  PREVIEW_FRAME_CASES,
+  isKnownRed
+} from "../chunk-MCBUX5XV.js";
+import "../chunk-2ESYSVXG.js";
+export {
+  CONFORMANCE_COMPOSITION,
+  CONFORMANCE_DURATION_SEC,
+  PREVIEW_FRAME_CASES,
+  isKnownRed
+};

package/dist/plane/contract.d.ts

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

package/dist/plane/contract.js

@@ -0,0 +1,31 @@
+import "../chunk-2ESYSVXG.js";
+
+// ../plane/src/contract.ts
+import { z } from "zod";
+var PreviewFrameRequest = z.object({
+  composition: z.unknown().optional().describe(
+    "The composition to render. Absent \u21D2 the project's ACTIVE composition \u2014 what create_render will encode. The response's `previewed.source` names what was rendered."
+  ),
+  compositionId: z.string().optional().describe(
+    "Preview a SPECIFIC persisted composition of this project (create_render parity). Absent \u21D2 the active one. A stale/foreign id is a 404 \u2014 never a silent fall-through."
+  ),
+  session_id: z.string().optional().describe(
+    "Compose-session id: render that session's SCRATCH composition (what the session has been editing) instead of the active row. Ignored when `composition` is passed."
+  ),
+  timestamps: z.array(z.number()).min(1),
+  // Vision-bound shrink knobs (additive): an AGENT looking at its own work wants
+  // the judge's cheap stills (jpeg, 0.5, q70 — what the eval panel grades), not
+  // the full-res default a human preview wants. Absent ⇒ unchanged full-res.
+  imageFormat: z.enum(["png", "jpeg"]).optional().describe(
+    "Still format. Default jpeg \u2014 these pixels go to a vision model, where jpeg is equivalent and png costs multiples in bytes to store and move. Pass png only when you need full fidelity."
+  ),
+  scale: z.number().min(0.1).max(1).optional().describe(
+    "Render scale 0.1\u20131. Default 0.5, which is what this schema has always recommended for vision-bound looks. Pass 1 when judging fine detail \u2014 it costs ~4x the vision tokens."
+  ),
+  jpegQuality: z.number().int().min(1).max(100).optional().describe(
+    "JPEG quality (jpeg only). Default 70 \u2014 the quality the eval panel grades at."
+  )
+});
+export {
+  PreviewFrameRequest
+};

package/dist/plane.d.ts

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

package/dist/plane.js

@@ -0,0 +1,13 @@
+import {
+  CONFORMANCE_COMPOSITION,
+  CONFORMANCE_DURATION_SEC,
+  PREVIEW_FRAME_CASES,
+  isKnownRed
+} from "./chunk-MCBUX5XV.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  CONFORMANCE_COMPOSITION,
+  CONFORMANCE_DURATION_SEC,
+  PREVIEW_FRAME_CASES,
+  isKnownRed
+};

package/dist/primitives/backgrounds.d.ts

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

package/dist/primitives/backgrounds.js

@@ -0,0 +1,32 @@
+import {
+  AnimatedBarChart,
+  AnimatedLineChart,
+  DitherGradientBg,
+  DynamicGrid,
+  EcosystemConstellation,
+  InfiniteMarquee,
+  MeshGradientBg,
+  PerspectiveMarquee,
+  SilkFlowBg,
+  VectorField,
+  VolumetricRays,
+  catalog
+} from "../chunk-S3P5BFFL.js";
+import "../chunk-DSNG6WLU.js";
+import "../chunk-YA3OR2KK.js";
+import "../chunk-CX2IIQ4R.js";
+import "../chunk-2ESYSVXG.js";
+export {
+  AnimatedBarChart,
+  AnimatedLineChart,
+  DitherGradientBg,
+  DynamicGrid,
+  EcosystemConstellation,
+  InfiniteMarquee,
+  MeshGradientBg,
+  PerspectiveMarquee,
+  SilkFlowBg,
+  VectorField,
+  VolumetricRays,
+  catalog
+};

package/dist/primitives/captions.d.ts

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