@nodaro/shared 2.26.0 → 3.0.0

package/dist/index.js

@@ -4131,7 +4131,12 @@ var COMPOSER_PLAN_MAP = {
   "lottie-overlay": { planType: "lottie-overlay", planField: "overlayPlan" },
   "3d-title": { planType: "3d-title", planField: "titlePlan" },
   "motion-graphics": { planType: "motion-graphics", planField: "motionPlan" },
-  "composite": { planType: "composite", planField: "compositePlan" }
+  "composite": { planType: "composite", planField: "compositePlan" },
+  // Scene3D previz (v1) — both the generator and the editor emit the SAME
+  // validated `Scene3DPlan` revision on their `composition` handle, so
+  // render-video routes either one to the `3d-scene` renderer unchanged.
+  "generate-3d-scene": { planType: "3d-scene", planField: "scenePlan" },
+  "edit-3d-scene": { planType: "3d-scene", planField: "scenePlan" }
 };
 var COMPOSER_PLAN_FIELDS = [
   ...new Set(Object.values(COMPOSER_PLAN_MAP).map((m) => m.planField))
@@ -5880,6 +5885,7 @@ var LLM_FEATURE_DEFAULTS = {
   "motion-graphics-lottie": "claude-sonnet-4.6",
   "lottie-overlay": "claude-sonnet-4.6",
   "3d-title": "claude-sonnet-4.6",
+  "3d-scene": "claude-sonnet-4.6",
   "image-to-text": "claude-sonnet-4.6",
   "describe-to-picker": "claude-opus-5",
   "qa-check": "gemini-3.6-flash",
@@ -5980,7 +5986,10 @@ var LLM_ROUTE_DEFAULTS = {
   "lottie-overlay": { temperature: 0.3, maxTokens: 2048, structuredOutput: true },
   "motion-graphics": { temperature: 0.3, maxTokens: 2048, structuredOutput: true },
   "motion-graphics-lottie": { temperature: 0.3, maxTokens: 8192, structuredOutput: true },
-  "3d-title": { temperature: 0.4, maxTokens: 3072, structuredOutput: true }
+  "3d-title": { temperature: 0.4, maxTokens: 3072, structuredOutput: true },
+  // A 100-object plan with keyframe tracks is the biggest structured payload
+  // any composer feature emits — 3072 (3d-title's cap) truncates it mid-array.
+  "3d-scene": { temperature: 0.3, maxTokens: 8192, structuredOutput: true }
 };
 function llmRouteDefaults(feature) {
   return feature && LLM_ROUTE_DEFAULTS[feature] || {};
@@ -8763,6 +8772,8 @@ var NODE_MAPPABLE_FIELDS = {
   "after-effects": ["effectPrompt"],
   "lottie-overlay": ["overlayPrompt"],
   "3d-title": ["titlePrompt"],
+  "generate-3d-scene": ["scenePrompt"],
+  "edit-3d-scene": ["editPrompt"],
   "motion-graphics": ["motionPrompt"],
   "generate-script": ["styleGuide"],
   "speech-to-video": ["prompt", "negativePrompt"],
@@ -13140,8 +13151,22 @@ function readPromptAffixes(data) {
 }
 
 // src/node-preset-extract.ts
-var PRESET_APPLY_CLEAR_KEYS = [...COMPOSER_PLAN_FIELDS, "lottieUrl"];
-var PROMPT_CONTENT_KEYS = ["prompt", PROMPT_PREFIX_KEY, PROMPT_SUFFIX_KEY];
+var PRESET_APPLY_CLEAR_KEYS = [
+  ...COMPOSER_PLAN_FIELDS,
+  "lottieUrl",
+  // Scene revision history contains old plans and their reference/prompt context.
+  // Preserve it in workflows, never capture or resurrect it through a preset.
+  "sceneHistory",
+  "scenePendingPlan",
+  "sceneJobBaseRevisionId",
+  "expectedRevisionId",
+  "changeSummary",
+  "selectedObjectIds",
+  "lockedObjectIds",
+  "referenceObjectIds",
+  "referenceRoles"
+];
+var PROMPT_CONTENT_KEYS = ["prompt", "scenePrompt", "editPrompt", PROMPT_PREFIX_KEY, PROMPT_SUFFIX_KEY];
 function presetApplyClearKeys(presetData) {
   const ownsPromptContent = PROMPT_CONTENT_KEYS.some((k) => presetData[k] !== void 0);
   return ownsPromptContent ? [...PRESET_APPLY_CLEAR_KEYS, PROMPT_PREFIX_KEY, PROMPT_SUFFIX_KEY] : PRESET_APPLY_CLEAR_KEYS;
@@ -14676,6 +14701,1645 @@ function entityHydrationColumns(kind) {
 function entityScalarFields(kind) {
   return [...ENTITY_SCALAR_FIELDS, ...ENTITY_KIND_SCALAR_FIELDS[kind]];
 }
+var SCENE3D_PLAN_TYPE = "3d-scene";
+var SCENE3D_SCHEMA_VERSION = 1;
+var SCENE3D_DEFAULT_FPS = 24;
+var SCENE3D_DEFAULT_DURATION_SECONDS = 4;
+var SCENE3D_LIMITS = {
+  minDimensionPx: 100,
+  maxDimensionPx: 1920,
+  minFps: 15,
+  maxFps: 60,
+  minDurationInFrames: 1,
+  maxDurationInFrames: 3600,
+  /** Shortest scene an authoring request may ask for, in seconds. One second
+   *  is the frozen v1 floor the SDK/MCP surface and the public docs state; the
+   *  route Zod and the canvas path both quote it from here so they cannot
+   *  drift below it. */
+  minDurationSeconds: 1,
+  /** Hard ceiling on wall-clock length, checked against fps × frames. */
+  maxDurationSeconds: 60,
+  minObjects: 1,
+  maxObjects: 100,
+  /** Per-object and per-camera track length. */
+  maxKeyframes: 240,
+  maxReferences: 8,
+  maxOperations: 100,
+  /** |x|, |y|, |z| ceiling for positions and camera/target coordinates. */
+  maxCoordinate: 1e3,
+  minSize: 1e-3,
+  maxSize: 1e3,
+  minScale: 1e-3,
+  maxScale: 1e3,
+  minFocalLengthMm: 10,
+  maxFocalLengthMm: 200,
+  defaultSensorWidthMm: 36,
+  minSensorWidthMm: 1,
+  maxSensorWidthMm: 200,
+  maxIntensity: 100,
+  /** How deep a parent chain may nest. Bounds the renderer's transform walk. */
+  maxHierarchyDepth: 8,
+  maxIdLength: 64,
+  maxNameLength: 120,
+  maxUrlLength: 2048,
+  maxChangeSummaryLength: 2e3
+};
+var SCENE3D_PRIMITIVES = [
+  "box",
+  "sphere",
+  "cylinder",
+  "cone",
+  "plane",
+  "capsule",
+  "group"
+];
+function boundedVec3(max, label) {
+  return z.tuple([
+    z.number().min(-max).max(max),
+    z.number().min(-max).max(max),
+    z.number().min(-max).max(max)
+  ]).describe(label);
+}
+var vec3Schema = boundedVec3(SCENE3D_LIMITS.maxCoordinate, "position triple (meters)");
+var sizeVec3Schema = z.tuple([
+  z.number().min(SCENE3D_LIMITS.minSize).max(SCENE3D_LIMITS.maxSize),
+  z.number().min(SCENE3D_LIMITS.minSize).max(SCENE3D_LIMITS.maxSize),
+  z.number().min(SCENE3D_LIMITS.minSize).max(SCENE3D_LIMITS.maxSize)
+]);
+var scaleVec3Schema = z.tuple([
+  z.number().min(SCENE3D_LIMITS.minScale).max(SCENE3D_LIMITS.maxScale),
+  z.number().min(SCENE3D_LIMITS.minScale).max(SCENE3D_LIMITS.maxScale),
+  z.number().min(SCENE3D_LIMITS.minScale).max(SCENE3D_LIMITS.maxScale)
+]);
+var rotationVec3Schema = boundedVec3(1e3, "euler XYZ (radians)");
+var HEX_COLOR = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+var scene3DColorSchema = z.string().regex(HEX_COLOR, "color must be an opaque hex string such as #4f8ef7 (3 or 6 digits; alpha is not supported)");
+var SCENE3D_ID = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
+var scene3DIdSchema = z.string().min(1).max(SCENE3D_LIMITS.maxIdLength).regex(SCENE3D_ID, "id must start alphanumeric and contain only letters, digits, '_', '-' or '.'");
+function isScene3DHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+var scene3DUrlSchema = z.string().min(1).max(SCENE3D_LIMITS.maxUrlLength).refine(isScene3DHttpUrl, "url must be an http(s) URL");
+var scene3DEasingSchema = z.enum(["linear", "easeInOut"]);
+var scene3DPrimitiveSchema = z.enum([
+  "box",
+  "sphere",
+  "cylinder",
+  "cone",
+  "plane",
+  "capsule",
+  "group"
+]);
+var frameSchema = z.number().int().min(0).max(SCENE3D_LIMITS.maxDurationInFrames);
+var scene3DObjectKeyframeSchema = z.object({
+  frame: frameSchema,
+  position: vec3Schema.optional(),
+  rotation: rotationVec3Schema.optional(),
+  scale: scaleVec3Schema.optional(),
+  easing: scene3DEasingSchema.optional()
+}).strict();
+var scene3DCameraKeyframeSchema = z.object({
+  frame: frameSchema,
+  position: vec3Schema.optional(),
+  target: vec3Schema.optional(),
+  focalLengthMm: z.number().min(SCENE3D_LIMITS.minFocalLengthMm).max(SCENE3D_LIMITS.maxFocalLengthMm).optional(),
+  easing: scene3DEasingSchema.optional()
+}).strict();
+var scene3DObjectSchema = z.object({
+  id: scene3DIdSchema,
+  name: z.string().min(1).max(SCENE3D_LIMITS.maxNameLength),
+  primitive: scene3DPrimitiveSchema,
+  parentId: scene3DIdSchema.optional(),
+  dimensions: sizeVec3Schema,
+  position: vec3Schema,
+  rotation: rotationVec3Schema,
+  scale: scaleVec3Schema,
+  color: scene3DColorSchema,
+  keyframes: z.array(scene3DObjectKeyframeSchema).max(SCENE3D_LIMITS.maxKeyframes).optional()
+}).strict();
+var scene3DCameraSchema = z.object({
+  position: vec3Schema,
+  target: vec3Schema,
+  focalLengthMm: z.number().min(SCENE3D_LIMITS.minFocalLengthMm).max(SCENE3D_LIMITS.maxFocalLengthMm),
+  sensorWidthMm: z.number().min(SCENE3D_LIMITS.minSensorWidthMm).max(SCENE3D_LIMITS.maxSensorWidthMm).default(SCENE3D_LIMITS.defaultSensorWidthMm),
+  keyframes: z.array(scene3DCameraKeyframeSchema).max(SCENE3D_LIMITS.maxKeyframes).optional()
+}).strict();
+var scene3DLightingSchema = z.object({
+  ambientIntensity: z.number().min(0).max(SCENE3D_LIMITS.maxIntensity),
+  keyIntensity: z.number().min(0).max(SCENE3D_LIMITS.maxIntensity),
+  keyPosition: vec3Schema
+}).strict();
+var scene3DReferenceSchema = z.object({
+  id: scene3DIdSchema,
+  url: scene3DUrlSchema,
+  kind: z.enum(["image", "video"]),
+  role: z.enum(["appearance", "layout", "motion"]),
+  objectId: scene3DIdSchema.optional(),
+  startSeconds: z.number().min(0).max(86400).optional(),
+  endSeconds: z.number().min(0).max(86400).optional()
+}).strict();
+function checkKeyframeTrack(frames, durationInFrames, path, issues) {
+  let previous = -1;
+  frames.forEach((kf, index) => {
+    if (kf.frame > durationInFrames - 1) {
+      issues.push({
+        path: [...path, index, "frame"],
+        message: `frame ${kf.frame} is past the scene's last frame (${durationInFrames - 1})`
+      });
+    }
+    if (kf.frame === previous) {
+      issues.push({ path: [...path, index, "frame"], message: `duplicate keyframe at frame ${kf.frame}` });
+    } else if (kf.frame < previous) {
+      issues.push({
+        path: [...path, index, "frame"],
+        message: `keyframes must be sorted by frame (${kf.frame} follows ${previous})`
+      });
+    }
+    previous = kf.frame;
+  });
+}
+function scene3DPlanV1Issues(plan) {
+  const issues = [];
+  const seconds = plan.durationInFrames / plan.fps;
+  if (seconds > SCENE3D_LIMITS.maxDurationSeconds) {
+    issues.push({
+      path: ["durationInFrames"],
+      message: `scene is ${seconds.toFixed(2)}s; the limit is ${SCENE3D_LIMITS.maxDurationSeconds}s`
+    });
+  }
+  const byId = /* @__PURE__ */ new Map();
+  plan.objects.forEach((object, index) => {
+    if (byId.has(object.id)) {
+      issues.push({ path: ["objects", index, "id"], message: `duplicate object id "${object.id}"` });
+      return;
+    }
+    byId.set(object.id, object);
+  });
+  plan.objects.forEach((object, index) => {
+    if (object.parentId === void 0) return;
+    if (object.parentId === object.id) {
+      issues.push({ path: ["objects", index, "parentId"], message: `object "${object.id}" cannot parent itself` });
+      return;
+    }
+    if (!byId.has(object.parentId)) {
+      issues.push({
+        path: ["objects", index, "parentId"],
+        message: `object "${object.id}" references unknown parent "${object.parentId}"`
+      });
+      return;
+    }
+    const seen = /* @__PURE__ */ new Set([object.id]);
+    let cursor = byId.get(object.parentId);
+    let depth = 1;
+    while (cursor) {
+      if (seen.has(cursor.id)) {
+        issues.push({
+          path: ["objects", index, "parentId"],
+          message: `parent cycle through object "${cursor.id}"`
+        });
+        break;
+      }
+      seen.add(cursor.id);
+      depth += 1;
+      if (depth > SCENE3D_LIMITS.maxHierarchyDepth) {
+        issues.push({
+          path: ["objects", index, "parentId"],
+          message: `hierarchy deeper than ${SCENE3D_LIMITS.maxHierarchyDepth} levels`
+        });
+        break;
+      }
+      cursor = cursor.parentId === void 0 ? void 0 : byId.get(cursor.parentId);
+    }
+  });
+  plan.objects.forEach((object, index) => {
+    if (object.keyframes && object.keyframes.length > 0) {
+      checkKeyframeTrack(object.keyframes, plan.durationInFrames, ["objects", index, "keyframes"], issues);
+    }
+  });
+  if (plan.camera.keyframes && plan.camera.keyframes.length > 0) {
+    checkKeyframeTrack(plan.camera.keyframes, plan.durationInFrames, ["camera", "keyframes"], issues);
+  }
+  const referenceIds = /* @__PURE__ */ new Set();
+  (plan.references ?? []).forEach((reference, index) => {
+    if (referenceIds.has(reference.id)) {
+      issues.push({ path: ["references", index, "id"], message: `duplicate reference id "${reference.id}"` });
+    }
+    referenceIds.add(reference.id);
+    if (reference.objectId !== void 0 && !byId.has(reference.objectId)) {
+      issues.push({
+        path: ["references", index, "objectId"],
+        message: `reference "${reference.id}" points at unknown object "${reference.objectId}"`
+      });
+    }
+    if (reference.startSeconds !== void 0 && reference.endSeconds !== void 0 && reference.endSeconds <= reference.startSeconds) {
+      issues.push({
+        path: ["references", index, "endSeconds"],
+        message: `reference "${reference.id}" ends at or before it starts`
+      });
+    }
+    if (reference.kind === "image" && (reference.startSeconds !== void 0 || reference.endSeconds !== void 0)) {
+      issues.push({
+        path: ["references", index, "startSeconds"],
+        message: `reference "${reference.id}" is an image; a time window applies to video only`
+      });
+    }
+  });
+  return issues;
+}
+var scene3DPlanV1ObjectSchema = z.object({
+  planType: z.literal(SCENE3D_PLAN_TYPE),
+  schemaVersion: z.literal(SCENE3D_SCHEMA_VERSION),
+  revisionId: z.uuid(),
+  parentRevisionId: z.uuid().optional(),
+  width: z.number().int().min(SCENE3D_LIMITS.minDimensionPx).max(SCENE3D_LIMITS.maxDimensionPx),
+  height: z.number().int().min(SCENE3D_LIMITS.minDimensionPx).max(SCENE3D_LIMITS.maxDimensionPx),
+  fps: z.number().int().min(SCENE3D_LIMITS.minFps).max(SCENE3D_LIMITS.maxFps),
+  durationInFrames: z.number().int().min(SCENE3D_LIMITS.minDurationInFrames).max(SCENE3D_LIMITS.maxDurationInFrames),
+  backgroundColor: scene3DColorSchema,
+  camera: scene3DCameraSchema,
+  objects: z.array(scene3DObjectSchema).min(SCENE3D_LIMITS.minObjects).max(SCENE3D_LIMITS.maxObjects),
+  lighting: scene3DLightingSchema,
+  references: z.array(scene3DReferenceSchema).max(SCENE3D_LIMITS.maxReferences).optional()
+}).strict();
+var scene3DPlanV1Schema = scene3DPlanV1ObjectSchema.superRefine((plan, ctx) => {
+  for (const issue2 of scene3DPlanV1Issues(plan)) {
+    ctx.addIssue({ code: "custom", path: issue2.path, message: issue2.message });
+  }
+});
+var scene3DPlanSchema = scene3DPlanV1Schema;
+var scene3DPlanIssues = scene3DPlanV1Issues;
+function scene3DDeepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null || typeof a !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, i) => scene3DDeepEqual(item, b[i]));
+  }
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every((key) => key in bObj && scene3DDeepEqual(aObj[key], bObj[key]));
+}
+function newScene3DRevisionId() {
+  const webCrypto = globalThis.crypto;
+  if (webCrypto && typeof webCrypto.randomUUID === "function") return webCrypto.randomUUID();
+  const bytes = new Uint8Array(16);
+  if (webCrypto && typeof webCrypto.getRandomValues === "function") {
+    webCrypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function isScene3DPlanV1(value) {
+  return scene3DPlanV1Schema.safeParse(value).success;
+}
+var SCENE3D_PLAN_FIELD = "scenePlan";
+var SCENE3D_GENERATE_NODE_TYPE = "generate-3d-scene";
+var SCENE3D_EDIT_NODE_TYPE = "edit-3d-scene";
+var scene3DObjectChangesSchema = z.object({
+  name: z.string().min(1).max(SCENE3D_LIMITS.maxNameLength).optional(),
+  primitive: scene3DPrimitiveSchema.optional(),
+  /** `null` detaches from the parent; omitted leaves it as-is. */
+  parentId: scene3DIdSchema.nullable().optional(),
+  dimensions: sizeVec3Schema.optional(),
+  position: vec3Schema.optional(),
+  rotation: rotationVec3Schema.optional(),
+  scale: scaleVec3Schema.optional(),
+  color: scene3DColorSchema.optional(),
+  keyframes: z.array(scene3DObjectKeyframeSchema).max(SCENE3D_LIMITS.maxKeyframes).optional()
+}).strict();
+var scene3DCameraChangesSchema = z.object({
+  position: vec3Schema.optional(),
+  target: vec3Schema.optional(),
+  focalLengthMm: z.number().min(SCENE3D_LIMITS.minFocalLengthMm).max(SCENE3D_LIMITS.maxFocalLengthMm).optional(),
+  sensorWidthMm: z.number().min(SCENE3D_LIMITS.minSensorWidthMm).max(SCENE3D_LIMITS.maxSensorWidthMm).optional(),
+  keyframes: z.array(scene3DCameraKeyframeSchema).max(SCENE3D_LIMITS.maxKeyframes).optional()
+}).strict();
+var scene3DLightingChangesSchema = z.object({
+  ambientIntensity: z.number().min(0).max(SCENE3D_LIMITS.maxIntensity).optional(),
+  keyIntensity: z.number().min(0).max(SCENE3D_LIMITS.maxIntensity).optional(),
+  keyPosition: vec3Schema.optional()
+}).strict();
+var scene3DEditOperationSchema = z.discriminatedUnion("op", [
+  z.object({ op: z.literal("set-object"), objectId: scene3DIdSchema, changes: scene3DObjectChangesSchema }).strict(),
+  z.object({ op: z.literal("add-object"), object: scene3DObjectSchema }).strict(),
+  z.object({ op: z.literal("remove-object"), objectId: scene3DIdSchema }).strict(),
+  z.object({ op: z.literal("set-camera"), changes: scene3DCameraChangesSchema }).strict(),
+  z.object({ op: z.literal("set-lighting"), changes: scene3DLightingChangesSchema }).strict(),
+  z.object({ op: z.literal("set-background"), color: scene3DColorSchema }).strict()
+]);
+var scene3DEditOperationsSchema = z.array(scene3DEditOperationSchema).min(1).max(SCENE3D_LIMITS.maxOperations);
+function clonePlan(plan) {
+  return JSON.parse(JSON.stringify(plan));
+}
+function summarizeScene3DOperations(operations) {
+  const lines = operations.map((operation) => {
+    switch (operation.op) {
+      case "set-object": {
+        const fields = Object.keys(operation.changes);
+        return `Updated ${fields.length > 0 ? fields.join(", ") : "nothing"} on "${operation.objectId}"`;
+      }
+      case "add-object":
+        return `Added ${operation.object.primitive} "${operation.object.name}" (${operation.object.id})`;
+      case "remove-object":
+        return `Removed "${operation.objectId}"`;
+      case "set-camera":
+        return `Updated camera ${Object.keys(operation.changes).join(", ") || "nothing"}`;
+      case "set-lighting":
+        return `Updated lighting ${Object.keys(operation.changes).join(", ") || "nothing"}`;
+      case "set-background":
+        return `Set background to ${operation.color}`;
+    }
+  });
+  return lines.join("; ").slice(0, SCENE3D_LIMITS.maxChangeSummaryLength);
+}
+function firstIssueMessage(error) {
+  const issue2 = error.issues[0];
+  if (!issue2) return "invalid";
+  const path = issue2.path.join(".");
+  return path ? `${path}: ${issue2.message}` : issue2.message;
+}
+function applyScene3DEditOperations(plan, operations, options = {}) {
+  const parsedPlan = scene3DPlanV1Schema.safeParse(plan);
+  if (!parsedPlan.success) {
+    return { ok: false, code: "invalid_plan", message: `scenePlan is invalid \u2014 ${firstIssueMessage(parsedPlan.error)}` };
+  }
+  const source = parsedPlan.data;
+  if (options.expectedRevisionId !== void 0 && options.expectedRevisionId !== source.revisionId) {
+    return {
+      ok: false,
+      code: "stale_revision",
+      message: `This scene has moved on \u2014 expected revision ${options.expectedRevisionId}, the plan is at ${source.revisionId}.`
+    };
+  }
+  const parsedOps = scene3DEditOperationsSchema.safeParse(operations);
+  if (!parsedOps.success) {
+    const issue2 = parsedOps.error.issues[0];
+    const index = typeof issue2?.path[0] === "number" ? issue2.path[0] : void 0;
+    return {
+      ok: false,
+      code: "invalid_operations",
+      message: `operations are invalid \u2014 ${firstIssueMessage(parsedOps.error)}`,
+      ...index === void 0 ? {} : { operationIndex: index }
+    };
+  }
+  const ops = parsedOps.data;
+  const next = clonePlan(source);
+  const changed = /* @__PURE__ */ new Set();
+  for (let index = 0; index < ops.length; index++) {
+    const operation = ops[index];
+    switch (operation.op) {
+      case "set-object": {
+        const target = next.objects.findIndex((o) => o.id === operation.objectId);
+        if (target === -1) {
+          return {
+            ok: false,
+            code: "unknown_object",
+            message: `no object "${operation.objectId}" in this scene`,
+            operationIndex: index
+          };
+        }
+        const { parentId, ...rest } = operation.changes;
+        const updated = { ...next.objects[target], ...rest };
+        if (parentId !== void 0) {
+          if (parentId === null) delete updated.parentId;
+          else updated.parentId = parentId;
+        }
+        next.objects = next.objects.map((o, i) => i === target ? updated : o);
+        changed.add(operation.objectId);
+        break;
+      }
+      case "add-object": {
+        if (next.objects.some((o) => o.id === operation.object.id)) {
+          return {
+            ok: false,
+            code: "duplicate_object",
+            message: `an object with id "${operation.object.id}" already exists`,
+            operationIndex: index
+          };
+        }
+        next.objects = [...next.objects, operation.object];
+        changed.add(operation.object.id);
+        break;
+      }
+      case "remove-object": {
+        if (!next.objects.some((o) => o.id === operation.objectId)) {
+          return {
+            ok: false,
+            code: "unknown_object",
+            message: `no object "${operation.objectId}" in this scene`,
+            operationIndex: index
+          };
+        }
+        next.objects = next.objects.filter((o) => o.id !== operation.objectId);
+        changed.add(operation.objectId);
+        break;
+      }
+      case "set-camera":
+        next.camera = { ...next.camera, ...operation.changes };
+        break;
+      case "set-lighting":
+        next.lighting = { ...next.lighting, ...operation.changes };
+        break;
+      case "set-background":
+        next.backgroundColor = operation.color;
+        break;
+    }
+  }
+  for (const lockedId of options.lockedObjectIds ?? []) {
+    const before = source.objects.find((o) => o.id === lockedId);
+    const after = next.objects.find((o) => o.id === lockedId);
+    if (before === void 0) continue;
+    if (after === void 0) {
+      return { ok: false, code: "locked_object", message: `object "${lockedId}" is locked and cannot be removed` };
+    }
+    if (!scene3DDeepEqual(before, after)) {
+      return { ok: false, code: "locked_object", message: `object "${lockedId}" is locked and cannot be modified` };
+    }
+  }
+  next.parentRevisionId = source.revisionId;
+  next.revisionId = options.revisionId ?? newScene3DRevisionId();
+  const validated = scene3DPlanV1Schema.safeParse(next);
+  if (!validated.success) {
+    return {
+      ok: false,
+      code: "invalid_plan",
+      message: `the edit would leave the scene invalid \u2014 ${firstIssueMessage(validated.error)}`
+    };
+  }
+  return {
+    ok: true,
+    plan: validated.data,
+    changedObjectIds: [...changed],
+    changeSummary: summarizeScene3DOperations(ops)
+  };
+}
+var SCENE3D_SCHEMA_VERSION_V2 = 2;
+var SCENE3D_SUPPORTED_SCHEMA_VERSIONS = [1, 2];
+var SCENE3D_V2_ENGINES = ["blender-cloud", "blender-local"];
+var SCENE3D_V2_LIMITS = {
+  /** Both the seconds and the frame ceiling apply; neither waives the other. */
+  maxDurationSeconds: 60,
+  minDurationInFrames: 1,
+  maxDurationInFrames: 3600,
+  minFps: 15,
+  maxFps: 60,
+  defaultFps: 24,
+  /** Even integers only — an odd axis breaks H.264 chroma subsampling. */
+  minDimensionPx: 100,
+  maxDimensionPx: 1920,
+  minEntities: 1,
+  /** SEMANTIC entities, not exported mesh nodes. */
+  maxEntities: 100,
+  /** Enforced during asset normalization, after decode — see
+   *  `scene3DV2NormalizationIssues` in `scene3d-v2-resources.ts`. */
+  maxMeshNodes: 2e3,
+  maxTriangles: 2e5,
+  maxHierarchyDepth: 16,
+  /** Decoded manifest JSON. Measured on the bytes, before `JSON.parse`. */
+  maxManifestBytes: 512 * 1024,
+  /** Decoded camera-track JSON. */
+  maxCameraTrackBytes: 8 * 1024 * 1024,
+  /** Total DECLARED bytes of the assets the renderer downloads. Compression
+   *  does not waive the decoded geometry limits above. */
+  maxRendererAssetBytes: 64 * 1024 * 1024,
+  /** A `blend-source` is a separately authorized download, never handed to the
+   *  browser renderer, and therefore not part of the renderer budget. */
+  maxBlendSourceBytes: 512 * 1024 * 1024,
+  maxAssets: 64,
+  maxShots: 32,
+  maxShotEntityIds: 16,
+  /** v1's reference limit, unchanged until deliberately expanded. */
+  maxReferences: SCENE3D_LIMITS.maxReferences,
+  maxAnchorsPerEntity: 32,
+  maxMaterialBindingsPerEntity: 16,
+  maxOverrides: 200,
+  minPosterDimensionPx: 16,
+  maxPosterDimensionPx: 4096,
+  maxIdLength: SCENE3D_LIMITS.maxIdLength,
+  maxAssetIdLength: 128,
+  maxNodeIdLength: 128,
+  maxNameLength: SCENE3D_LIMITS.maxNameLength,
+  maxLabelLength: SCENE3D_LIMITS.maxNameLength,
+  maxMaterialNameLength: 120,
+  maxVersionLength: 64,
+  maxCoordinate: SCENE3D_LIMITS.maxCoordinate,
+  minSize: SCENE3D_LIMITS.minSize,
+  maxSize: SCENE3D_LIMITS.maxSize,
+  maxIntensity: SCENE3D_LIMITS.maxIntensity
+};
+var SCENE3D_V2_OVERRIDE_OPERATION_VERSION = 1;
+var SCENE3D_GLB_EXTRAS_ENTITY_ID = "nodaroEntityId";
+var SCENE3D_GLB_EXTRAS_SUBPART_ID = "nodaroSubpartId";
+var SCENE3D_GLB_EXTRAS_MATERIAL_ROLE = "nodaroMaterialRole";
+var SCENE3D_GLB_EXTRAS_ALLOWLIST = [
+  SCENE3D_GLB_EXTRAS_ENTITY_ID,
+  SCENE3D_GLB_EXTRAS_SUBPART_ID,
+  SCENE3D_GLB_EXTRAS_MATERIAL_ROLE
+];
+var SCENE3D_ENTITY_ROLES = [
+  "person",
+  "vehicle",
+  "prop",
+  "environment",
+  "other"
+];
+var SCENE3D_V2_PRIMITIVES = [
+  "box",
+  "sphere",
+  "cylinder",
+  "cone",
+  "plane",
+  "capsule"
+];
+var SCENE3D_ENTITY_CAPABILITIES = [
+  "transform",
+  "color",
+  "visibility"
+];
+var SCENE3D_DEFAULT_ENTITY_CAPABILITIES = SCENE3D_ENTITY_CAPABILITIES;
+var SCENE3D_ASSET_KINDS = [
+  "glb",
+  "camera-track-json",
+  "poster",
+  "validation-report",
+  "blend-source"
+];
+var SCENE3D_ASSET_ROLES = [
+  "scene-geometry",
+  "entity-geometry",
+  "camera-track",
+  "poster",
+  "validation-report",
+  "source"
+];
+var SCENE3D_ASSET_ROLE_KINDS = {
+  "scene-geometry": "glb",
+  "entity-geometry": "glb",
+  "camera-track": "camera-track-json",
+  poster: "poster",
+  "validation-report": "validation-report",
+  source: "blend-source"
+};
+var SCENE3D_RENDERER_ASSET_KINDS = [
+  "glb",
+  "camera-track-json",
+  "poster"
+];
+var SCENE3D_PRIMITIVE_MATERIAL_ROLE = "identity";
+var SCENE3D_CLAY_LIGHTING_PRESETS = ["clay-studio-v1"];
+var scene3DAssetIdSchema = z.string().min(1).max(SCENE3D_V2_LIMITS.maxAssetIdLength).regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/, "assetId must be an opaque id (letters, digits, '_', '-', '.', ':')").refine((value) => !value.includes(".."), "assetId must not contain '..'");
+var scene3DNodeIdSchema = z.string().min(1).max(SCENE3D_V2_LIMITS.maxNodeIdLength).regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/, "node id must be an exporter-generated stable id");
+var scene3DSha256Schema = z.string().regex(/^[0-9a-f]{64}$/, "sha256 must be 64 lowercase hex characters");
+var scene3DVersionTokenSchema = z.string().min(1).max(SCENE3D_V2_LIMITS.maxVersionLength).regex(
+  /^[A-Za-z0-9][A-Za-z0-9_.+-]*$/,
+  "version must be a bounded token (letters, digits, '_', '-', '.', '+') \u2014 never a path or prose"
+);
+var scene3DEngineIdSchema = z.string().min(1).max(SCENE3D_V2_LIMITS.maxVersionLength).regex(/^[a-z0-9][a-z0-9-]*$/, "engine must be a lowercase slug such as blender-cloud");
+var scene3DAnchorNameSchema = scene3DIdSchema;
+var scene3DMaterialRoleSchema = scene3DIdSchema;
+var scene3DMaterialNameSchema = z.string().min(1).max(SCENE3D_V2_LIMITS.maxMaterialNameLength).regex(/^[^\u0000-\u001f\u007f]+$/, "material name must not contain control characters");
+var v2FrameSchema = z.number().int().min(0).max(SCENE3D_V2_LIMITS.maxDurationInFrames);
+var scene3DEntityCapabilitySchema = z.enum(["transform", "color", "visibility"]);
+var scene3DAnchorSchema = z.object({
+  name: scene3DAnchorNameSchema,
+  position: vec3Schema,
+  rotation: rotationVec3Schema.optional()
+}).strict();
+var scene3DMaterialBindingSchema = z.object({
+  role: scene3DMaterialRoleSchema,
+  materialName: scene3DMaterialNameSchema,
+  color: scene3DColorSchema.optional(),
+  roughness: z.number().min(0).max(1).optional()
+}).strict();
+var scene3DAssetAnimationSchema = z.object({
+  clipName: z.string().min(1).max(SCENE3D_V2_LIMITS.maxNameLength),
+  startFrame: v2FrameSchema,
+  endFrameExclusive: z.number().int().min(1).max(SCENE3D_V2_LIMITS.maxDurationInFrames),
+  loop: z.boolean().optional()
+}).strict();
+var scene3DEntityVisualSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("group") }).strict(),
+  z.object({
+    kind: z.literal("primitive"),
+    primitive: z.enum(["box", "sphere", "cylinder", "cone", "plane", "capsule"]),
+    dimensions: sizeVec3Schema,
+    color: scene3DColorSchema
+  }).strict(),
+  z.object({
+    kind: z.literal("asset"),
+    assetId: scene3DAssetIdSchema,
+    rootNodeId: scene3DNodeIdSchema,
+    animation: scene3DAssetAnimationSchema.optional()
+  }).strict()
+]);
+var scene3DEntityV2Schema = z.object({
+  id: scene3DIdSchema,
+  name: z.string().min(1).max(SCENE3D_V2_LIMITS.maxNameLength),
+  parentId: scene3DIdSchema.optional(),
+  role: z.enum(["person", "vehicle", "prop", "environment", "other"]).optional(),
+  position: vec3Schema.optional(),
+  rotation: rotationVec3Schema.optional(),
+  scale: scaleVec3Schema.optional(),
+  identityColor: scene3DColorSchema.optional(),
+  anchors: z.array(scene3DAnchorSchema).max(SCENE3D_V2_LIMITS.maxAnchorsPerEntity).optional(),
+  capabilities: z.array(scene3DEntityCapabilitySchema).max(SCENE3D_ENTITY_CAPABILITIES.length).optional(),
+  locks: z.array(scene3DEntityCapabilitySchema).max(SCENE3D_ENTITY_CAPABILITIES.length).optional(),
+  materialBindings: z.array(scene3DMaterialBindingSchema).max(SCENE3D_V2_LIMITS.maxMaterialBindingsPerEntity).optional(),
+  visual: scene3DEntityVisualSchema
+}).strict();
+var scene3DAssetRefSchema = z.object({
+  assetId: scene3DAssetIdSchema,
+  kind: z.enum(["glb", "camera-track-json", "poster", "validation-report", "blend-source"]),
+  role: z.enum(["scene-geometry", "entity-geometry", "camera-track", "poster", "validation-report", "source"]),
+  byteLength: z.number().int().min(1).max(SCENE3D_V2_LIMITS.maxBlendSourceBytes),
+  sha256: scene3DSha256Schema,
+  originRevisionId: z.uuid().optional()
+}).strict();
+var scene3DShotSchema = z.object({
+  id: scene3DIdSchema,
+  startFrame: v2FrameSchema,
+  endFrameExclusive: z.number().int().min(1).max(SCENE3D_V2_LIMITS.maxDurationInFrames),
+  label: z.string().min(1).max(SCENE3D_V2_LIMITS.maxLabelLength).optional(),
+  subjectEntityIds: z.array(scene3DIdSchema).max(SCENE3D_V2_LIMITS.maxShotEntityIds).optional(),
+  foregroundEntityIds: z.array(scene3DIdSchema).max(SCENE3D_V2_LIMITS.maxShotEntityIds).optional()
+}).strict();
+var scene3DClayLightingSchema = z.object({
+  preset: z.enum(SCENE3D_CLAY_LIGHTING_PRESETS),
+  ambientIntensity: z.number().min(0).max(SCENE3D_V2_LIMITS.maxIntensity),
+  keyIntensity: z.number().min(0).max(SCENE3D_V2_LIMITS.maxIntensity),
+  keyPosition: vec3Schema
+}).strict();
+var overrideProvenanceShape = {
+  id: scene3DIdSchema,
+  sourceRevisionId: z.uuid(),
+  sourceContentHash: scene3DSha256Schema,
+  operationVersion: z.number().int().min(1).max(255)
+};
+var scene3DOverrideSchema = z.discriminatedUnion("kind", [
+  z.object({
+    ...overrideProvenanceShape,
+    kind: z.literal("entity-transform"),
+    entityId: scene3DIdSchema,
+    space: z.enum(["local", "world"]),
+    position: vec3Schema.optional(),
+    rotation: rotationVec3Schema.optional(),
+    scale: scaleVec3Schema.optional()
+  }).strict(),
+  z.object({
+    ...overrideProvenanceShape,
+    kind: z.literal("entity-color"),
+    entityId: scene3DIdSchema,
+    materialRole: scene3DMaterialRoleSchema,
+    color: scene3DColorSchema
+  }).strict(),
+  z.object({
+    ...overrideProvenanceShape,
+    kind: z.literal("entity-visibility"),
+    entityId: scene3DIdSchema,
+    visible: z.boolean()
+  }).strict(),
+  z.object({
+    ...overrideProvenanceShape,
+    kind: z.literal("camera-shot-offset"),
+    shotId: scene3DIdSchema,
+    positionOffset: vec3Schema.optional(),
+    targetOffset: vec3Schema.optional()
+  }).strict()
+]);
+var scene3DProvenanceSchema = z.object({
+  engine: scene3DEngineIdSchema,
+  engineVersion: scene3DVersionTokenSchema,
+  recipeVersion: scene3DVersionTokenSchema,
+  compilerVersion: scene3DVersionTokenSchema,
+  exporterVersion: scene3DVersionTokenSchema,
+  rendererVersion: scene3DVersionTokenSchema,
+  sourceRevisionId: z.uuid().optional(),
+  sourceArtifactId: scene3DAssetIdSchema.optional(),
+  contentHash: scene3DSha256Schema
+}).strict();
+function scene3DJsonByteLength(text) {
+  return new TextEncoder().encode(text).length;
+}
+function scene3DZodIssues(error) {
+  return error.issues.map((issue2) => ({ path: [...issue2.path], message: issue2.message }));
+}
+function entityCapabilities(entity) {
+  return entity.capabilities ?? SCENE3D_DEFAULT_ENTITY_CAPABILITIES;
+}
+function scene3DEntityAcceptsOverlay(entity, capability2) {
+  return entityCapabilities(entity).includes(capability2) && !(entity.locks ?? []).includes(capability2);
+}
+function checkEntities(plan, byId, issues) {
+  const rootNodeOwners = /* @__PURE__ */ new Map();
+  plan.objects.forEach((entity, index) => {
+    const at = (...rest) => ["objects", index, ...rest];
+    if (entity.visual.kind !== "asset") {
+      for (const field of ["position", "rotation", "scale"]) {
+        if (entity[field] === void 0) {
+          issues.push({
+            path: at(field),
+            message: `entity "${entity.id}" is a ${entity.visual.kind} and must declare ${field}`
+          });
+        }
+      }
+    }
+    if (entity.visual.kind === "asset") {
+      const owner = rootNodeOwners.get(entity.visual.rootNodeId);
+      if (owner !== void 0) {
+        issues.push({
+          path: at("visual", "rootNodeId"),
+          message: `root node "${entity.visual.rootNodeId}" is already the root of entity "${owner}"`
+        });
+      } else {
+        rootNodeOwners.set(entity.visual.rootNodeId, entity.id);
+      }
+      const animation = entity.visual.animation;
+      if (animation) {
+        if (animation.endFrameExclusive <= animation.startFrame) {
+          issues.push({
+            path: at("visual", "animation", "endFrameExclusive"),
+            message: `entity "${entity.id}" animation ends at or before it starts`
+          });
+        }
+        if (animation.endFrameExclusive > plan.durationInFrames) {
+          issues.push({
+            path: at("visual", "animation", "endFrameExclusive"),
+            message: `entity "${entity.id}" animation runs past the scene (${plan.durationInFrames} frames)`
+          });
+        }
+      }
+    } else if (entity.materialBindings && entity.materialBindings.length > 0) {
+      issues.push({
+        path: at("materialBindings"),
+        message: `entity "${entity.id}" is a ${entity.visual.kind}; material bindings name materials in an asset root`
+      });
+    }
+    const roles = /* @__PURE__ */ new Set();
+    (entity.materialBindings ?? []).forEach((binding, bindingIndex) => {
+      if (roles.has(binding.role)) {
+        issues.push({
+          path: at("materialBindings", bindingIndex, "role"),
+          message: `entity "${entity.id}" binds material role "${binding.role}" twice`
+        });
+      }
+      roles.add(binding.role);
+    });
+    const anchorNames = /* @__PURE__ */ new Set();
+    (entity.anchors ?? []).forEach((anchor, anchorIndex) => {
+      if (anchorNames.has(anchor.name)) {
+        issues.push({
+          path: at("anchors", anchorIndex, "name"),
+          message: `entity "${entity.id}" declares anchor "${anchor.name}" twice`
+        });
+      }
+      anchorNames.add(anchor.name);
+    });
+  });
+  plan.objects.forEach((entity, index) => {
+    if (entity.parentId === void 0) return;
+    if (entity.parentId === entity.id) {
+      issues.push({ path: ["objects", index, "parentId"], message: `entity "${entity.id}" cannot parent itself` });
+      return;
+    }
+    if (!byId.has(entity.parentId)) {
+      issues.push({
+        path: ["objects", index, "parentId"],
+        message: `entity "${entity.id}" references unknown parent "${entity.parentId}"`
+      });
+      return;
+    }
+    const seen = /* @__PURE__ */ new Set([entity.id]);
+    let cursor = byId.get(entity.parentId);
+    let depth = 1;
+    while (cursor) {
+      if (seen.has(cursor.id)) {
+        issues.push({ path: ["objects", index, "parentId"], message: `parent cycle through entity "${cursor.id}"` });
+        break;
+      }
+      seen.add(cursor.id);
+      depth += 1;
+      if (depth > SCENE3D_V2_LIMITS.maxHierarchyDepth) {
+        issues.push({
+          path: ["objects", index, "parentId"],
+          message: `hierarchy deeper than ${SCENE3D_V2_LIMITS.maxHierarchyDepth} levels`
+        });
+        break;
+      }
+      cursor = cursor.parentId === void 0 ? void 0 : byId.get(cursor.parentId);
+    }
+  });
+}
+function checkAssets(plan, assetsById, issues) {
+  let rendererBytes = 0;
+  let sourceCount = 0;
+  plan.assets.forEach((asset, index) => {
+    const at = (...rest) => ["assets", index, ...rest];
+    const expectedKind = SCENE3D_ASSET_ROLE_KINDS[asset.role];
+    if (asset.kind !== expectedKind) {
+      issues.push({
+        path: at("kind"),
+        message: `asset "${asset.assetId}" has role "${asset.role}", which requires kind "${expectedKind}" (got "${asset.kind}")`
+      });
+    }
+    if (asset.kind === "camera-track-json" && asset.byteLength > SCENE3D_V2_LIMITS.maxCameraTrackBytes) {
+      issues.push({
+        path: at("byteLength"),
+        message: `camera track "${asset.assetId}" is ${asset.byteLength} bytes; the limit is ${SCENE3D_V2_LIMITS.maxCameraTrackBytes}`
+      });
+    }
+    if (SCENE3D_RENDERER_ASSET_KINDS.includes(asset.kind)) {
+      rendererBytes += asset.byteLength;
+      if (asset.byteLength > SCENE3D_V2_LIMITS.maxRendererAssetBytes) {
+        issues.push({
+          path: at("byteLength"),
+          message: `asset "${asset.assetId}" is ${asset.byteLength} bytes; a downloaded scene asset may not exceed ${SCENE3D_V2_LIMITS.maxRendererAssetBytes}`
+        });
+      }
+    }
+    if (asset.kind === "blend-source") {
+      sourceCount += 1;
+      if (sourceCount > 1) {
+        issues.push({ path: at("kind"), message: "a revision may retain at most one blend-source asset" });
+      }
+    }
+  });
+  if (rendererBytes > SCENE3D_V2_LIMITS.maxRendererAssetBytes) {
+    issues.push({
+      path: ["assets"],
+      message: `downloaded scene assets total ${rendererBytes} bytes; the limit is ${SCENE3D_V2_LIMITS.maxRendererAssetBytes}`
+    });
+  }
+  const track = assetsById.get(plan.cameraTrackAssetId);
+  if (!track) {
+    issues.push({
+      path: ["cameraTrackAssetId"],
+      message: `cameraTrackAssetId "${plan.cameraTrackAssetId}" is not in assets`
+    });
+  } else if (track.kind !== "camera-track-json") {
+    issues.push({
+      path: ["cameraTrackAssetId"],
+      message: `cameraTrackAssetId "${plan.cameraTrackAssetId}" is kind "${track.kind}"; a camera track must be camera-track-json`
+    });
+  }
+  const referencedGlbs = /* @__PURE__ */ new Set();
+  for (const entity of plan.objects) {
+    if (entity.visual.kind === "asset") referencedGlbs.add(entity.visual.assetId);
+  }
+  plan.assets.forEach((asset, index) => {
+    if (asset.kind === "glb" && !referencedGlbs.has(asset.assetId)) {
+      issues.push({
+        path: ["assets", index, "assetId"],
+        message: `glb asset "${asset.assetId}" is not referenced by any entity`
+      });
+    }
+  });
+  plan.objects.forEach((entity, index) => {
+    if (entity.visual.kind !== "asset") return;
+    const asset = assetsById.get(entity.visual.assetId);
+    if (!asset) {
+      issues.push({
+        path: ["objects", index, "visual", "assetId"],
+        message: `entity "${entity.id}" references unknown asset "${entity.visual.assetId}"`
+      });
+    } else if (asset.kind !== "glb") {
+      issues.push({
+        path: ["objects", index, "visual", "assetId"],
+        message: `entity "${entity.id}" references asset "${asset.assetId}" of kind "${asset.kind}"; geometry must be glb`
+      });
+    }
+  });
+  if (plan.provenance.sourceArtifactId !== void 0) {
+    const source = assetsById.get(plan.provenance.sourceArtifactId);
+    if (!source) {
+      issues.push({
+        path: ["provenance", "sourceArtifactId"],
+        message: `sourceArtifactId "${plan.provenance.sourceArtifactId}" is not in assets`
+      });
+    } else if (source.kind !== "blend-source") {
+      issues.push({
+        path: ["provenance", "sourceArtifactId"],
+        message: `sourceArtifactId "${source.assetId}" is kind "${source.kind}"; a retained source must be blend-source`
+      });
+    }
+  }
+}
+function checkShots(plan, byId, issues) {
+  const seenIds = /* @__PURE__ */ new Set();
+  let expectedStart = 0;
+  plan.shots.forEach((shot, index) => {
+    const at = (...rest) => ["shots", index, ...rest];
+    if (seenIds.has(shot.id)) {
+      issues.push({ path: at("id"), message: `duplicate shot id "${shot.id}"` });
+    }
+    seenIds.add(shot.id);
+    if (shot.endFrameExclusive <= shot.startFrame) {
+      issues.push({
+        path: at("endFrameExclusive"),
+        message: `shot "${shot.id}" ends at or before it starts (${shot.startFrame}..${shot.endFrameExclusive})`
+      });
+    }
+    if (shot.startFrame !== expectedStart) {
+      issues.push({
+        path: at("startFrame"),
+        message: index === 0 ? `shots must start at frame 0 (got ${shot.startFrame})` : `shot "${shot.id}" starts at ${shot.startFrame}; the previous shot ends at ${expectedStart} \u2014 every frame belongs to exactly one shot`
+      });
+    }
+    expectedStart = Math.max(expectedStart, shot.endFrameExclusive);
+    for (const field of ["subjectEntityIds", "foregroundEntityIds"]) {
+      (shot[field] ?? []).forEach((entityId, entityIndex) => {
+        if (!byId.has(entityId)) {
+          issues.push({
+            path: at(field, entityIndex),
+            message: `shot "${shot.id}" references unknown entity "${entityId}"`
+          });
+        }
+      });
+    }
+  });
+  const last = plan.shots[plan.shots.length - 1];
+  if (last && last.endFrameExclusive !== plan.durationInFrames) {
+    issues.push({
+      path: ["shots", plan.shots.length - 1, "endFrameExclusive"],
+      message: `shots end at frame ${last.endFrameExclusive}; the scene is ${plan.durationInFrames} frames and must be covered completely`
+    });
+  }
+}
+function checkOverrides(plan, byId, shotIds, issues) {
+  const overrideIds = /* @__PURE__ */ new Set();
+  const transformTargets = /* @__PURE__ */ new Set();
+  const visibilityTargets = /* @__PURE__ */ new Set();
+  const colorTargets = /* @__PURE__ */ new Set();
+  const offsetTargets = /* @__PURE__ */ new Set();
+  (plan.overrides ?? []).forEach((override, index) => {
+    const at = (...rest) => ["overrides", index, ...rest];
+    if (overrideIds.has(override.id)) {
+      issues.push({ path: at("id"), message: `duplicate override id "${override.id}"` });
+    }
+    overrideIds.add(override.id);
+    if (override.operationVersion > SCENE3D_V2_OVERRIDE_OPERATION_VERSION) {
+      issues.push({
+        path: at("operationVersion"),
+        message: `override "${override.id}" uses operation version ${override.operationVersion}; this reader understands up to ${SCENE3D_V2_OVERRIDE_OPERATION_VERSION}`
+      });
+    }
+    if (override.kind === "camera-shot-offset") {
+      if (!shotIds.has(override.shotId)) {
+        issues.push({ path: at("shotId"), message: `override "${override.id}" targets unknown shot "${override.shotId}"` });
+      } else if (offsetTargets.has(override.shotId)) {
+        issues.push({
+          path: at("shotId"),
+          message: `shot "${override.shotId}" already has a camera offset; one owner per channel`
+        });
+      }
+      offsetTargets.add(override.shotId);
+      if (override.positionOffset === void 0 && override.targetOffset === void 0) {
+        issues.push({ path: at(), message: `override "${override.id}" offsets nothing` });
+      }
+      return;
+    }
+    const entity = byId.get(override.entityId);
+    if (!entity) {
+      issues.push({ path: at("entityId"), message: `override "${override.id}" targets unknown entity "${override.entityId}"` });
+      return;
+    }
+    if (override.kind === "entity-transform") {
+      if (transformTargets.has(override.entityId)) {
+        issues.push({
+          path: at("entityId"),
+          message: `entity "${override.entityId}" already has a transform override; one owner per channel`
+        });
+      }
+      transformTargets.add(override.entityId);
+      if (!scene3DEntityAcceptsOverlay(entity, "transform")) {
+        issues.push({
+          path: at("entityId"),
+          message: `entity "${override.entityId}" does not accept a transform overlay (locked or not advertised)`
+        });
+      }
+      if (override.position === void 0 && override.rotation === void 0 && override.scale === void 0) {
+        issues.push({ path: at(), message: `override "${override.id}" changes nothing` });
+      }
+      return;
+    }
+    if (override.kind === "entity-visibility") {
+      if (visibilityTargets.has(override.entityId)) {
+        issues.push({
+          path: at("entityId"),
+          message: `entity "${override.entityId}" already has a visibility override; one owner per channel`
+        });
+      }
+      visibilityTargets.add(override.entityId);
+      if (!scene3DEntityAcceptsOverlay(entity, "visibility")) {
+        issues.push({
+          path: at("entityId"),
+          message: `entity "${override.entityId}" does not accept a visibility overlay (locked or not advertised)`
+        });
+      }
+      return;
+    }
+    const key = `${override.entityId}\0${override.materialRole}`;
+    if (colorTargets.has(key)) {
+      issues.push({
+        path: at("materialRole"),
+        message: `entity "${override.entityId}" already recolours material role "${override.materialRole}"`
+      });
+    }
+    colorTargets.add(key);
+    if (!scene3DEntityAcceptsOverlay(entity, "color")) {
+      issues.push({
+        path: at("entityId"),
+        message: `entity "${override.entityId}" does not accept a colour overlay (locked or not advertised)`
+      });
+    }
+    if (entity.visual.kind === "group") {
+      issues.push({
+        path: at("materialRole"),
+        message: `entity "${override.entityId}" is a group and has no geometry to recolour`
+      });
+    } else if (entity.visual.kind === "primitive") {
+      if (override.materialRole !== SCENE3D_PRIMITIVE_MATERIAL_ROLE) {
+        issues.push({
+          path: at("materialRole"),
+          message: `entity "${override.entityId}" is a primitive; its only material role is "${SCENE3D_PRIMITIVE_MATERIAL_ROLE}"`
+        });
+      }
+    } else if (!(entity.materialBindings ?? []).some((binding) => binding.role === override.materialRole)) {
+      issues.push({
+        path: at("materialRole"),
+        message: `entity "${override.entityId}" declares no material role "${override.materialRole}"; a binding may only name materials in that entity's asset root`
+      });
+    }
+  });
+}
+function scene3DPlanV2Issues(plan) {
+  const issues = [];
+  const seconds = plan.durationInFrames / plan.fps;
+  if (seconds > SCENE3D_V2_LIMITS.maxDurationSeconds) {
+    issues.push({
+      path: ["durationInFrames"],
+      message: `scene is ${seconds.toFixed(2)}s; the limit is ${SCENE3D_V2_LIMITS.maxDurationSeconds}s`
+    });
+  }
+  for (const axis of ["width", "height"]) {
+    if (plan[axis] % 2 !== 0) {
+      issues.push({ path: [axis], message: `${axis} must be an even number of pixels (got ${plan[axis]})` });
+    }
+  }
+  const byId = /* @__PURE__ */ new Map();
+  plan.objects.forEach((entity, index) => {
+    if (byId.has(entity.id)) {
+      issues.push({ path: ["objects", index, "id"], message: `duplicate entity id "${entity.id}"` });
+      return;
+    }
+    byId.set(entity.id, entity);
+  });
+  const assetsById = /* @__PURE__ */ new Map();
+  plan.assets.forEach((asset, index) => {
+    if (assetsById.has(asset.assetId)) {
+      issues.push({ path: ["assets", index, "assetId"], message: `duplicate asset id "${asset.assetId}"` });
+      return;
+    }
+    assetsById.set(asset.assetId, asset);
+  });
+  checkEntities(plan, byId, issues);
+  checkAssets(plan, assetsById, issues);
+  checkShots(plan, byId, issues);
+  checkOverrides(plan, byId, new Set(plan.shots.map((shot) => shot.id)), issues);
+  const referenceIds = /* @__PURE__ */ new Set();
+  (plan.references ?? []).forEach((reference, index) => {
+    if (referenceIds.has(reference.id)) {
+      issues.push({ path: ["references", index, "id"], message: `duplicate reference id "${reference.id}"` });
+    }
+    referenceIds.add(reference.id);
+    if (reference.objectId !== void 0 && !byId.has(reference.objectId)) {
+      issues.push({
+        path: ["references", index, "objectId"],
+        message: `reference "${reference.id}" points at unknown entity "${reference.objectId}"`
+      });
+    }
+    if (reference.startSeconds !== void 0 && reference.endSeconds !== void 0 && reference.endSeconds <= reference.startSeconds) {
+      issues.push({
+        path: ["references", index, "endSeconds"],
+        message: `reference "${reference.id}" ends at or before it starts`
+      });
+    }
+    if (reference.kind === "image" && (reference.startSeconds !== void 0 || reference.endSeconds !== void 0)) {
+      issues.push({
+        path: ["references", index, "startSeconds"],
+        message: `reference "${reference.id}" is an image; a time window applies to video only`
+      });
+    }
+  });
+  return issues;
+}
+var scene3DPlanV2ObjectSchema = z.object({
+  planType: z.literal(SCENE3D_PLAN_TYPE),
+  schemaVersion: z.literal(SCENE3D_SCHEMA_VERSION_V2),
+  revisionId: z.uuid(),
+  parentRevisionId: z.uuid().optional(),
+  width: z.number().int().min(SCENE3D_V2_LIMITS.minDimensionPx).max(SCENE3D_V2_LIMITS.maxDimensionPx),
+  height: z.number().int().min(SCENE3D_V2_LIMITS.minDimensionPx).max(SCENE3D_V2_LIMITS.maxDimensionPx),
+  fps: z.number().int().min(SCENE3D_V2_LIMITS.minFps).max(SCENE3D_V2_LIMITS.maxFps),
+  durationInFrames: z.number().int().min(SCENE3D_V2_LIMITS.minDurationInFrames).max(SCENE3D_V2_LIMITS.maxDurationInFrames),
+  units: z.literal("meters"),
+  upAxis: z.literal("Y"),
+  handedness: z.literal("right"),
+  objects: z.array(scene3DEntityV2Schema).min(SCENE3D_V2_LIMITS.minEntities).max(SCENE3D_V2_LIMITS.maxEntities),
+  assets: z.array(scene3DAssetRefSchema).min(1).max(SCENE3D_V2_LIMITS.maxAssets),
+  cameraTrackAssetId: scene3DAssetIdSchema,
+  shots: z.array(scene3DShotSchema).min(1).max(SCENE3D_V2_LIMITS.maxShots),
+  lighting: scene3DClayLightingSchema,
+  backgroundColor: scene3DColorSchema,
+  references: z.array(scene3DReferenceSchema).max(SCENE3D_V2_LIMITS.maxReferences).optional(),
+  overrides: z.array(scene3DOverrideSchema).max(SCENE3D_V2_LIMITS.maxOverrides).optional(),
+  provenance: scene3DProvenanceSchema
+}).strict();
+var scene3DPlanV2Schema = scene3DPlanV2ObjectSchema.superRefine((plan, ctx) => {
+  for (const issue2 of scene3DPlanV2Issues(plan)) {
+    ctx.addIssue({ code: "custom", path: issue2.path, message: issue2.message });
+  }
+});
+var scene3DAnyPlanSchema = z.discriminatedUnion("schemaVersion", [scene3DPlanV1ObjectSchema, scene3DPlanV2ObjectSchema]).superRefine((plan, ctx) => {
+  const issues = plan.schemaVersion === SCENE3D_SCHEMA_VERSION_V2 ? scene3DPlanV2Issues(plan) : scene3DPlanV1Issues(plan);
+  for (const issue2 of issues) {
+    ctx.addIssue({ code: "custom", path: issue2.path, message: issue2.message });
+  }
+});
+var scene3DAcceptedSchemaVersionsSchema = z.array(z.union([z.literal(1), z.literal(2)])).min(1).max(SCENE3D_SUPPORTED_SCHEMA_VERSIONS.length);
+function isScene3DPlanV2(value) {
+  return scene3DPlanV2Schema.safeParse(value).success;
+}
+function isScene3DPlan(value) {
+  return scene3DAnyPlanSchema.safeParse(value).success;
+}
+function scene3DPlanSchemaVersion(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const record = value;
+  if (record.planType !== SCENE3D_PLAN_TYPE) return null;
+  if (typeof record.schemaVersion !== "number" || !Number.isInteger(record.schemaVersion)) return null;
+  return record.schemaVersion;
+}
+function isScene3DSchemaVersionSupported(version) {
+  return SCENE3D_SUPPORTED_SCHEMA_VERSIONS.includes(version);
+}
+function isKnownScene3DEngine(engine) {
+  return SCENE3D_V2_ENGINES.includes(engine);
+}
+function scene3DShotIndexForFrame(shots, frame) {
+  for (let index = 0; index < shots.length; index++) {
+    const shot = shots[index];
+    if (frame >= shot.startFrame && frame < shot.endFrameExclusive) return index;
+  }
+  return -1;
+}
+function scene3DShotForFrame(shots, frame) {
+  const index = scene3DShotIndexForFrame(shots, frame);
+  return index === -1 ? void 0 : shots[index];
+}
+
+// src/scene3d-v2-resources.ts
+function scene3DV2HierarchyDepth(entities) {
+  const byId = new Map(entities.map((entity) => [entity.id, entity]));
+  let deepest = 0;
+  for (const entity of entities) {
+    let depth = 1;
+    let cursor = entity;
+    const seen = /* @__PURE__ */ new Set([entity.id]);
+    while (cursor.parentId !== void 0) {
+      const parent = byId.get(cursor.parentId);
+      if (!parent || seen.has(parent.id)) break;
+      seen.add(parent.id);
+      cursor = parent;
+      depth += 1;
+    }
+    if (depth > deepest) deepest = depth;
+  }
+  return deepest;
+}
+function scene3DV2ResourceUsage(plan) {
+  let rendererAssetBytes = 0;
+  let cameraTrackBytes = 0;
+  let blendSourceBytes = 0;
+  for (const asset of plan.assets) {
+    if (SCENE3D_RENDERER_ASSET_KINDS.includes(asset.kind)) rendererAssetBytes += asset.byteLength;
+    if (asset.kind === "camera-track-json") cameraTrackBytes += asset.byteLength;
+    if (asset.kind === "blend-source") blendSourceBytes += asset.byteLength;
+  }
+  return {
+    entities: plan.objects.length,
+    assets: plan.assets.length,
+    shots: plan.shots.length,
+    overrides: plan.overrides?.length ?? 0,
+    references: plan.references?.length ?? 0,
+    frames: plan.durationInFrames,
+    durationSeconds: plan.durationInFrames / plan.fps,
+    hierarchyDepth: scene3DV2HierarchyDepth(plan.objects),
+    rendererAssetBytes,
+    cameraTrackBytes,
+    blendSourceBytes
+  };
+}
+function scene3DV2AdmissionIssues(plan, manifestBytes) {
+  const issues = [];
+  const usage = scene3DV2ResourceUsage(plan);
+  const limits = SCENE3D_V2_LIMITS;
+  if (manifestBytes !== void 0 && manifestBytes > limits.maxManifestBytes) {
+    issues.push({
+      path: [],
+      message: `manifest is ${manifestBytes} bytes; the limit is ${limits.maxManifestBytes}`
+    });
+  }
+  if (usage.frames > limits.maxDurationInFrames) {
+    issues.push({
+      path: ["durationInFrames"],
+      message: `scene is ${usage.frames} frames; the limit is ${limits.maxDurationInFrames}`
+    });
+  }
+  if (usage.durationSeconds > limits.maxDurationSeconds) {
+    issues.push({
+      path: ["durationInFrames"],
+      message: `scene is ${usage.durationSeconds.toFixed(2)}s; the limit is ${limits.maxDurationSeconds}s`
+    });
+  }
+  if (usage.entities > limits.maxEntities) {
+    issues.push({ path: ["objects"], message: `${usage.entities} entities; the limit is ${limits.maxEntities}` });
+  }
+  if (usage.shots > limits.maxShots) {
+    issues.push({ path: ["shots"], message: `${usage.shots} shots; the limit is ${limits.maxShots}` });
+  }
+  if (usage.hierarchyDepth > limits.maxHierarchyDepth) {
+    issues.push({
+      path: ["objects"],
+      message: `hierarchy is ${usage.hierarchyDepth} deep; the limit is ${limits.maxHierarchyDepth}`
+    });
+  }
+  if (usage.rendererAssetBytes > limits.maxRendererAssetBytes) {
+    issues.push({
+      path: ["assets"],
+      message: `downloaded scene assets total ${usage.rendererAssetBytes} bytes; the limit is ${limits.maxRendererAssetBytes}`
+    });
+  }
+  if (usage.cameraTrackBytes > limits.maxCameraTrackBytes) {
+    issues.push({
+      path: ["assets"],
+      message: `camera track data totals ${usage.cameraTrackBytes} bytes; the limit is ${limits.maxCameraTrackBytes}`
+    });
+  }
+  return issues;
+}
+function scene3DV2NormalizationIssues(plan, stats) {
+  const issues = [];
+  const limits = SCENE3D_V2_LIMITS;
+  const declared = new Map(plan.assets.map((asset) => [asset.assetId, asset]));
+  let meshNodes = 0;
+  let triangles = 0;
+  let rendererBytes = 0;
+  stats.forEach((stat, index) => {
+    const at = (...rest) => [index, ...rest];
+    const asset = declared.get(stat.assetId);
+    if (!asset) {
+      issues.push({ path: at("assetId"), message: `asset "${stat.assetId}" is not declared in the manifest` });
+      return;
+    }
+    if (stat.kind !== asset.kind) {
+      issues.push({
+        path: at("kind"),
+        message: `asset "${stat.assetId}" decoded as "${stat.kind}" but the manifest declares "${asset.kind}"`
+      });
+    }
+    if (stat.byteLength !== asset.byteLength) {
+      issues.push({
+        path: at("byteLength"),
+        message: `asset "${stat.assetId}" is ${stat.byteLength} bytes; the manifest declares ${asset.byteLength}`
+      });
+    }
+    if (stat.sha256 !== void 0 && stat.sha256 !== asset.sha256) {
+      issues.push({
+        path: at("sha256"),
+        message: `asset "${stat.assetId}" digest does not match the manifest`
+      });
+    }
+    if (SCENE3D_RENDERER_ASSET_KINDS.includes(stat.kind)) rendererBytes += stat.byteLength;
+    if (stat.kind === "camera-track-json" && stat.byteLength > limits.maxCameraTrackBytes) {
+      issues.push({
+        path: at("byteLength"),
+        message: `camera track "${stat.assetId}" decoded to ${stat.byteLength} bytes; the limit is ${limits.maxCameraTrackBytes}`
+      });
+    }
+    meshNodes += stat.meshNodes ?? 0;
+    triangles += stat.triangles ?? 0;
+    if (stat.maxNodeDepth !== void 0 && stat.maxNodeDepth > limits.maxHierarchyDepth) {
+      issues.push({
+        path: at("maxNodeDepth"),
+        message: `asset "${stat.assetId}" nests ${stat.maxNodeDepth} levels; the limit is ${limits.maxHierarchyDepth}`
+      });
+    }
+    for (const [field, value] of [
+      ["imageWidth", stat.imageWidth],
+      ["imageHeight", stat.imageHeight]
+    ]) {
+      if (value === void 0) continue;
+      if (!Number.isInteger(value) || value < limits.minPosterDimensionPx || value > limits.maxPosterDimensionPx) {
+        issues.push({
+          path: at(field),
+          message: `asset "${stat.assetId}" ${field} is ${value}; it must be an integer between ${limits.minPosterDimensionPx} and ${limits.maxPosterDimensionPx}`
+        });
+      }
+    }
+  });
+  if (meshNodes > limits.maxMeshNodes) {
+    issues.push({ path: [], message: `resolved assets contain ${meshNodes} mesh nodes; the limit is ${limits.maxMeshNodes}` });
+  }
+  if (triangles > limits.maxTriangles) {
+    issues.push({ path: [], message: `resolved assets contain ${triangles} triangles; the limit is ${limits.maxTriangles}` });
+  }
+  if (rendererBytes > limits.maxRendererAssetBytes) {
+    issues.push({
+      path: [],
+      message: `downloaded scene assets decoded to ${rendererBytes} bytes; the limit is ${limits.maxRendererAssetBytes}`
+    });
+  }
+  return issues;
+}
+function parseScene3DPlanV2Json(text) {
+  const bytes = scene3DJsonByteLength(text);
+  if (bytes > SCENE3D_V2_LIMITS.maxManifestBytes) {
+    return {
+      ok: false,
+      issues: [{ path: [], message: `manifest is ${bytes} bytes; the limit is ${SCENE3D_V2_LIMITS.maxManifestBytes}` }]
+    };
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(text);
+  } catch {
+    return { ok: false, issues: [{ path: [], message: "manifest is not valid JSON" }] };
+  }
+  const parsed = scene3DPlanV2Schema.safeParse(decoded);
+  if (!parsed.success) return { ok: false, issues: scene3DZodIssues(parsed.error) };
+  return { ok: true, value: parsed.data };
+}
+var SCENE3D_V2_CONTENT_HASH_EXCLUDED = ["revisionId", "parentRevisionId"];
+function canonicalize(value) {
+  if (value === null) return "null";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error("cannot canonicalize a non-finite number");
+    return JSON.stringify(value === 0 ? 0 : value);
+  }
+  if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((item) => canonicalize(item)).join(",")}]`;
+  if (typeof value === "object") {
+    const record = value;
+    const parts = [];
+    for (const key of Object.keys(record).sort()) {
+      const entry = record[key];
+      if (entry === void 0) continue;
+      parts.push(`${JSON.stringify(key)}:${canonicalize(entry)}`);
+    }
+    return `{${parts.join(",")}}`;
+  }
+  throw new Error(`cannot canonicalize ${typeof value}`);
+}
+function canonicalScene3DPlanV2Json(plan) {
+  const { revisionId: _revisionId, parentRevisionId: _parentRevisionId, provenance, ...rest } = plan;
+  const { contentHash: _contentHash, ...provenanceRest } = provenance;
+  return canonicalize({ ...rest, provenance: provenanceRest });
+}
+function toHex(buffer) {
+  return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function computeScene3DPlanV2ContentHash(plan) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) throw new Error("WebCrypto SubtleCrypto is required to hash a Scene3D revision");
+  const bytes = new TextEncoder().encode(canonicalScene3DPlanV2Json(plan));
+  return toHex(await subtle.digest("SHA-256", bytes));
+}
+async function verifyScene3DPlanV2ContentHash(plan) {
+  return await computeScene3DPlanV2ContentHash(plan) === plan.provenance.contentHash;
+}
+var SCENE3D_CAMERA_TRACK_FORMAT = "scene3d-camera-track";
+var SCENE3D_CAMERA_TRACK_VERSION = 1;
+var SCENE3D_CAMERA_TRACK_LIMITS = {
+  maxJsonBytes: SCENE3D_V2_LIMITS.maxCameraTrackBytes,
+  maxFrameCount: SCENE3D_V2_LIMITS.maxDurationInFrames,
+  minFps: SCENE3D_V2_LIMITS.minFps,
+  maxFps: SCENE3D_V2_LIMITS.maxFps,
+  /** A unit quaternion off by more than this is a bug, not float noise. */
+  quaternionTolerance: 1e-4,
+  /** Absolute tolerance on the projection entries that must be exactly zero
+   *  (or exactly ∓1) in a perspective matrix. */
+  projectionEpsilon: 1e-6,
+  /** Relative tolerance when comparing declared near/far against the values the
+   *  projection matrix implies. */
+  nearFarRelativeTolerance: 1e-3,
+  /** Relative tolerance on `m[0]/m[5]` vs the manifest's `height/width`. */
+  aspectRelativeTolerance: 1e-3,
+  minNear: 1e-4,
+  maxFar: 1e7
+};
+var coordinate = z.number().min(-SCENE3D_LIMITS.maxCoordinate).max(SCENE3D_LIMITS.maxCoordinate);
+var positionSchema = z.tuple([coordinate, coordinate, coordinate]);
+var scene3DCameraSampleSchema = z.object({
+  position: positionSchema,
+  quaternion: z.tuple([z.number(), z.number(), z.number(), z.number()]),
+  projectionMatrix: z.array(z.number()).length(16),
+  near: z.number().min(SCENE3D_CAMERA_TRACK_LIMITS.minNear).max(SCENE3D_CAMERA_TRACK_LIMITS.maxFar),
+  far: z.number().min(SCENE3D_CAMERA_TRACK_LIMITS.minNear).max(SCENE3D_CAMERA_TRACK_LIMITS.maxFar),
+  target: positionSchema.optional(),
+  focalLengthMm: z.number().min(SCENE3D_LIMITS.minFocalLengthMm).max(SCENE3D_LIMITS.maxFocalLengthMm).optional()
+}).strict();
+var scene3DCameraTrackObjectSchema = z.object({
+  format: z.literal(SCENE3D_CAMERA_TRACK_FORMAT),
+  version: z.literal(SCENE3D_CAMERA_TRACK_VERSION),
+  frameStart: z.literal(0),
+  frameCount: z.number().int().min(1).max(SCENE3D_CAMERA_TRACK_LIMITS.maxFrameCount),
+  fps: z.number().int().min(SCENE3D_CAMERA_TRACK_LIMITS.minFps).max(SCENE3D_CAMERA_TRACK_LIMITS.maxFps),
+  samples: z.array(scene3DCameraSampleSchema).min(1).max(SCENE3D_CAMERA_TRACK_LIMITS.maxFrameCount)
+}).strict();
+function scene3DProjectionIssues(matrix, near, far, path) {
+  const issues = [];
+  const eps = SCENE3D_CAMERA_TRACK_LIMITS.projectionEpsilon;
+  if (matrix.length !== 16) {
+    issues.push({ path, message: `projection matrix must have exactly 16 entries (got ${matrix.length})` });
+    return issues;
+  }
+  if (matrix.some((value) => !Number.isFinite(value))) {
+    issues.push({ path, message: "projection matrix contains a non-finite entry" });
+    return issues;
+  }
+  if (Math.abs(matrix[11]) < eps && Math.abs(matrix[15] - 1) < eps) {
+    issues.push({
+      path,
+      message: "projection matrix is orthographic; only perspective cameras are supported by this schema version"
+    });
+    return issues;
+  }
+  for (const index of [1, 2, 3, 4, 6, 7, 12, 13, 15]) {
+    if (Math.abs(matrix[index]) > eps) {
+      issues.push({ path: [...path, index], message: `projection matrix entry ${index} must be 0 (got ${matrix[index]})` });
+    }
+  }
+  if (Math.abs(matrix[11] + 1) > eps) {
+    issues.push({ path: [...path, 11], message: `projection matrix entry 11 must be -1 for a perspective camera (got ${matrix[11]})` });
+  }
+  if (!(matrix[0] > 0)) {
+    issues.push({ path: [...path, 0], message: `projection matrix entry 0 must be positive (got ${matrix[0]})` });
+  }
+  if (!(matrix[5] > 0)) {
+    issues.push({ path: [...path, 5], message: `projection matrix entry 5 must be positive (got ${matrix[5]})` });
+  }
+  if (!(matrix[10] < 0)) {
+    issues.push({ path: [...path, 10], message: `projection matrix entry 10 must be negative (got ${matrix[10]})` });
+  }
+  if (!(matrix[14] < 0)) {
+    issues.push({ path: [...path, 14], message: `projection matrix entry 14 must be negative (got ${matrix[14]})` });
+  }
+  if (issues.length > 0) return issues;
+  if (!(near > 0) || !(far > near)) {
+    issues.push({ path, message: `near/far must satisfy 0 < near < far (got near ${near}, far ${far})` });
+    return issues;
+  }
+  const tolerance = SCENE3D_CAMERA_TRACK_LIMITS.nearFarRelativeTolerance;
+  const impliedNear = matrix[14] / (matrix[10] - 1);
+  if (Math.abs(impliedNear - near) > Math.abs(near) * tolerance) {
+    issues.push({
+      path,
+      message: `projection matrix implies near ${impliedNear.toPrecision(6)}, but the sample declares ${near}`
+    });
+  }
+  const farDenominator = matrix[10] + 1;
+  if (Math.abs(farDenominator) < eps) {
+    issues.push({
+      path,
+      message: `projection matrix implies an infinite far plane, but the sample declares ${far}`
+    });
+  } else {
+    const impliedFar = matrix[14] / farDenominator;
+    if (Math.abs(impliedFar - far) > Math.abs(far) * tolerance) {
+      issues.push({
+        path,
+        message: `projection matrix implies far ${impliedFar.toPrecision(6)}, but the sample declares ${far}`
+      });
+    }
+  }
+  return issues;
+}
+function scene3DCameraTrackIssues(track) {
+  const issues = [];
+  if (track.samples.length !== track.frameCount) {
+    issues.push({
+      path: ["samples"],
+      message: `track declares ${track.frameCount} frames but carries ${track.samples.length} samples; exactly one sample per frame is required`
+    });
+  }
+  const quaternionTolerance = SCENE3D_CAMERA_TRACK_LIMITS.quaternionTolerance;
+  track.samples.forEach((sample, index) => {
+    const [x, y, z22, w] = sample.quaternion;
+    const norm = Math.sqrt(x * x + y * y + z22 * z22 + w * w);
+    if (Math.abs(norm - 1) > quaternionTolerance) {
+      issues.push({
+        path: ["samples", index, "quaternion"],
+        message: `quaternion at frame ${index} has length ${norm.toPrecision(6)}; it must be normalized`
+      });
+    }
+    if (!(sample.far > sample.near)) {
+      issues.push({
+        path: ["samples", index, "far"],
+        message: `frame ${index}: far (${sample.far}) must be greater than near (${sample.near})`
+      });
+    }
+    for (const issue2 of scene3DProjectionIssues(
+      sample.projectionMatrix,
+      sample.near,
+      sample.far,
+      ["samples", index, "projectionMatrix"]
+    )) {
+      issues.push(issue2);
+    }
+  });
+  return issues;
+}
+var scene3DCameraTrackSchema = scene3DCameraTrackObjectSchema.superRefine((track, ctx) => {
+  for (const issue2 of scene3DCameraTrackIssues(track)) {
+    ctx.addIssue({ code: "custom", path: issue2.path, message: issue2.message });
+  }
+});
+function isScene3DCameraTrack(value) {
+  return scene3DCameraTrackSchema.safeParse(value).success;
+}
+function scene3DCameraTrackPlanIssues(track, plan) {
+  const issues = [];
+  if (track.fps !== plan.fps) {
+    issues.push({
+      path: ["fps"],
+      message: `camera track is ${track.fps} fps but the scene is ${plan.fps} fps; changing fps requires an explicit resample and a new revision`
+    });
+  }
+  if (track.frameCount !== plan.durationInFrames) {
+    issues.push({
+      path: ["frameCount"],
+      message: `camera track covers ${track.frameCount} frames but the scene is ${plan.durationInFrames} frames`
+    });
+  }
+  const expected = plan.height / plan.width;
+  const tolerance = SCENE3D_CAMERA_TRACK_LIMITS.aspectRelativeTolerance;
+  track.samples.forEach((sample, index) => {
+    const m0 = sample.projectionMatrix[0];
+    const m5 = sample.projectionMatrix[5];
+    if (!Number.isFinite(m0) || !Number.isFinite(m5) || m5 === 0) return;
+    const actual = m0 / m5;
+    if (Math.abs(actual - expected) > expected * tolerance) {
+      issues.push({
+        path: ["samples", index, "projectionMatrix"],
+        message: `frame ${index}: projection is baked for aspect ${(1 / actual).toPrecision(6)} but the scene renders ${plan.width}\xD7${plan.height}; reprojection requires a new revision`
+      });
+    }
+  });
+  return issues;
+}
+function scene3DSampleForFrame(track, frame) {
+  if (!Number.isInteger(frame) || frame < 0 || frame >= track.frameCount) return void 0;
+  return track.samples[frame];
+}
+function parseScene3DCameraTrackJson(text) {
+  const bytes = scene3DJsonByteLength(text);
+  if (bytes > SCENE3D_CAMERA_TRACK_LIMITS.maxJsonBytes) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: [],
+          message: `camera track is ${bytes} bytes; the limit is ${SCENE3D_CAMERA_TRACK_LIMITS.maxJsonBytes}`
+        }
+      ]
+    };
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(text);
+  } catch {
+    return { ok: false, issues: [{ path: [], message: "camera track is not valid JSON" }] };
+  }
+  const parsed = scene3DCameraTrackSchema.safeParse(decoded);
+  if (!parsed.success) {
+    return { ok: false, issues: scene3DZodIssues(parsed.error) };
+  }
+  return { ok: true, value: parsed.data };
+}
 
 // src/studio-transient.ts
 var STUDIO_TRANSIENT_KEYS = [
@@ -14723,7 +16387,141 @@ function stripStudioTransientSettings(settings) {
   }
   return { ...settings, studio: kept };
 }
+var scene3DV2OverrideInputSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("entity-transform"),
+    entityId: scene3DIdSchema,
+    space: z.enum(["local", "world"]),
+    position: vec3Schema.optional(),
+    rotation: rotationVec3Schema.optional(),
+    scale: scaleVec3Schema.optional()
+  }).strict(),
+  z.object({
+    kind: z.literal("entity-color"),
+    entityId: scene3DIdSchema,
+    materialRole: scene3DMaterialRoleSchema,
+    color: scene3DColorSchema
+  }).strict(),
+  z.object({ kind: z.literal("entity-visibility"), entityId: scene3DIdSchema, visible: z.boolean() }).strict(),
+  z.object({
+    kind: z.literal("camera-shot-offset"),
+    shotId: scene3DIdSchema,
+    positionOffset: vec3Schema.optional(),
+    targetOffset: vec3Schema.optional()
+  }).strict()
+]);
+var scene3DV2EditOperationSchema = z.discriminatedUnion("op", [
+  z.object({ op: z.literal("set-override"), override: scene3DV2OverrideInputSchema }).strict(),
+  z.object({ op: z.literal("remove-override"), overrideId: scene3DIdSchema }).strict()
+]);
+var scene3DV2EditOperationsSchema = z.array(scene3DV2EditOperationSchema).min(1).max(100);
+function channel(override) {
+  switch (override.kind) {
+    case "entity-transform":
+      return `transform:${override.entityId}`;
+    case "entity-color":
+      return `color:${override.entityId}:${override.materialRole}`;
+    case "entity-visibility":
+      return `visibility:${override.entityId}`;
+    case "camera-shot-offset":
+      return `camera:${override.shotId}`;
+  }
+}
+function capability(override) {
+  switch (override.kind) {
+    case "entity-transform":
+      return "transform";
+    case "entity-color":
+      return "color";
+    case "entity-visibility":
+      return "visibility";
+    case "camera-shot-offset":
+      return null;
+  }
+}
+function lockIssue(plan, override, externalLocks) {
+  if (override.kind === "camera-shot-offset") return null;
+  const target = plan.objects.find((o) => o.id === override.entityId);
+  if (!target) return `Unknown entity: ${override.entityId}`;
+  const cap = capability(override);
+  if (target.capabilities && !target.capabilities.includes(cap)) return `Entity ${target.id} does not allow ${cap} edits`;
+  if (externalLocks.has(target.id) || target.locks?.includes(cap)) return `Entity ${target.id} is locked for ${cap}`;
+  if (cap !== "transform" && cap !== "visibility") return null;
+  const byId = new Map(plan.objects.map((entity) => [entity.id, entity]));
+  for (const entity of plan.objects) {
+    if (!externalLocks.has(entity.id) && !entity.locks?.includes(cap)) continue;
+    let parent = entity.parentId;
+    while (parent) {
+      if (parent === target.id) return `Changing ${target.id} would change locked descendant ${entity.id}`;
+      parent = byId.get(parent)?.parentId;
+    }
+  }
+  return null;
+}
+async function applyScene3DV2EditOperations(input, operations, options) {
+  const parsed = scene3DPlanV2Schema.safeParse(input);
+  if (!parsed.success) return { ok: false, code: "invalid_plan", message: parsed.error.issues[0]?.message ?? "Invalid scene" };
+  const base = parsed.data;
+  if (base.revisionId !== options.expectedRevisionId || options.expectedContentHash !== void 0 && base.provenance.contentHash !== options.expectedContentHash) {
+    return { ok: false, code: "stale_revision", message: "The scene changed since this edit was prepared" };
+  }
+  if (!await verifyScene3DPlanV2ContentHash(base)) {
+    return { ok: false, code: "invalid_plan", message: "The scene content does not match its digest" };
+  }
+  const ops = scene3DV2EditOperationsSchema.safeParse(operations);
+  if (!ops.success) return { ok: false, code: "invalid_operations", message: ops.error.issues[0]?.message ?? "Invalid edit" };
+  const revisionId = options.newRevisionId ?? newScene3DRevisionId();
+  if (revisionId === base.revisionId) return { ok: false, code: "invalid_operations", message: "An edit requires a new revision identity" };
+  const externalLocks = new Set(options.lockedObjectIds ?? []);
+  for (const id of externalLocks) {
+    if (!base.objects.some((entity) => entity.id === id)) return { ok: false, code: "invalid_operations", message: `Unknown locked entity: ${id}` };
+  }
+  let overrides = [...base.overrides ?? []];
+  for (const [index, operation] of ops.data.entries()) {
+    if (operation.op === "remove-override") {
+      const existing = overrides.find((override) => override.id === operation.overrideId);
+      if (!existing) return { ok: false, code: "invalid_operations", message: `Unknown override: ${operation.overrideId}` };
+      const issue3 = lockIssue(base, existing, externalLocks);
+      if (issue3) return { ok: false, code: "locked", message: issue3 };
+      overrides = overrides.filter((override) => override.id !== existing.id);
+      continue;
+    }
+    const issue2 = lockIssue(base, operation.override, externalLocks);
+    if (issue2) return { ok: false, code: "locked", message: issue2 };
+    const previous = overrides.find((override) => channel(override) === channel(operation.override));
+    const compatible = previous && (previous.kind !== "entity-transform" || operation.override.kind === "entity-transform" && previous.space === operation.override.space);
+    const next2 = {
+      ...compatible ? previous : {},
+      ...operation.override,
+      id: `edit-${revisionId}-${index}`,
+      sourceRevisionId: base.revisionId,
+      sourceContentHash: base.provenance.contentHash,
+      operationVersion: SCENE3D_V2_OVERRIDE_OPERATION_VERSION
+    };
+    const key = channel(next2);
+    overrides = [...overrides.filter((override) => channel(override) !== key), next2];
+  }
+  const { sourceArtifactId: _sourceArtifactId, ...provenance } = base.provenance;
+  const next = {
+    ...base,
+    revisionId,
+    parentRevisionId: base.revisionId,
+    // Geometry and cameras are reused; derived images, validation and native
+    // exports describe the old revision until regenerated for these overlays.
+    assets: base.assets.filter((asset) => asset.kind === "glb" || asset.kind === "camera-track-json").map((asset) => ({
+      ...asset,
+      originRevisionId: asset.originRevisionId ?? base.revisionId
+    })),
+    overrides,
+    provenance: { ...provenance, sourceRevisionId: base.revisionId }
+  };
+  const validated = scene3DPlanV2Schema.safeParse(next);
+  if (!validated.success) return { ok: false, code: "invalid_operations", message: validated.error.issues[0]?.message ?? "Invalid edited scene" };
+  const plan = validated.data;
+  const contentHash = await computeScene3DPlanV2ContentHash(plan);
+  return { ok: true, plan: { ...plan, provenance: { ...plan.provenance, contentHash } }, changeSummary: `Applied ${ops.data.length} scene edit${ops.data.length === 1 ? "" : "s"}` };
+}
 
-export { ACCESS_LEVELS, ACTIVE_SCENE_HELPERS, ADVANCED_MODE_UNAVAILABLE_REASON, AGGREGATEABLE_TYPES, AGGREGATE_LANE_SOURCE_TYPES, AI_AVATAR_DURATION_BUCKETS, AI_AVATAR_MAX_AUDIO_SEC, AI_AVATAR_MAX_DURATION_SEC, AI_AVATAR_RESERVE_IDS, AI_WRITER_PROVIDERS, ALA_CARTE_BOARDS, ALL_CAPTION_STYLES, ANIMALS, ANIMAL_SUBCATEGORY_LABELS, ANIMAL_SUBCATEGORY_ORDER, ASPECT_RATIO_DIMENSIONS, AUDIO_ADDON_PROVIDERS, AUDIO_CROSSFADE_CURVES, AUDIO_CROSSFADE_CURVE_IDS, AUDIO_FX_PRESETS, AUDIO_FX_PRESET_LABELS, AUDIO_FX_PRESET_SET, AUDIO_FX_REVERB_PRESETS, AUDIO_PRODUCER_TYPES, AddBRollResultSchema, AnchorSceneStyleResultSchema, AssetRefSchema, AuditImagesResultSchema, AuditImagesShotEntrySchema, AuditPromptIssueSchema, AuditPromptResultSchema, AvatarPayloadError, BOARD_TO_ASSET_TYPE, BOARD_TO_COLUMN, BOARD_VARIANTS, BridgeToNextSceneInputSchema, BridgeToNextSceneResultSchema, CATEGORY_DURATION_DEFAULTS, CHARACTER_ASPECT_DEFAULTS, CHARACTER_ASPECT_OPTIONS, CHARACTER_ASSET_TYPES, CHARACTER_ASSET_VARIANTS, CHARACTER_ATTACH_COLUMNS, CHARACTER_FACETS, CHARACTER_FACET_IDS, CHARACTER_LORA_TRAINING_JOB_TYPE, CHARACTER_MOTION_PROVIDERS, CHARACTER_PICKER_DISPLAY_ORDER, CHARACTER_REFERENCE_PHOTO_KINDS, CHARACTER_STYLES, CHARACTER_VARIANT_ASSET_BUCKETS, CHAT_ENABLED_STAGES, CHAT_STAGES, CHAT_TURN_CAPS, CHAT_WIRED_STAGES, CINEMATIC_DEFAULT_DURATION_SEC, CINEMATIC_DEFAULT_RESOLUTION, CINEMATIC_MAX_DURATION_SEC, CINEMATIC_MAX_LOOKS, CINEMATIC_MAX_REFERENCE_IMAGES, CINEMATIC_MAX_REFERENCE_VIDEOS, CINEMATIC_MIN_DURATION_SEC, CINEMATIC_MIN_LOOKS, CINEMATIC_PROMPT_MAX, CINEMATIC_RESERVE_IDS, COLLABORATOR_ROLES, COLLECT_IN_HANDLE, COMBINE_TRANSITIONS, COMBINE_TRANSITION_GROUP_LABELS, COMBINE_TRANSITION_GROUP_ORDER, COMBINE_TRANSITION_IDS, COMPOSER_PLAN_FIELDS, COMPOSER_PLAN_MAP, CONTENT_TYPES_BY_PLATFORM, CREATURE_ATTACH_COLUMNS, CREDIT_BASE_USD, CREDIT_ROUNDING_RESOLUTION, CastCoverageCriticVerdictSchema, CharacterImageCriticVerdictSchema, CharacterMetadataSchema, ChatTurnResponseSchema, CriticIssueSchema, DEFAULT_AUDIO_CROSSFADE_CURVE_ID, DEFAULT_CARRIED_FRACTION, DEFAULT_CHARACTER_ANGLE_COUNT, DEFAULT_CHARACTER_EXPRESSION_COUNT, DEFAULT_CHARACTER_FACET, DEFAULT_LABEL_BY_SOURCE, DEFAULT_LOCATION_USAGE_MODE, DEFAULT_PANEL_COUNT, DEFAULT_REF_IMAGE_MAX, DEFAULT_SECTIONS, DEFAULT_USAGE_MODE, DEFAULT_VIDEO_ANALYSIS_MODEL, DEFAULT_VIDEO_ANALYSIS_TIER, DEFAULT_VIDEO_CLIP_COST, DEFAULT_VIDEO_DURATION_SEC, DEFAULT_VIDEO_PROVIDER, DEFAULT_VOICE_CHANGER_MODEL, DEFAULT_VOICE_DESIGN_MODEL, DETAIL_VARIANTS, DURATION_PRICED_PROVIDERS, DYNAMIC_PRODUCER_TYPES, DetectionResultSchema, EFFORT_TIER_BUMP, EMOTIONAL_BEAT, ENTITY_ASPECT_DEFAULTS, ENTITY_BUCKET_FIELDS, ENTITY_DB_ID_FIELD, ENTITY_IMAGE_HANDLE_TYPES, ENTITY_KIND_SCALAR_FIELDS, ENTITY_NAME_FIELD, ENTITY_NODE_KINDS, ENTITY_SCALAR_FIELDS, ENTITY_SECTIONS, ENTITY_STATUSES, ENTITY_TABLE, ENTITY_TOOL_RETRY_CAP, ENTITY_TYPES, EXECUTION_DATA_KEYS, EXTEND_VIDEO_PROVIDERS, EntityMetadataSchema, EntityRejectInputSchema, EntityStaleEventSchema, EntityStateChangeEventSchema, FACE_SWAP_PROVIDERS, FAL_LIP_SYNC_PROVIDERS, FAN_OUT_EACH_TYPES, FEATURED_ENTITIES, FILM_BASE_CREDITS, FLEXIBLE_INPUT_LIP_SYNC_PROVIDERS, FLUX2_RES_MP, FLUX_LORA_CHARACTER_MODEL_ID, FRAME_MODE_ADAPTIVE_ONLY_ASPECT, FRAME_TARGET_HANDLES, FREECUT_EXPORT_COMPLETE, FREECUT_EXPORT_PROGRESS, FREECUT_READY, FREECUT_REQUEST_IMPORT, FURNITURE, FURNITURE_SUBCATEGORY_LABELS, FURNITURE_SUBCATEGORY_ORDER, FixContinuityInputSchema, FixContinuityResultSchema, GEMINI_OMNI_PROVIDERS, GENERATE_TEXT_DELIMITER, GLOBAL_MAX_DURATION_SECONDS, GRANTED_ACCESS, GROUP_HANDLE_PREFIX, GUIDANCE_SCALE_SUPPORT, GVP_ANCHOR_CHOICES, GVP_DEFAULT_PROVIDER, GVP_END_FRAME_PROVIDERS, GVP_EXTEND_PROVIDERS, GVP_SUPPORTED_PROVIDERS, GenerateMotionInputSchema, GenerateMotionResultSchema, HANDLE_PORT_SEPARATOR, HELPERS_SHIPPED_IN_1B3, HIGH_QUALITY_PROVIDERS, HINT_EXEMPT_PARAMETER_TYPES, I2I_MASK_SUPPORT, I2I_STRENGTH_SUPPORT, IDEOGRAM_PROVIDERS, IMAGE_ASPECT_RATIO_VALUES, IMAGE_CRITIC_LEAF_MODES, IMAGE_CRITIC_MAX_RETRIES, IMAGE_CRITIC_METADATA_KEYS, IMAGE_CRITIC_MIN_ADHERENCE_SCORE, IMAGE_CRITIC_MODES, IMAGE_CRITIC_UNRESOLVABLE, IMAGE_EDIT_PROVIDERS, IMAGE_GEN_PROVIDERS, IMAGE_I2I_PROVIDERS, IMAGE_MASK_MODE, IMAGE_PROMPT_MAX, IMAGE_REF_TYPES, IMAGE_TO_VIDEO_PROVIDERS, INPUT_FIELD_MAP2 as INPUT_FIELD_MAP, INPUT_NODE_TYPES, INSTAGRAM_CAROUSEL_MAX_ITEMS, INSTAGRAM_CAROUSEL_MIN_ITEMS, ITER_CLONE_PATTERN, ImageCriticIssueSchema, ImageCriticResultSchema, ImageCriticVerdictSchema, ImprovePromptInputSchema, ImprovePromptResultSchema, KEYFRAME_CREDITS_PER_SHOT, KINETIC_CAPTION_STYLES, LANGUAGES, LEGACY_LOTTIE_HOST_REMAP, LIP_SYNC_DURATION_BUCKETS, LIP_SYNC_MAX_AUDIO_SECONDS, LIP_SYNC_PROVIDERS, LLM_FEATURE_DEFAULTS, LLM_MODALITY_CAPS, LLM_MODELS, LLM_MODEL_IDS, LLM_REASONING_EFFORTS, LLM_ROUTE_DEFAULTS, LLM_TEXT_INPUT_MAX, LLM_VENDOR_LABELS, LLM_VENDOR_ORDER, LOCATION_ASSET_TYPES, LOCATION_ASSET_VARIANTS, LOCATION_ATMOSPHERE_PROVIDERS, LOCATION_ATTACH_COLUMNS, LOCATION_BUCKET_TO_CATALOG_ID, LOCATION_PRESET_TO_CATALOG, LOCATION_REFERENCE_PHOTO_KINDS, LOCATION_REFERENCE_PHOTO_KIND_LABELS, LOCATION_USAGE_MODES, LOTTIE_OVERLAY_CATALOG, LOTTIE_SLOT_FIELD_PREFIX, LocationImageCriticVerdictSchema, LocationMetadataSchema, LocationsCoverageCriticIssueSchema, LocationsCoverageCriticVerdictSchema, MAX_CUSTOM_ENTRIES_PER_BOARD, MAX_IMAGE_PROMPT_CHARS_BY_PROVIDER, MAX_LOCATION_VARIANTS, MAX_NEGATIVE_PROMPT_CHARS_BY_PROVIDER, MAX_PANELS_PER_SHEET, MAX_TTS_CHARS_BY_PROVIDER, MAX_VIDEO_PROMPT_CHARS_BY_PROVIDER, MEMBER_STATUSES, MINIMAX_H3_DEFAULT_RESOLUTION, MINIMAX_H3_PROVIDERS, MODELS_WITH_REFERENCE_IMAGE_SUPPORT, MODEL_CATALOG, MODEL_PARAM_NODE_TYPES, MODEL_RECOMMENDATIONS, MODIFY_IMAGE_PROVIDERS, MOTION_COLUMN, MOTION_TRANSFER_PROVIDERS, MUSIC_PROVIDERS, MatchCutVerdictSchema, NATIVE_ADAPTIVE_ASPECT, NATIVE_NEGATIVE_PROMPT_MODELS, NATIVE_NEGATIVE_VIDEO_PROVIDERS, NEGATIVE_PROMPT_MAX, NODARO_IMPORT_FILES, NODARO_LOAD_TIMELINE, NODARO_LOAD_VIDEO, NODARO_RESET_PROJECT, NODE_DEFAULT_TYPES, NODE_MAPPABLE_FIELDS, NODE_PRESET_EXPORT_KIND, NODE_REF_PATTERN, NON_EN_LOCALE_IDS, NO_SPLIT_DELIMITER, OBJECT_ASPECT_DEFAULTS, OBJECT_ASPECT_OPTIONS, OBJECT_ASSET_TYPES, OBJECT_ASSET_VARIANTS, OBJECT_ATTACH_COLUMNS, OBJECT_MOTION_PROVIDERS, OBJECT_PICKER_NODE_TYPES, ORG_ERROR_CODES, ORG_KINDS, ORG_ROLES, ORG_STATUSES, OUTPUT_FIELD_MAP, OUTPUT_FORMATS, ObjectMetadataSchema, OptimizeForModelInputSchema, OptimizeForModelResultSchema, OrgSettingsSchema, PARAMETER_NODE_TYPES, PASSTHROUGH_TYPES, PAYG_RETENTION_DAYS, PER_FORMAT_DURATION_BOUNDS, PICKER_TO_COMBINE_TRANSITION, PIPELINE_ACTIVATION_MODES, PIPELINE_FORMATS, PIPELINE_HARD_TIMEOUT_MS, PIPELINE_MODEL_STAGES, PIPELINE_MODES, PIPELINE_OUTPUT_RESOLUTIONS, PIPELINE_PINNABLE_IMAGE_MODELS, PIPELINE_PINNABLE_SCRIPT_LLMS, PIPELINE_PINNABLE_VIDEO_MODELS, PIPELINE_STAGE_NAMES, PIPELINE_STAGE_TIMEOUT_MS, PIPELINE_TYPES, PLACEHOLDER_CHARACTER_NAME, PLATFORM_LABELS, PLATFORM_SPECS, PRESET_APPLY_CLEAR_KEYS, PRESET_EXCLUDED_KEYS, PRESET_LABELS, PRESET_SETTING_KEYS, PRICING_DEFAULT_DURATION_SEC, PRICING_DEFAULT_RESOLUTION, PROMPT_HARD_CEILING, PROMPT_PREFIX_KEY, PROMPT_SUFFIX_KEY, PROVIDER_DIRECTIVE_DEFAULTS, PROVIDER_PLACEHOLDER_PREFIX, PipelineCompletedEventSchema, PipelineConfigSchema, PipelineDriftSummarySchema, PipelineEditorDecisionsReadyEventSchema, PipelineForkedEventSchema, PipelineInputSchema, PipelineMusicReadyEventSchema, PipelineStageNameSchema, PipelineStageStatusSchema, PipelineStateSchema, PipelineStatusSchema, PresetSettingsSchema, QA_CHECK_PROVIDERS, REDUCE_STRATEGIES, REDUCE_STRATEGY_IDS, REFERENCE_BOARD_PROVIDERS, REFERENCE_BOARD_TEMPLATES, REFERENCE_HANDLE_MAP, REFERENCE_ROLE_PRESETS, REF_HANDLE_CATEGORY, REF_IMAGE_MAX_LIMITS, REF_TOKEN_NAMESPACE_PREFIXES, RENDERING_SPEED_SUPPORT, REPEATABLE_NODE_TYPES, REPEAT_PLACEHOLDER, REPLICATE_LIP_SYNC_PROVIDERS, RESERVED_TEMPLATE_VARS, SCENE_HELPER_NAMES, SCRAPER_ACTOR_LABELS, SCRAPER_CREDIT_COSTS, SCRAPER_OUTPUT_FIELDS, SCRIPT_PROVIDERS, SEASONS, SECTION_BOARD, SECTION_KINDS, SEEDANCE_2_5_REF_LIMITS, SEEDANCE_2_CONTINUATION_REF_SEC, SEEDANCE_2_EXTEND_STITCH, SEEDANCE_2_PROVIDERS, SEEDANCE_2_R2V_MAX_AUDIO_SEC_BY_PROVIDER, SEEDANCE_2_R2V_MIN_REF_VIDEO_SEC, SEEDANCE_2_REF_LIMITS, SEEDANCE_LIP_SYNC_PROVIDERS, SEED_SUPPORT, SEPARATOR_DISPLAY, SEPARATOR_PRESETS, SHEET_ASPECTS, SHEET_BACKGROUNDS, SHEET_PRESETS, SHEET_SKINS, SHEET_TYPES, SHORT_FILM_ANGLE_COUNT, SHORT_FILM_EXPRESSION_COUNT, SHORT_FILM_VARIANT_THRESHOLD_SEC, SLOT_TOKEN_RE, SMART_CUT_WINDOW_DEFAULT, SMART_CUT_WINDOW_MAX, SMART_CUT_WINDOW_MIN, SOCIAL_POST_NODE_TYPES, STAGE_PATCH_SCHEMA, STATIC_CAPTION_STYLES, STRUCTURAL_SECTIONS, STRUCTURED_VISION_MODELS, STUDIO_SHOT_TRANSIENT_KEYS, STUDIO_TRANSIENT_KEYS, SUBMISSION_STATUSES, SUNO_ADD_TRACK_MODELS, SUNO_FIELD_HANDLE_FIELDS, SUNO_HARD_CEILING, SUNO_MODELS, SUNO_SELECT_OPERATIONS, SUNO_TEXT_MAX, SUNO_TITLE_MAX, SUNO_TRACK_SOURCE_TYPES, SUNO_VERSION_PRICED_OPERATIONS, SUPPORTED_FONT_NAMES, SURROUND_DIRECTIONS, SWITCHX_BLOCK_FRAMES, SWITCHX_FRAME_TIERS, SceneHelperNameSchema, SceneInputModeSchema, SceneMetadataSchema, SceneNodeDataSchema, SceneSpecSchema, ScriptCriticVerdictSchema, ShotSpecSchema, ShowrunnerPlanSchema, StageAwaitingSubGateEventSchema, StoryboardCohesionCriticVerdictSchema, StyleDirectivesSchema, SubGateNameSchema, T2I_TO_I2I_VARIANT, TASK_CHAINED_EDIT_PROVIDERS, TEXT_TO_AUDIO_PROVIDERS, TEXT_TO_VIDEO_PROVIDERS, TIER_MAX_PIPELINE_COST_CREDITS, TIER_PIPELINE_PARALLELISM, TILT_CARRIED_FRACTION, TOPAZ_DEFAULT_UPSCALE_FACTOR, TOPAZ_UPSCALE_FACTORS, TRANSCRIBE_PROVIDERS, TRANSIENT_RUNTIME_KEYS, TTS_PROVIDERS, TTS_TEXT_MAX, TWO_K_RESOLUTION_PROVIDERS, TransitionTypeSchema, UPSCALE_IMAGE_PROVIDERS, USAGE_GROUP_BYS, USAGE_MODES, VARIABLES_HANDLE_ID, VARIABLE_PRICING_MODELS, VEHICLES, VEHICLE_SUBCATEGORY_LABELS, VEHICLE_SUBCATEGORY_ORDER, VEO_PROVIDERS, VIDEO_ANALYSIS_AUDIO_MODES, VIDEO_ANALYSIS_BUCKET_CREDITS, VIDEO_ANALYSIS_CLIP_TRANSITIONS_IN, VIDEO_ANALYSIS_DEFAULT_VARIATION, VIDEO_ANALYSIS_DURATION_BUCKETS, VIDEO_ANALYSIS_DURATION_TOLERANCE_SEC, VIDEO_ANALYSIS_ENTITY_SOURCES, VIDEO_ANALYSIS_FACELESS_ANGLES, VIDEO_ANALYSIS_LEGACY_MODELS, VIDEO_ANALYSIS_LLM_MODELS, VIDEO_ANALYSIS_MAX_DURATION_SEC, VIDEO_ANALYSIS_MAX_SCENE_SEC, VIDEO_ANALYSIS_MAX_VARIATIONS, VIDEO_ANALYSIS_MIXED_TIERS, VIDEO_ANALYSIS_SHOT_ANGLES, VIDEO_ANALYSIS_SPEED_EFFECTS, VIDEO_ANALYSIS_STORY_JUMPS, VIDEO_ANALYSIS_TEXT_KINDS, VIDEO_ANALYSIS_TIERS, VIDEO_ANALYSIS_TIER_LABELS, VIDEO_ANALYSIS_TIER_ORDER, VIDEO_ANALYSIS_TIMES_OF_DAY, VIDEO_ANALYSIS_TRANSITIONS, VIDEO_ANALYSIS_VARIATION_SLUGS, VIDEO_ANALYSIS_VISUAL_EFFECTS, VIDEO_ANALYSIS_WINDOW, VIDEO_AUDIO_CAPABILITY, VIDEO_AUDIT_BUCKET_CREDITS, VIDEO_CLIP_CREDITS, VIDEO_CRITIC_CREDITS_PER_SHOT, VIDEO_CRITIC_FRAME_MODES, VIDEO_CRITIC_MAX_RETRIES, VIDEO_CRITIC_METADATA_KEYS, VIDEO_CRITIC_MIN_ADHERENCE_SCORE, VIDEO_DURATION_TIERS, VIDEO_GEN_COLLAPSED_T2V_IDS, VIDEO_GEN_PROVIDERS, VIDEO_INPUT_LIP_SYNC_PROVIDERS, VIDEO_MODEL_CAPS, VIDEO_MODE_ALIASES, VIDEO_PRODUCER_TYPES, VIDEO_PROMPT_MAX, VIDEO_PROVIDERS_REQUIRING_IMAGE, VIDEO_PROVIDERS_WITHOUT_DISPATCH, VIDEO_REF_LIMITS_BY_PROVIDER, VIDEO_REF_VIDEO_DURATION_LIMITS, VIDEO_TO_VIDEO_PROVIDERS, VIDEO_UPSCALE_PROVIDERS, VIDEO_UTIL_PRICING, VIDEO_VARIABLE_PRICING, VOICE_CHANGER_MODELS, VOICE_CHANGER_MODEL_IDS, VOICE_DESIGN_MODELS, ValidateMatchCutInputSchema, ValidateMatchCutResultSchema, VideoCriticVerdictSchema, VoiceMatchSchema, WAN_3_DEFAULT_RESOLUTION, WAN_3_PROVIDERS, WARDROBE_VARIANTS, WEAPONS, WEAPON_SUBCATEGORY_LABELS, WEAPON_SUBCATEGORY_ORDER, WORKFLOW_VISIBILITIES, WORKSPACE_HEADER, WORKSPACE_HEADER_LOWER, WORKSPACE_ROLES, WorkspaceSettingsSchema, aggregateByType, aiAvatarReserveCreditId, analyzedSceneSchema, applyDefaultVideoSelection, applyHandleInputOverride, applyRange, applyRangeIndices, applySlots, applyVideoAudioToggle, applyVideoNegativePrompt, aspectRatioFromDims, aspectRatioOptionsByKind, aspectRatioToNumber, assembleNarratedVideoCredits, availableReasoningEfforts, bucketSecondsFromAuditCreditId, bucketSecondsFromCreditId, buildBoardPrompt, buildChildrenByParent, buildConditionVariables, buildCreditModelIdentifier, buildExpressionFromVisual, buildLipSyncCreditId, buildLlmCreditIdentifier, buildModelMenu, buildModelTree, buildMotionCreditModelIdentifier, buildNodePresetExport, buildPanelPrompt, buildProgressSegments, buildRangeLabel, buildScraperCreditId, buildVideoAnalysisCreditId, buildVideoAuditCreditId, buildVideoCreditModelIdentifier, calculateCombinedProgress, calculateMonetizationMarkup, calculateMonetizedCost, calculateProgress, canonicalVarName, characterBoardItems, characterBucketDisplayRank, characterMentionSlug, characterMentionableAssetArrays, characterSheetRefItems, characterVariantAssetArrays, checkRefVideoDurations, cinematicCreditId, clampCinematicDuration, clampSmartCutWindow, classifyRefToken, cleanOrphanedItems, clearImageCriticMetadata, clearVideoCriticMetadata, clipLookSchema, collectAncestorRefs, combineSameLabelRefs, computeAggregateLanes, countRefModalityEdges, creditRangesAll, creditsToUsd, decodeProviderItem, defaultCarriedFraction, defaultResolutionFor, defaultRoleForSource, defaultVideoAspectRatio, deriveLinkedFields, deriveLottieSlotFields, deriveSlotRefs, describeEdgeBehavior, describeMaskRegion, describeNodeAdjustments, describeSlotControl, dropUnknownBindings, dropUnknownSpeakers, durationsByMode, effectiveReasoningEffort, encodeProviderItem, ensureLocaleCatalogLoaded, entityHydrationColumns, entityMentionSlug, entityMentionSlugForRef, entityScalarFields, entitySlotSchema, entryMatchesQuery, estimateCombineVideosCredits, estimateFilmCredits, estimateLoopTrimAddonCredits, estimateLoopVideoCredits, estimateScriptDurationSec, estimateSheetCost, estimateTrimVideoCredits, evaluateCondition, evaluateConditionGroup, evaluateJsonExpression, evaluateJsonPath, expandExtraRefsToConnectedReferences, expandItemsWithRepeat, extractAllGeneratedResults, extractCharacterLoraFields, extractGeneratedJsonAsList, extractPresetData, extractReferencedLabels, extractVideoDurationFromNode, fieldKeyFromHandle, filterCloneNodes, findCharacterMentionTokens, findEntityMentionTokens, findImageMentionTokens, findLocationMentionTokens, findSeedance2AudioOverLimit, firstSightExtraRole, flattenItems, getAnimal, getAnimalLabel, getAnimalPromptHint, getAnimalTerm, getAspectRatioOptions, getAudioCrossfadeCurve, getCharacterFacet, getCombineTransition, getCreditRange, getDurationsForModel, getEffectiveRepeatCount, getFeaturedEntities, getFurniture, getFurnitureLabel, getInputFieldSchema, getInputNodes, getItemSortId, getLipSyncMaxAudioSeconds, getLlmModalityCaps, getLlmModel, getLlmTier, getLocaleDirection, getMaxImagePromptChars, getMaxNegativePromptChars, getMaxSunoPromptChars, getMaxSunoStyleChars, getMaxTtsChars, getMaxVideoPromptChars, getModel, getNodeLabel, getNodeResult, getOutputNodes, getOutputType, getParameterValue, getQualityOptions, getResolutionOptions, getRouteReachableNodeIds, getStrategy, getTargetField, getValidValues, getVehicle, getVehicleLabel, getVideoAudioCapability, getWeapon, getWeaponLabel, groupByFamily, groupHandleId, groupLlmModelsByVendor, hasContiguousSegmentDurations, hasFeature, hexToRgbaArray, humanizeSlotSid, imageMentionSlug, imageMentionSlugForRef, imageReferenceLimit, inferMusicVideo, isAggregateableType, isCharacterAspectRatio, isCollectInEdge, isDefaultSelectorConfig, isExpandedClone, isFlux2Model, isGeminiOmniProvider, isGvpSupportedProvider, isHandleInputWired, isKineticCaptionStyle, isLocationUsageMode, isMinimaxH3Provider, isObjectAspectRatio, isOversizedScene, isPaygRetentionActive, isPerSecondLipSyncProvider, isScraperActor, isSeedance2Provider, isTiltDirection, isUsageMode, isVeoProvider, isVideoAnalysisMixedTier, isVideoAnalysisTier, isWan3Provider, jsonResultToList, knownEntitySlugsFromRefs, knownImageSlugsFromRefs, listBoardTemplates, listModels, listSlotSids, llmRouteDefaults, locationMentionSlug, locationReferencePhotoKindLabel, locationUsageModeLabel, mapAspectRatio, mapQuality, mapShotIntentToProviderDirectives, matchVariant, maxSegmentSecFor, maxSegmentsFor, mergeClipLook, mergeExposedSettings, migrateEdgeOutputMode, migrateToItems, minSegmentSecFor, modelIdsByKindMode, modelToNodeTarget, modelsForInputMode, modelsWithFeature, motionGraphicsFeature, normalizeLottieLayers, normalizeMinimaxH3Resolution, normalizeModelInput, normalizeNodeModelParams, normalizePinterestUrl, normalizeRoleSlug, normalizeVideoRequestParams, normalizeWan3Resolution, orderedLlmModels, parseAttributedDialogue, parseCharacterMentionToken, parseEntityMentionToken, parseGroupHandle, parseHandleId, parseImageMentionToken, parseListExpression, parseLocationMentionToken, parseNodePresetExport, parseNodeRef, pickAiAvatarBucket, pickIds, pickLipSyncBucket, pickSwitchXFrameTier, pickVideoAnalysisBucket, planSheetGeneration, planSheetPanels, preferredInputModeForModel, presentTypes, presetApplyClearKeys, presetDataMatches, presetEntries, pricedVideoSelection, qualityOptionsByKind, readPromptAffixes, refHandleCategory, referenceModalityForHandle, referenceSheetCreditId, registerCatalogSidecars, registerSidecarLoaders, renderAnalyzedScene, resetCatalogSidecars, resolutionOptionsByKind, resolveAiAvatarCreditId, resolveAudioCrossfadeCurve, resolveCharacterAspectRatio, resolveCinematicCreditId, resolveConditionValue, resolveDefaultRole, resolveDescription, resolveDialogueVoices, resolveEffectiveSourceType, resolveEffectiveTier, resolveEntityAspect, resolveFieldMappings, resolveGvpAnchorWire, resolveImageGenCreditIdentifier, resolveIndex, resolveLabel, resolveListExpression, resolveLlmCreditId, resolveLocationFields, resolveLocationPresetCatalog, resolveLottieOverlaySrc, resolveNodeRefs, resolveNormalizedImageGen, resolveObjectAspectRatio, resolvePipelineModel, resolveRelativeWindowToken, resolveScraperCreditId, resolveSelectorRefs, resolveSeparator, resolveSheetSections, resolveSlideshowTransition, resolveSourceThroughConnectedList, resolveStoredTier, resolveSwitchXCreditId, resolveTopazUpscale, resolveVideoAnalysisModel, resolveVideoModeForInputs, resolveVideoProviderForMode, resolveXfadeName, rewriteSceneBindings, rewriteSlotTokens, rewriteSpeakerSlots, rgbaArrayToHex, roleToPhrase, runSelector, safetyRetryPolicy, sanitizeRole, searchModelVariants, seedance2AudioLimitSec, segmentDurationsFor, selectByModulo, selectByNamedKey, selectByPredicate, selectListItems, selectLoraRoutingForMentions, selectRandom, setRegisteredPersonPackFields, settledWithLimit, slotVariationSchema, sortCharacterEntriesForDisplay, sortListItems, sourceRefKey, spliceDelimitedRows, splitByLoopDelimiter, splitGeneratedItems, spreadJsonArrayIfSingleton, stringifyPathResults, stripDerivedAnalysisFields, stripExportContent, stripStudioTransientSettings, stripTransientRuntimeData, sunoCreditType, supportedDefaultDimensions, supportsAdvancedMode, supportsEndAnchor, supportsExtendRender, toConnectedReference, toConnectedReferences, togglePick, tryParseJson, uiAspectRatioFill, uiDurationFill, uiResolutionFill, unresolvedRefTokens, unwrapUnresolvedTokens, usageModeDirective, usageModeIncludesName, usageModeLabel, usdToCredits, validateAiAvatarPayload, validateCinematicAvatarPayload, validateDurationForFormat, validateModeActivation, validateModelInput, validateNoNestedGroups, validateObjects, validateProviderForNodeType, validateSubWorkflowRoutes, variantJobId, videoAnalysisCreditSegment, videoAnalysisNumWindows, videoAnalysisResultSchema, videoAuditCreditsForBucket, videoModelCanSpeakDialogue, videoModelSupportsAudio, videoNegativeSuffix, videoProviderFoldsLoneEndFrame, videoProviderRequiresImage, windowAnalysisSchema, zipMergeLists };
+export { ACCESS_LEVELS, ACTIVE_SCENE_HELPERS, ADVANCED_MODE_UNAVAILABLE_REASON, AGGREGATEABLE_TYPES, AGGREGATE_LANE_SOURCE_TYPES, AI_AVATAR_DURATION_BUCKETS, AI_AVATAR_MAX_AUDIO_SEC, AI_AVATAR_MAX_DURATION_SEC, AI_AVATAR_RESERVE_IDS, AI_WRITER_PROVIDERS, ALA_CARTE_BOARDS, ALL_CAPTION_STYLES, ANIMALS, ANIMAL_SUBCATEGORY_LABELS, ANIMAL_SUBCATEGORY_ORDER, ASPECT_RATIO_DIMENSIONS, AUDIO_ADDON_PROVIDERS, AUDIO_CROSSFADE_CURVES, AUDIO_CROSSFADE_CURVE_IDS, AUDIO_FX_PRESETS, AUDIO_FX_PRESET_LABELS, AUDIO_FX_PRESET_SET, AUDIO_FX_REVERB_PRESETS, AUDIO_PRODUCER_TYPES, AddBRollResultSchema, AnchorSceneStyleResultSchema, AssetRefSchema, AuditImagesResultSchema, AuditImagesShotEntrySchema, AuditPromptIssueSchema, AuditPromptResultSchema, AvatarPayloadError, BOARD_TO_ASSET_TYPE, BOARD_TO_COLUMN, BOARD_VARIANTS, BridgeToNextSceneInputSchema, BridgeToNextSceneResultSchema, CATEGORY_DURATION_DEFAULTS, CHARACTER_ASPECT_DEFAULTS, CHARACTER_ASPECT_OPTIONS, CHARACTER_ASSET_TYPES, CHARACTER_ASSET_VARIANTS, CHARACTER_ATTACH_COLUMNS, CHARACTER_FACETS, CHARACTER_FACET_IDS, CHARACTER_LORA_TRAINING_JOB_TYPE, CHARACTER_MOTION_PROVIDERS, CHARACTER_PICKER_DISPLAY_ORDER, CHARACTER_REFERENCE_PHOTO_KINDS, CHARACTER_STYLES, CHARACTER_VARIANT_ASSET_BUCKETS, CHAT_ENABLED_STAGES, CHAT_STAGES, CHAT_TURN_CAPS, CHAT_WIRED_STAGES, CINEMATIC_DEFAULT_DURATION_SEC, CINEMATIC_DEFAULT_RESOLUTION, CINEMATIC_MAX_DURATION_SEC, CINEMATIC_MAX_LOOKS, CINEMATIC_MAX_REFERENCE_IMAGES, CINEMATIC_MAX_REFERENCE_VIDEOS, CINEMATIC_MIN_DURATION_SEC, CINEMATIC_MIN_LOOKS, CINEMATIC_PROMPT_MAX, CINEMATIC_RESERVE_IDS, COLLABORATOR_ROLES, COLLECT_IN_HANDLE, COMBINE_TRANSITIONS, COMBINE_TRANSITION_GROUP_LABELS, COMBINE_TRANSITION_GROUP_ORDER, COMBINE_TRANSITION_IDS, COMPOSER_PLAN_FIELDS, COMPOSER_PLAN_MAP, CONTENT_TYPES_BY_PLATFORM, CREATURE_ATTACH_COLUMNS, CREDIT_BASE_USD, CREDIT_ROUNDING_RESOLUTION, CastCoverageCriticVerdictSchema, CharacterImageCriticVerdictSchema, CharacterMetadataSchema, ChatTurnResponseSchema, CriticIssueSchema, DEFAULT_AUDIO_CROSSFADE_CURVE_ID, DEFAULT_CARRIED_FRACTION, DEFAULT_CHARACTER_ANGLE_COUNT, DEFAULT_CHARACTER_EXPRESSION_COUNT, DEFAULT_CHARACTER_FACET, DEFAULT_LABEL_BY_SOURCE, DEFAULT_LOCATION_USAGE_MODE, DEFAULT_PANEL_COUNT, DEFAULT_REF_IMAGE_MAX, DEFAULT_SECTIONS, DEFAULT_USAGE_MODE, DEFAULT_VIDEO_ANALYSIS_MODEL, DEFAULT_VIDEO_ANALYSIS_TIER, DEFAULT_VIDEO_CLIP_COST, DEFAULT_VIDEO_DURATION_SEC, DEFAULT_VIDEO_PROVIDER, DEFAULT_VOICE_CHANGER_MODEL, DEFAULT_VOICE_DESIGN_MODEL, DETAIL_VARIANTS, DURATION_PRICED_PROVIDERS, DYNAMIC_PRODUCER_TYPES, DetectionResultSchema, EFFORT_TIER_BUMP, EMOTIONAL_BEAT, ENTITY_ASPECT_DEFAULTS, ENTITY_BUCKET_FIELDS, ENTITY_DB_ID_FIELD, ENTITY_IMAGE_HANDLE_TYPES, ENTITY_KIND_SCALAR_FIELDS, ENTITY_NAME_FIELD, ENTITY_NODE_KINDS, ENTITY_SCALAR_FIELDS, ENTITY_SECTIONS, ENTITY_STATUSES, ENTITY_TABLE, ENTITY_TOOL_RETRY_CAP, ENTITY_TYPES, EXECUTION_DATA_KEYS, EXTEND_VIDEO_PROVIDERS, EntityMetadataSchema, EntityRejectInputSchema, EntityStaleEventSchema, EntityStateChangeEventSchema, FACE_SWAP_PROVIDERS, FAL_LIP_SYNC_PROVIDERS, FAN_OUT_EACH_TYPES, FEATURED_ENTITIES, FILM_BASE_CREDITS, FLEXIBLE_INPUT_LIP_SYNC_PROVIDERS, FLUX2_RES_MP, FLUX_LORA_CHARACTER_MODEL_ID, FRAME_MODE_ADAPTIVE_ONLY_ASPECT, FRAME_TARGET_HANDLES, FREECUT_EXPORT_COMPLETE, FREECUT_EXPORT_PROGRESS, FREECUT_READY, FREECUT_REQUEST_IMPORT, FURNITURE, FURNITURE_SUBCATEGORY_LABELS, FURNITURE_SUBCATEGORY_ORDER, FixContinuityInputSchema, FixContinuityResultSchema, GEMINI_OMNI_PROVIDERS, GENERATE_TEXT_DELIMITER, GLOBAL_MAX_DURATION_SECONDS, GRANTED_ACCESS, GROUP_HANDLE_PREFIX, GUIDANCE_SCALE_SUPPORT, GVP_ANCHOR_CHOICES, GVP_DEFAULT_PROVIDER, GVP_END_FRAME_PROVIDERS, GVP_EXTEND_PROVIDERS, GVP_SUPPORTED_PROVIDERS, GenerateMotionInputSchema, GenerateMotionResultSchema, HANDLE_PORT_SEPARATOR, HELPERS_SHIPPED_IN_1B3, HIGH_QUALITY_PROVIDERS, HINT_EXEMPT_PARAMETER_TYPES, I2I_MASK_SUPPORT, I2I_STRENGTH_SUPPORT, IDEOGRAM_PROVIDERS, IMAGE_ASPECT_RATIO_VALUES, IMAGE_CRITIC_LEAF_MODES, IMAGE_CRITIC_MAX_RETRIES, IMAGE_CRITIC_METADATA_KEYS, IMAGE_CRITIC_MIN_ADHERENCE_SCORE, IMAGE_CRITIC_MODES, IMAGE_CRITIC_UNRESOLVABLE, IMAGE_EDIT_PROVIDERS, IMAGE_GEN_PROVIDERS, IMAGE_I2I_PROVIDERS, IMAGE_MASK_MODE, IMAGE_PROMPT_MAX, IMAGE_REF_TYPES, IMAGE_TO_VIDEO_PROVIDERS, INPUT_FIELD_MAP2 as INPUT_FIELD_MAP, INPUT_NODE_TYPES, INSTAGRAM_CAROUSEL_MAX_ITEMS, INSTAGRAM_CAROUSEL_MIN_ITEMS, ITER_CLONE_PATTERN, ImageCriticIssueSchema, ImageCriticResultSchema, ImageCriticVerdictSchema, ImprovePromptInputSchema, ImprovePromptResultSchema, KEYFRAME_CREDITS_PER_SHOT, KINETIC_CAPTION_STYLES, LANGUAGES, LEGACY_LOTTIE_HOST_REMAP, LIP_SYNC_DURATION_BUCKETS, LIP_SYNC_MAX_AUDIO_SECONDS, LIP_SYNC_PROVIDERS, LLM_FEATURE_DEFAULTS, LLM_MODALITY_CAPS, LLM_MODELS, LLM_MODEL_IDS, LLM_REASONING_EFFORTS, LLM_ROUTE_DEFAULTS, LLM_TEXT_INPUT_MAX, LLM_VENDOR_LABELS, LLM_VENDOR_ORDER, LOCATION_ASSET_TYPES, LOCATION_ASSET_VARIANTS, LOCATION_ATMOSPHERE_PROVIDERS, LOCATION_ATTACH_COLUMNS, LOCATION_BUCKET_TO_CATALOG_ID, LOCATION_PRESET_TO_CATALOG, LOCATION_REFERENCE_PHOTO_KINDS, LOCATION_REFERENCE_PHOTO_KIND_LABELS, LOCATION_USAGE_MODES, LOTTIE_OVERLAY_CATALOG, LOTTIE_SLOT_FIELD_PREFIX, LocationImageCriticVerdictSchema, LocationMetadataSchema, LocationsCoverageCriticIssueSchema, LocationsCoverageCriticVerdictSchema, MAX_CUSTOM_ENTRIES_PER_BOARD, MAX_IMAGE_PROMPT_CHARS_BY_PROVIDER, MAX_LOCATION_VARIANTS, MAX_NEGATIVE_PROMPT_CHARS_BY_PROVIDER, MAX_PANELS_PER_SHEET, MAX_TTS_CHARS_BY_PROVIDER, MAX_VIDEO_PROMPT_CHARS_BY_PROVIDER, MEMBER_STATUSES, MINIMAX_H3_DEFAULT_RESOLUTION, MINIMAX_H3_PROVIDERS, MODELS_WITH_REFERENCE_IMAGE_SUPPORT, MODEL_CATALOG, MODEL_PARAM_NODE_TYPES, MODEL_RECOMMENDATIONS, MODIFY_IMAGE_PROVIDERS, MOTION_COLUMN, MOTION_TRANSFER_PROVIDERS, MUSIC_PROVIDERS, MatchCutVerdictSchema, NATIVE_ADAPTIVE_ASPECT, NATIVE_NEGATIVE_PROMPT_MODELS, NATIVE_NEGATIVE_VIDEO_PROVIDERS, NEGATIVE_PROMPT_MAX, NODARO_IMPORT_FILES, NODARO_LOAD_TIMELINE, NODARO_LOAD_VIDEO, NODARO_RESET_PROJECT, NODE_DEFAULT_TYPES, NODE_MAPPABLE_FIELDS, NODE_PRESET_EXPORT_KIND, NODE_REF_PATTERN, NON_EN_LOCALE_IDS, NO_SPLIT_DELIMITER, OBJECT_ASPECT_DEFAULTS, OBJECT_ASPECT_OPTIONS, OBJECT_ASSET_TYPES, OBJECT_ASSET_VARIANTS, OBJECT_ATTACH_COLUMNS, OBJECT_MOTION_PROVIDERS, OBJECT_PICKER_NODE_TYPES, ORG_ERROR_CODES, ORG_KINDS, ORG_ROLES, ORG_STATUSES, OUTPUT_FIELD_MAP, OUTPUT_FORMATS, ObjectMetadataSchema, OptimizeForModelInputSchema, OptimizeForModelResultSchema, OrgSettingsSchema, PARAMETER_NODE_TYPES, PASSTHROUGH_TYPES, PAYG_RETENTION_DAYS, PER_FORMAT_DURATION_BOUNDS, PICKER_TO_COMBINE_TRANSITION, PIPELINE_ACTIVATION_MODES, PIPELINE_FORMATS, PIPELINE_HARD_TIMEOUT_MS, PIPELINE_MODEL_STAGES, PIPELINE_MODES, PIPELINE_OUTPUT_RESOLUTIONS, PIPELINE_PINNABLE_IMAGE_MODELS, PIPELINE_PINNABLE_SCRIPT_LLMS, PIPELINE_PINNABLE_VIDEO_MODELS, PIPELINE_STAGE_NAMES, PIPELINE_STAGE_TIMEOUT_MS, PIPELINE_TYPES, PLACEHOLDER_CHARACTER_NAME, PLATFORM_LABELS, PLATFORM_SPECS, PRESET_APPLY_CLEAR_KEYS, PRESET_EXCLUDED_KEYS, PRESET_LABELS, PRESET_SETTING_KEYS, PRICING_DEFAULT_DURATION_SEC, PRICING_DEFAULT_RESOLUTION, PROMPT_HARD_CEILING, PROMPT_PREFIX_KEY, PROMPT_SUFFIX_KEY, PROVIDER_DIRECTIVE_DEFAULTS, PROVIDER_PLACEHOLDER_PREFIX, PipelineCompletedEventSchema, PipelineConfigSchema, PipelineDriftSummarySchema, PipelineEditorDecisionsReadyEventSchema, PipelineForkedEventSchema, PipelineInputSchema, PipelineMusicReadyEventSchema, PipelineStageNameSchema, PipelineStageStatusSchema, PipelineStateSchema, PipelineStatusSchema, PresetSettingsSchema, QA_CHECK_PROVIDERS, REDUCE_STRATEGIES, REDUCE_STRATEGY_IDS, REFERENCE_BOARD_PROVIDERS, REFERENCE_BOARD_TEMPLATES, REFERENCE_HANDLE_MAP, REFERENCE_ROLE_PRESETS, REF_HANDLE_CATEGORY, REF_IMAGE_MAX_LIMITS, REF_TOKEN_NAMESPACE_PREFIXES, RENDERING_SPEED_SUPPORT, REPEATABLE_NODE_TYPES, REPEAT_PLACEHOLDER, REPLICATE_LIP_SYNC_PROVIDERS, RESERVED_TEMPLATE_VARS, SCENE3D_ASSET_KINDS, SCENE3D_ASSET_ROLES, SCENE3D_ASSET_ROLE_KINDS, SCENE3D_CAMERA_TRACK_FORMAT, SCENE3D_CAMERA_TRACK_LIMITS, SCENE3D_CAMERA_TRACK_VERSION, SCENE3D_CLAY_LIGHTING_PRESETS, SCENE3D_DEFAULT_DURATION_SECONDS, SCENE3D_DEFAULT_ENTITY_CAPABILITIES, SCENE3D_DEFAULT_FPS, SCENE3D_EDIT_NODE_TYPE, SCENE3D_ENTITY_CAPABILITIES, SCENE3D_ENTITY_ROLES, SCENE3D_GENERATE_NODE_TYPE, SCENE3D_GLB_EXTRAS_ALLOWLIST, SCENE3D_GLB_EXTRAS_ENTITY_ID, SCENE3D_GLB_EXTRAS_MATERIAL_ROLE, SCENE3D_GLB_EXTRAS_SUBPART_ID, SCENE3D_LIMITS, SCENE3D_PLAN_FIELD, SCENE3D_PLAN_TYPE, SCENE3D_PRIMITIVES, SCENE3D_PRIMITIVE_MATERIAL_ROLE, SCENE3D_RENDERER_ASSET_KINDS, SCENE3D_SCHEMA_VERSION, SCENE3D_SCHEMA_VERSION_V2, SCENE3D_SUPPORTED_SCHEMA_VERSIONS, SCENE3D_V2_CONTENT_HASH_EXCLUDED, SCENE3D_V2_ENGINES, SCENE3D_V2_LIMITS, SCENE3D_V2_OVERRIDE_OPERATION_VERSION, SCENE3D_V2_PRIMITIVES, SCENE_HELPER_NAMES, SCRAPER_ACTOR_LABELS, SCRAPER_CREDIT_COSTS, SCRAPER_OUTPUT_FIELDS, SCRIPT_PROVIDERS, SEASONS, SECTION_BOARD, SECTION_KINDS, SEEDANCE_2_5_REF_LIMITS, SEEDANCE_2_CONTINUATION_REF_SEC, SEEDANCE_2_EXTEND_STITCH, SEEDANCE_2_PROVIDERS, SEEDANCE_2_R2V_MAX_AUDIO_SEC_BY_PROVIDER, SEEDANCE_2_R2V_MIN_REF_VIDEO_SEC, SEEDANCE_2_REF_LIMITS, SEEDANCE_LIP_SYNC_PROVIDERS, SEED_SUPPORT, SEPARATOR_DISPLAY, SEPARATOR_PRESETS, SHEET_ASPECTS, SHEET_BACKGROUNDS, SHEET_PRESETS, SHEET_SKINS, SHEET_TYPES, SHORT_FILM_ANGLE_COUNT, SHORT_FILM_EXPRESSION_COUNT, SHORT_FILM_VARIANT_THRESHOLD_SEC, SLOT_TOKEN_RE, SMART_CUT_WINDOW_DEFAULT, SMART_CUT_WINDOW_MAX, SMART_CUT_WINDOW_MIN, SOCIAL_POST_NODE_TYPES, STAGE_PATCH_SCHEMA, STATIC_CAPTION_STYLES, STRUCTURAL_SECTIONS, STRUCTURED_VISION_MODELS, STUDIO_SHOT_TRANSIENT_KEYS, STUDIO_TRANSIENT_KEYS, SUBMISSION_STATUSES, SUNO_ADD_TRACK_MODELS, SUNO_FIELD_HANDLE_FIELDS, SUNO_HARD_CEILING, SUNO_MODELS, SUNO_SELECT_OPERATIONS, SUNO_TEXT_MAX, SUNO_TITLE_MAX, SUNO_TRACK_SOURCE_TYPES, SUNO_VERSION_PRICED_OPERATIONS, SUPPORTED_FONT_NAMES, SURROUND_DIRECTIONS, SWITCHX_BLOCK_FRAMES, SWITCHX_FRAME_TIERS, SceneHelperNameSchema, SceneInputModeSchema, SceneMetadataSchema, SceneNodeDataSchema, SceneSpecSchema, ScriptCriticVerdictSchema, ShotSpecSchema, ShowrunnerPlanSchema, StageAwaitingSubGateEventSchema, StoryboardCohesionCriticVerdictSchema, StyleDirectivesSchema, SubGateNameSchema, T2I_TO_I2I_VARIANT, TASK_CHAINED_EDIT_PROVIDERS, TEXT_TO_AUDIO_PROVIDERS, TEXT_TO_VIDEO_PROVIDERS, TIER_MAX_PIPELINE_COST_CREDITS, TIER_PIPELINE_PARALLELISM, TILT_CARRIED_FRACTION, TOPAZ_DEFAULT_UPSCALE_FACTOR, TOPAZ_UPSCALE_FACTORS, TRANSCRIBE_PROVIDERS, TRANSIENT_RUNTIME_KEYS, TTS_PROVIDERS, TTS_TEXT_MAX, TWO_K_RESOLUTION_PROVIDERS, TransitionTypeSchema, UPSCALE_IMAGE_PROVIDERS, USAGE_GROUP_BYS, USAGE_MODES, VARIABLES_HANDLE_ID, VARIABLE_PRICING_MODELS, VEHICLES, VEHICLE_SUBCATEGORY_LABELS, VEHICLE_SUBCATEGORY_ORDER, VEO_PROVIDERS, VIDEO_ANALYSIS_AUDIO_MODES, VIDEO_ANALYSIS_BUCKET_CREDITS, VIDEO_ANALYSIS_CLIP_TRANSITIONS_IN, VIDEO_ANALYSIS_DEFAULT_VARIATION, VIDEO_ANALYSIS_DURATION_BUCKETS, VIDEO_ANALYSIS_DURATION_TOLERANCE_SEC, VIDEO_ANALYSIS_ENTITY_SOURCES, VIDEO_ANALYSIS_FACELESS_ANGLES, VIDEO_ANALYSIS_LEGACY_MODELS, VIDEO_ANALYSIS_LLM_MODELS, VIDEO_ANALYSIS_MAX_DURATION_SEC, VIDEO_ANALYSIS_MAX_SCENE_SEC, VIDEO_ANALYSIS_MAX_VARIATIONS, VIDEO_ANALYSIS_MIXED_TIERS, VIDEO_ANALYSIS_SHOT_ANGLES, VIDEO_ANALYSIS_SPEED_EFFECTS, VIDEO_ANALYSIS_STORY_JUMPS, VIDEO_ANALYSIS_TEXT_KINDS, VIDEO_ANALYSIS_TIERS, VIDEO_ANALYSIS_TIER_LABELS, VIDEO_ANALYSIS_TIER_ORDER, VIDEO_ANALYSIS_TIMES_OF_DAY, VIDEO_ANALYSIS_TRANSITIONS, VIDEO_ANALYSIS_VARIATION_SLUGS, VIDEO_ANALYSIS_VISUAL_EFFECTS, VIDEO_ANALYSIS_WINDOW, VIDEO_AUDIO_CAPABILITY, VIDEO_AUDIT_BUCKET_CREDITS, VIDEO_CLIP_CREDITS, VIDEO_CRITIC_CREDITS_PER_SHOT, VIDEO_CRITIC_FRAME_MODES, VIDEO_CRITIC_MAX_RETRIES, VIDEO_CRITIC_METADATA_KEYS, VIDEO_CRITIC_MIN_ADHERENCE_SCORE, VIDEO_DURATION_TIERS, VIDEO_GEN_COLLAPSED_T2V_IDS, VIDEO_GEN_PROVIDERS, VIDEO_INPUT_LIP_SYNC_PROVIDERS, VIDEO_MODEL_CAPS, VIDEO_MODE_ALIASES, VIDEO_PRODUCER_TYPES, VIDEO_PROMPT_MAX, VIDEO_PROVIDERS_REQUIRING_IMAGE, VIDEO_PROVIDERS_WITHOUT_DISPATCH, VIDEO_REF_LIMITS_BY_PROVIDER, VIDEO_REF_VIDEO_DURATION_LIMITS, VIDEO_TO_VIDEO_PROVIDERS, VIDEO_UPSCALE_PROVIDERS, VIDEO_UTIL_PRICING, VIDEO_VARIABLE_PRICING, VOICE_CHANGER_MODELS, VOICE_CHANGER_MODEL_IDS, VOICE_DESIGN_MODELS, ValidateMatchCutInputSchema, ValidateMatchCutResultSchema, VideoCriticVerdictSchema, VoiceMatchSchema, WAN_3_DEFAULT_RESOLUTION, WAN_3_PROVIDERS, WARDROBE_VARIANTS, WEAPONS, WEAPON_SUBCATEGORY_LABELS, WEAPON_SUBCATEGORY_ORDER, WORKFLOW_VISIBILITIES, WORKSPACE_HEADER, WORKSPACE_HEADER_LOWER, WORKSPACE_ROLES, WorkspaceSettingsSchema, aggregateByType, aiAvatarReserveCreditId, analyzedSceneSchema, applyDefaultVideoSelection, applyHandleInputOverride, applyRange, applyRangeIndices, applyScene3DEditOperations, applyScene3DV2EditOperations, applySlots, applyVideoAudioToggle, applyVideoNegativePrompt, aspectRatioFromDims, aspectRatioOptionsByKind, aspectRatioToNumber, assembleNarratedVideoCredits, availableReasoningEfforts, bucketSecondsFromAuditCreditId, bucketSecondsFromCreditId, buildBoardPrompt, buildChildrenByParent, buildConditionVariables, buildCreditModelIdentifier, buildExpressionFromVisual, buildLipSyncCreditId, buildLlmCreditIdentifier, buildModelMenu, buildModelTree, buildMotionCreditModelIdentifier, buildNodePresetExport, buildPanelPrompt, buildProgressSegments, buildRangeLabel, buildScraperCreditId, buildVideoAnalysisCreditId, buildVideoAuditCreditId, buildVideoCreditModelIdentifier, calculateCombinedProgress, calculateMonetizationMarkup, calculateMonetizedCost, calculateProgress, canonicalScene3DPlanV2Json, canonicalVarName, characterBoardItems, characterBucketDisplayRank, characterMentionSlug, characterMentionableAssetArrays, characterSheetRefItems, characterVariantAssetArrays, checkRefVideoDurations, cinematicCreditId, clampCinematicDuration, clampSmartCutWindow, classifyRefToken, cleanOrphanedItems, clearImageCriticMetadata, clearVideoCriticMetadata, clipLookSchema, collectAncestorRefs, combineSameLabelRefs, computeAggregateLanes, computeScene3DPlanV2ContentHash, countRefModalityEdges, creditRangesAll, creditsToUsd, decodeProviderItem, defaultCarriedFraction, defaultResolutionFor, defaultRoleForSource, defaultVideoAspectRatio, deriveLinkedFields, deriveLottieSlotFields, deriveSlotRefs, describeEdgeBehavior, describeMaskRegion, describeNodeAdjustments, describeSlotControl, dropUnknownBindings, dropUnknownSpeakers, durationsByMode, effectiveReasoningEffort, encodeProviderItem, ensureLocaleCatalogLoaded, entityHydrationColumns, entityMentionSlug, entityMentionSlugForRef, entityScalarFields, entitySlotSchema, entryMatchesQuery, estimateCombineVideosCredits, estimateFilmCredits, estimateLoopTrimAddonCredits, estimateLoopVideoCredits, estimateScriptDurationSec, estimateSheetCost, estimateTrimVideoCredits, evaluateCondition, evaluateConditionGroup, evaluateJsonExpression, evaluateJsonPath, expandExtraRefsToConnectedReferences, expandItemsWithRepeat, extractAllGeneratedResults, extractCharacterLoraFields, extractGeneratedJsonAsList, extractPresetData, extractReferencedLabels, extractVideoDurationFromNode, fieldKeyFromHandle, filterCloneNodes, findCharacterMentionTokens, findEntityMentionTokens, findImageMentionTokens, findLocationMentionTokens, findSeedance2AudioOverLimit, firstSightExtraRole, flattenItems, getAnimal, getAnimalLabel, getAnimalPromptHint, getAnimalTerm, getAspectRatioOptions, getAudioCrossfadeCurve, getCharacterFacet, getCombineTransition, getCreditRange, getDurationsForModel, getEffectiveRepeatCount, getFeaturedEntities, getFurniture, getFurnitureLabel, getInputFieldSchema, getInputNodes, getItemSortId, getLipSyncMaxAudioSeconds, getLlmModalityCaps, getLlmModel, getLlmTier, getLocaleDirection, getMaxImagePromptChars, getMaxNegativePromptChars, getMaxSunoPromptChars, getMaxSunoStyleChars, getMaxTtsChars, getMaxVideoPromptChars, getModel, getNodeLabel, getNodeResult, getOutputNodes, getOutputType, getParameterValue, getQualityOptions, getResolutionOptions, getRouteReachableNodeIds, getStrategy, getTargetField, getValidValues, getVehicle, getVehicleLabel, getVideoAudioCapability, getWeapon, getWeaponLabel, groupByFamily, groupHandleId, groupLlmModelsByVendor, hasContiguousSegmentDurations, hasFeature, hexToRgbaArray, humanizeSlotSid, imageMentionSlug, imageMentionSlugForRef, imageReferenceLimit, inferMusicVideo, isAggregateableType, isCharacterAspectRatio, isCollectInEdge, isDefaultSelectorConfig, isExpandedClone, isFlux2Model, isGeminiOmniProvider, isGvpSupportedProvider, isHandleInputWired, isKineticCaptionStyle, isKnownScene3DEngine, isLocationUsageMode, isMinimaxH3Provider, isObjectAspectRatio, isOversizedScene, isPaygRetentionActive, isPerSecondLipSyncProvider, isScene3DCameraTrack, isScene3DHttpUrl, isScene3DPlan, isScene3DPlanV1, isScene3DPlanV2, isScene3DSchemaVersionSupported, isScraperActor, isSeedance2Provider, isTiltDirection, isUsageMode, isVeoProvider, isVideoAnalysisMixedTier, isVideoAnalysisTier, isWan3Provider, jsonResultToList, knownEntitySlugsFromRefs, knownImageSlugsFromRefs, listBoardTemplates, listModels, listSlotSids, llmRouteDefaults, locationMentionSlug, locationReferencePhotoKindLabel, locationUsageModeLabel, mapAspectRatio, mapQuality, mapShotIntentToProviderDirectives, matchVariant, maxSegmentSecFor, maxSegmentsFor, mergeClipLook, mergeExposedSettings, migrateEdgeOutputMode, migrateToItems, minSegmentSecFor, modelIdsByKindMode, modelToNodeTarget, modelsForInputMode, modelsWithFeature, motionGraphicsFeature, newScene3DRevisionId, normalizeLottieLayers, normalizeMinimaxH3Resolution, normalizeModelInput, normalizeNodeModelParams, normalizePinterestUrl, normalizeRoleSlug, normalizeVideoRequestParams, normalizeWan3Resolution, orderedLlmModels, parseAttributedDialogue, parseCharacterMentionToken, parseEntityMentionToken, parseGroupHandle, parseHandleId, parseImageMentionToken, parseListExpression, parseLocationMentionToken, parseNodePresetExport, parseNodeRef, parseScene3DCameraTrackJson, parseScene3DPlanV2Json, pickAiAvatarBucket, pickIds, pickLipSyncBucket, pickSwitchXFrameTier, pickVideoAnalysisBucket, planSheetGeneration, planSheetPanels, preferredInputModeForModel, presentTypes, presetApplyClearKeys, presetDataMatches, presetEntries, pricedVideoSelection, qualityOptionsByKind, readPromptAffixes, refHandleCategory, referenceModalityForHandle, referenceSheetCreditId, registerCatalogSidecars, registerSidecarLoaders, renderAnalyzedScene, resetCatalogSidecars, resolutionOptionsByKind, resolveAiAvatarCreditId, resolveAudioCrossfadeCurve, resolveCharacterAspectRatio, resolveCinematicCreditId, resolveConditionValue, resolveDefaultRole, resolveDescription, resolveDialogueVoices, resolveEffectiveSourceType, resolveEffectiveTier, resolveEntityAspect, resolveFieldMappings, resolveGvpAnchorWire, resolveImageGenCreditIdentifier, resolveIndex, resolveLabel, resolveListExpression, resolveLlmCreditId, resolveLocationFields, resolveLocationPresetCatalog, resolveLottieOverlaySrc, resolveNodeRefs, resolveNormalizedImageGen, resolveObjectAspectRatio, resolvePipelineModel, resolveRelativeWindowToken, resolveScraperCreditId, resolveSelectorRefs, resolveSeparator, resolveSheetSections, resolveSlideshowTransition, resolveSourceThroughConnectedList, resolveStoredTier, resolveSwitchXCreditId, resolveTopazUpscale, resolveVideoAnalysisModel, resolveVideoModeForInputs, resolveVideoProviderForMode, resolveXfadeName, rewriteSceneBindings, rewriteSlotTokens, rewriteSpeakerSlots, rgbaArrayToHex, roleToPhrase, rotationVec3Schema, runSelector, safetyRetryPolicy, sanitizeRole, scaleVec3Schema, scene3DAcceptedSchemaVersionsSchema, scene3DAnchorNameSchema, scene3DAnchorSchema, scene3DAnyPlanSchema, scene3DAssetAnimationSchema, scene3DAssetIdSchema, scene3DAssetRefSchema, scene3DCameraChangesSchema, scene3DCameraKeyframeSchema, scene3DCameraSampleSchema, scene3DCameraSchema, scene3DCameraTrackIssues, scene3DCameraTrackObjectSchema, scene3DCameraTrackPlanIssues, scene3DCameraTrackSchema, scene3DClayLightingSchema, scene3DColorSchema, scene3DDeepEqual, scene3DEasingSchema, scene3DEditOperationSchema, scene3DEditOperationsSchema, scene3DEngineIdSchema, scene3DEntityAcceptsOverlay, scene3DEntityCapabilitySchema, scene3DEntityV2Schema, scene3DEntityVisualSchema, scene3DIdSchema, scene3DJsonByteLength, scene3DLightingChangesSchema, scene3DLightingSchema, scene3DMaterialBindingSchema, scene3DMaterialNameSchema, scene3DMaterialRoleSchema, scene3DNodeIdSchema, scene3DObjectChangesSchema, scene3DObjectKeyframeSchema, scene3DObjectSchema, scene3DOverrideSchema, scene3DPlanIssues, scene3DPlanSchema, scene3DPlanSchemaVersion, scene3DPlanV1Issues, scene3DPlanV1ObjectSchema, scene3DPlanV1Schema, scene3DPlanV2Issues, scene3DPlanV2ObjectSchema, scene3DPlanV2Schema, scene3DPrimitiveSchema, scene3DProjectionIssues, scene3DProvenanceSchema, scene3DReferenceSchema, scene3DSampleForFrame, scene3DSha256Schema, scene3DShotForFrame, scene3DShotIndexForFrame, scene3DShotSchema, scene3DUrlSchema, scene3DV2AdmissionIssues, scene3DV2EditOperationSchema, scene3DV2EditOperationsSchema, scene3DV2HierarchyDepth, scene3DV2NormalizationIssues, scene3DV2OverrideInputSchema, scene3DV2ResourceUsage, scene3DVersionTokenSchema, scene3DZodIssues, searchModelVariants, seedance2AudioLimitSec, segmentDurationsFor, selectByModulo, selectByNamedKey, selectByPredicate, selectListItems, selectLoraRoutingForMentions, selectRandom, setRegisteredPersonPackFields, settledWithLimit, sizeVec3Schema, slotVariationSchema, sortCharacterEntriesForDisplay, sortListItems, sourceRefKey, spliceDelimitedRows, splitByLoopDelimiter, splitGeneratedItems, spreadJsonArrayIfSingleton, stringifyPathResults, stripDerivedAnalysisFields, stripExportContent, stripStudioTransientSettings, stripTransientRuntimeData, summarizeScene3DOperations, sunoCreditType, supportedDefaultDimensions, supportsAdvancedMode, supportsEndAnchor, supportsExtendRender, toConnectedReference, toConnectedReferences, togglePick, tryParseJson, uiAspectRatioFill, uiDurationFill, uiResolutionFill, unresolvedRefTokens, unwrapUnresolvedTokens, usageModeDirective, usageModeIncludesName, usageModeLabel, usdToCredits, validateAiAvatarPayload, validateCinematicAvatarPayload, validateDurationForFormat, validateModeActivation, validateModelInput, validateNoNestedGroups, validateObjects, validateProviderForNodeType, validateSubWorkflowRoutes, variantJobId, vec3Schema, verifyScene3DPlanV2ContentHash, videoAnalysisCreditSegment, videoAnalysisNumWindows, videoAnalysisResultSchema, videoAuditCreditsForBucket, videoModelCanSpeakDialogue, videoModelSupportsAudio, videoNegativeSuffix, videoProviderFoldsLoneEndFrame, videoProviderRequiresImage, windowAnalysisSchema, zipMergeLists };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map