@nodaro/shared 2.26.0 → 2.27.0

package/dist/index.cjs

@@ -4133,7 +4133,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))
@@ -5882,6 +5887,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",
@@ -5982,7 +5988,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] || {};
@@ -8765,6 +8774,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"],
@@ -13142,8 +13153,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;
@@ -14678,6 +14703,489 @@ 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 zod.z.tuple([
+    zod.z.number().min(-max).max(max),
+    zod.z.number().min(-max).max(max),
+    zod.z.number().min(-max).max(max)
+  ]).describe(label);
+}
+var vec3Schema = boundedVec3(SCENE3D_LIMITS.maxCoordinate, "position triple (meters)");
+var sizeVec3Schema = zod.z.tuple([
+  zod.z.number().min(SCENE3D_LIMITS.minSize).max(SCENE3D_LIMITS.maxSize),
+  zod.z.number().min(SCENE3D_LIMITS.minSize).max(SCENE3D_LIMITS.maxSize),
+  zod.z.number().min(SCENE3D_LIMITS.minSize).max(SCENE3D_LIMITS.maxSize)
+]);
+var scaleVec3Schema = zod.z.tuple([
+  zod.z.number().min(SCENE3D_LIMITS.minScale).max(SCENE3D_LIMITS.maxScale),
+  zod.z.number().min(SCENE3D_LIMITS.minScale).max(SCENE3D_LIMITS.maxScale),
+  zod.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 = zod.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 = zod.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 = zod.z.string().min(1).max(SCENE3D_LIMITS.maxUrlLength).refine(isScene3DHttpUrl, "url must be an http(s) URL");
+var scene3DEasingSchema = zod.z.enum(["linear", "easeInOut"]);
+var scene3DPrimitiveSchema = zod.z.enum([
+  "box",
+  "sphere",
+  "cylinder",
+  "cone",
+  "plane",
+  "capsule",
+  "group"
+]);
+var frameSchema = zod.z.number().int().min(0).max(SCENE3D_LIMITS.maxDurationInFrames);
+var scene3DObjectKeyframeSchema = zod.z.object({
+  frame: frameSchema,
+  position: vec3Schema.optional(),
+  rotation: rotationVec3Schema.optional(),
+  scale: scaleVec3Schema.optional(),
+  easing: scene3DEasingSchema.optional()
+}).strict();
+var scene3DCameraKeyframeSchema = zod.z.object({
+  frame: frameSchema,
+  position: vec3Schema.optional(),
+  target: vec3Schema.optional(),
+  focalLengthMm: zod.z.number().min(SCENE3D_LIMITS.minFocalLengthMm).max(SCENE3D_LIMITS.maxFocalLengthMm).optional(),
+  easing: scene3DEasingSchema.optional()
+}).strict();
+var scene3DObjectSchema = zod.z.object({
+  id: scene3DIdSchema,
+  name: zod.z.string().min(1).max(SCENE3D_LIMITS.maxNameLength),
+  primitive: scene3DPrimitiveSchema,
+  parentId: scene3DIdSchema.optional(),
+  dimensions: sizeVec3Schema,
+  position: vec3Schema,
+  rotation: rotationVec3Schema,
+  scale: scaleVec3Schema,
+  color: scene3DColorSchema,
+  keyframes: zod.z.array(scene3DObjectKeyframeSchema).max(SCENE3D_LIMITS.maxKeyframes).optional()
+}).strict();
+var scene3DCameraSchema = zod.z.object({
+  position: vec3Schema,
+  target: vec3Schema,
+  focalLengthMm: zod.z.number().min(SCENE3D_LIMITS.minFocalLengthMm).max(SCENE3D_LIMITS.maxFocalLengthMm),
+  sensorWidthMm: zod.z.number().min(SCENE3D_LIMITS.minSensorWidthMm).max(SCENE3D_LIMITS.maxSensorWidthMm).default(SCENE3D_LIMITS.defaultSensorWidthMm),
+  keyframes: zod.z.array(scene3DCameraKeyframeSchema).max(SCENE3D_LIMITS.maxKeyframes).optional()
+}).strict();
+var scene3DLightingSchema = zod.z.object({
+  ambientIntensity: zod.z.number().min(0).max(SCENE3D_LIMITS.maxIntensity),
+  keyIntensity: zod.z.number().min(0).max(SCENE3D_LIMITS.maxIntensity),
+  keyPosition: vec3Schema
+}).strict();
+var scene3DReferenceSchema = zod.z.object({
+  id: scene3DIdSchema,
+  url: scene3DUrlSchema,
+  kind: zod.z.enum(["image", "video"]),
+  role: zod.z.enum(["appearance", "layout", "motion"]),
+  objectId: scene3DIdSchema.optional(),
+  startSeconds: zod.z.number().min(0).max(86400).optional(),
+  endSeconds: zod.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 scene3DPlanIssues(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 scene3DPlanSchema = zod.z.object({
+  planType: zod.z.literal(SCENE3D_PLAN_TYPE),
+  schemaVersion: zod.z.literal(SCENE3D_SCHEMA_VERSION),
+  revisionId: zod.z.uuid(),
+  parentRevisionId: zod.z.uuid().optional(),
+  width: zod.z.number().int().min(SCENE3D_LIMITS.minDimensionPx).max(SCENE3D_LIMITS.maxDimensionPx),
+  height: zod.z.number().int().min(SCENE3D_LIMITS.minDimensionPx).max(SCENE3D_LIMITS.maxDimensionPx),
+  fps: zod.z.number().int().min(SCENE3D_LIMITS.minFps).max(SCENE3D_LIMITS.maxFps),
+  durationInFrames: zod.z.number().int().min(SCENE3D_LIMITS.minDurationInFrames).max(SCENE3D_LIMITS.maxDurationInFrames),
+  backgroundColor: scene3DColorSchema,
+  camera: scene3DCameraSchema,
+  objects: zod.z.array(scene3DObjectSchema).min(SCENE3D_LIMITS.minObjects).max(SCENE3D_LIMITS.maxObjects),
+  lighting: scene3DLightingSchema,
+  references: zod.z.array(scene3DReferenceSchema).max(SCENE3D_LIMITS.maxReferences).optional()
+}).strict().superRefine((plan, ctx) => {
+  for (const issue2 of scene3DPlanIssues(plan)) {
+    ctx.addIssue({ code: "custom", path: issue2.path, message: issue2.message });
+  }
+});
+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 isScene3DPlan(value) {
+  return scene3DPlanSchema.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 = zod.z.object({
+  name: zod.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: zod.z.array(scene3DObjectKeyframeSchema).max(SCENE3D_LIMITS.maxKeyframes).optional()
+}).strict();
+var scene3DCameraChangesSchema = zod.z.object({
+  position: vec3Schema.optional(),
+  target: vec3Schema.optional(),
+  focalLengthMm: zod.z.number().min(SCENE3D_LIMITS.minFocalLengthMm).max(SCENE3D_LIMITS.maxFocalLengthMm).optional(),
+  sensorWidthMm: zod.z.number().min(SCENE3D_LIMITS.minSensorWidthMm).max(SCENE3D_LIMITS.maxSensorWidthMm).optional(),
+  keyframes: zod.z.array(scene3DCameraKeyframeSchema).max(SCENE3D_LIMITS.maxKeyframes).optional()
+}).strict();
+var scene3DLightingChangesSchema = zod.z.object({
+  ambientIntensity: zod.z.number().min(0).max(SCENE3D_LIMITS.maxIntensity).optional(),
+  keyIntensity: zod.z.number().min(0).max(SCENE3D_LIMITS.maxIntensity).optional(),
+  keyPosition: vec3Schema.optional()
+}).strict();
+var scene3DEditOperationSchema = zod.z.discriminatedUnion("op", [
+  zod.z.object({ op: zod.z.literal("set-object"), objectId: scene3DIdSchema, changes: scene3DObjectChangesSchema }).strict(),
+  zod.z.object({ op: zod.z.literal("add-object"), object: scene3DObjectSchema }).strict(),
+  zod.z.object({ op: zod.z.literal("remove-object"), objectId: scene3DIdSchema }).strict(),
+  zod.z.object({ op: zod.z.literal("set-camera"), changes: scene3DCameraChangesSchema }).strict(),
+  zod.z.object({ op: zod.z.literal("set-lighting"), changes: scene3DLightingChangesSchema }).strict(),
+  zod.z.object({ op: zod.z.literal("set-background"), color: scene3DColorSchema }).strict()
+]);
+var scene3DEditOperationsSchema = zod.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 = scene3DPlanSchema.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 = scene3DPlanSchema.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)
+  };
+}
 
 // src/studio-transient.ts
 var STUDIO_TRANSIENT_KEYS = [
@@ -15053,6 +15561,15 @@ exports.REPEATABLE_NODE_TYPES = REPEATABLE_NODE_TYPES;
 exports.REPEAT_PLACEHOLDER = REPEAT_PLACEHOLDER;
 exports.REPLICATE_LIP_SYNC_PROVIDERS = REPLICATE_LIP_SYNC_PROVIDERS;
 exports.RESERVED_TEMPLATE_VARS = RESERVED_TEMPLATE_VARS;
+exports.SCENE3D_DEFAULT_DURATION_SECONDS = SCENE3D_DEFAULT_DURATION_SECONDS;
+exports.SCENE3D_DEFAULT_FPS = SCENE3D_DEFAULT_FPS;
+exports.SCENE3D_EDIT_NODE_TYPE = SCENE3D_EDIT_NODE_TYPE;
+exports.SCENE3D_GENERATE_NODE_TYPE = SCENE3D_GENERATE_NODE_TYPE;
+exports.SCENE3D_LIMITS = SCENE3D_LIMITS;
+exports.SCENE3D_PLAN_FIELD = SCENE3D_PLAN_FIELD;
+exports.SCENE3D_PLAN_TYPE = SCENE3D_PLAN_TYPE;
+exports.SCENE3D_PRIMITIVES = SCENE3D_PRIMITIVES;
+exports.SCENE3D_SCHEMA_VERSION = SCENE3D_SCHEMA_VERSION;
 exports.SCENE_HELPER_NAMES = SCENE_HELPER_NAMES;
 exports.SCRAPER_ACTOR_LABELS = SCRAPER_ACTOR_LABELS;
 exports.SCRAPER_CREDIT_COSTS = SCRAPER_CREDIT_COSTS;
@@ -15216,6 +15733,7 @@ exports.applyDefaultVideoSelection = applyDefaultVideoSelection;
 exports.applyHandleInputOverride = applyHandleInputOverride;
 exports.applyRange = applyRange;
 exports.applyRangeIndices = applyRangeIndices;
+exports.applyScene3DEditOperations = applyScene3DEditOperations;
 exports.applySlots = applySlots;
 exports.applyVideoAudioToggle = applyVideoAudioToggle;
 exports.applyVideoNegativePrompt = applyVideoNegativePrompt;
@@ -15394,6 +15912,8 @@ exports.isObjectAspectRatio = isObjectAspectRatio;
 exports.isOversizedScene = isOversizedScene;
 exports.isPaygRetentionActive = isPaygRetentionActive;
 exports.isPerSecondLipSyncProvider = isPerSecondLipSyncProvider;
+exports.isScene3DHttpUrl = isScene3DHttpUrl;
+exports.isScene3DPlan = isScene3DPlan;
 exports.isScraperActor = isScraperActor;
 exports.isSeedance2Provider = isSeedance2Provider;
 exports.isTiltDirection = isTiltDirection;
@@ -15428,6 +15948,7 @@ exports.modelToNodeTarget = modelToNodeTarget;
 exports.modelsForInputMode = modelsForInputMode;
 exports.modelsWithFeature = modelsWithFeature;
 exports.motionGraphicsFeature = motionGraphicsFeature;
+exports.newScene3DRevisionId = newScene3DRevisionId;
 exports.normalizeLottieLayers = normalizeLottieLayers;
 exports.normalizeMinimaxH3Resolution = normalizeMinimaxH3Resolution;
 exports.normalizeModelInput = normalizeModelInput;
@@ -15514,9 +16035,30 @@ exports.rewriteSlotTokens = rewriteSlotTokens;
 exports.rewriteSpeakerSlots = rewriteSpeakerSlots;
 exports.rgbaArrayToHex = rgbaArrayToHex;
 exports.roleToPhrase = roleToPhrase;
+exports.rotationVec3Schema = rotationVec3Schema;
 exports.runSelector = runSelector;
 exports.safetyRetryPolicy = safetyRetryPolicy;
 exports.sanitizeRole = sanitizeRole;
+exports.scaleVec3Schema = scaleVec3Schema;
+exports.scene3DCameraChangesSchema = scene3DCameraChangesSchema;
+exports.scene3DCameraKeyframeSchema = scene3DCameraKeyframeSchema;
+exports.scene3DCameraSchema = scene3DCameraSchema;
+exports.scene3DColorSchema = scene3DColorSchema;
+exports.scene3DDeepEqual = scene3DDeepEqual;
+exports.scene3DEasingSchema = scene3DEasingSchema;
+exports.scene3DEditOperationSchema = scene3DEditOperationSchema;
+exports.scene3DEditOperationsSchema = scene3DEditOperationsSchema;
+exports.scene3DIdSchema = scene3DIdSchema;
+exports.scene3DLightingChangesSchema = scene3DLightingChangesSchema;
+exports.scene3DLightingSchema = scene3DLightingSchema;
+exports.scene3DObjectChangesSchema = scene3DObjectChangesSchema;
+exports.scene3DObjectKeyframeSchema = scene3DObjectKeyframeSchema;
+exports.scene3DObjectSchema = scene3DObjectSchema;
+exports.scene3DPlanIssues = scene3DPlanIssues;
+exports.scene3DPlanSchema = scene3DPlanSchema;
+exports.scene3DPrimitiveSchema = scene3DPrimitiveSchema;
+exports.scene3DReferenceSchema = scene3DReferenceSchema;
+exports.scene3DUrlSchema = scene3DUrlSchema;
 exports.searchModelVariants = searchModelVariants;
 exports.seedance2AudioLimitSec = seedance2AudioLimitSec;
 exports.segmentDurationsFor = segmentDurationsFor;
@@ -15528,6 +16070,7 @@ exports.selectLoraRoutingForMentions = selectLoraRoutingForMentions;
 exports.selectRandom = selectRandom;
 exports.setRegisteredPersonPackFields = setRegisteredPersonPackFields;
 exports.settledWithLimit = settledWithLimit;
+exports.sizeVec3Schema = sizeVec3Schema;
 exports.slotVariationSchema = slotVariationSchema;
 exports.sortCharacterEntriesForDisplay = sortCharacterEntriesForDisplay;
 exports.sortListItems = sortListItems;
@@ -15541,6 +16084,7 @@ exports.stripDerivedAnalysisFields = stripDerivedAnalysisFields;
 exports.stripExportContent = stripExportContent;
 exports.stripStudioTransientSettings = stripStudioTransientSettings;
 exports.stripTransientRuntimeData = stripTransientRuntimeData;
+exports.summarizeScene3DOperations = summarizeScene3DOperations;
 exports.sunoCreditType = sunoCreditType;
 exports.supportedDefaultDimensions = supportedDefaultDimensions;
 exports.supportsAdvancedMode = supportsAdvancedMode;
@@ -15569,6 +16113,7 @@ exports.validateObjects = validateObjects;
 exports.validateProviderForNodeType = validateProviderForNodeType;
 exports.validateSubWorkflowRoutes = validateSubWorkflowRoutes;
 exports.variantJobId = variantJobId;
+exports.vec3Schema = vec3Schema;
 exports.videoAnalysisCreditSegment = videoAnalysisCreditSegment;
 exports.videoAnalysisNumWindows = videoAnalysisNumWindows;
 exports.videoAnalysisResultSchema = videoAnalysisResultSchema;