@deepblend/dsh-blender-contracts 0.2.20 → 0.3.1

package/lib/scene-spec.js

@@ -22,6 +22,8 @@
 
 import { canonicalStringify, sha256Canonical } from './canonical.js'
 import { compileSchema, formatIssues } from './json-schema.js'
+import { referenceImageIssues } from './reference-images.js'
+import { HANDLED_CUP_FIELDS, handledCupIssues, resolveHandledCup } from './handled-cup.js'
 import sceneSpecSchema from './schemas/scene-spec.schema.json' with { type: 'json' }
 
 /** The one schema version this module understands. */
@@ -73,6 +75,7 @@ export const TRANSFORM_ANIMATION_PROPERTIES = Object.freeze([
  */
 export const MATERIAL_ANIMATION_PROPERTIES = Object.freeze([
   'emissionStrength', 'roughness', 'metallic', 'ior', 'alpha', 'coatWeight', 'transmissionWeight',
+  'anisotropic', 'anisotropicRotation',
   'baseColor.r', 'baseColor.g', 'baseColor.b',
   'emissionColor.r', 'emissionColor.g', 'emissionColor.b',
 ])
@@ -114,6 +117,7 @@ const NON_NEGATIVE_MATERIAL_PROPERTIES = Object.freeze([
 /** Material parameters that are only meaningful inside [0, 1]. */
 const UNIT_MATERIAL_PROPERTIES = Object.freeze([
   'roughness', 'metallic', 'alpha', 'coatWeight', 'transmissionWeight',
+  'anisotropic', 'anisotropicRotation',
   'baseColor.r', 'baseColor.g', 'baseColor.b',
 ])
 
@@ -136,6 +140,9 @@ export const IMPORT_OPERATOR_BY_ASSET_TYPE = Object.freeze({
   blend: 'wm.append',
 })
 
+export const IMAGE_ASSET_TYPES = Object.freeze(['png', 'jpg', 'jpeg'])
+export const ENVIRONMENT_ASSET_TYPES = Object.freeze([...IMAGE_ASSET_TYPES, 'hdr', 'exr'])
+
 const validateStructure = compileSchema(sceneSpecSchema, { id: 'scene-spec.schema.json' })
 
 /**
@@ -226,6 +233,9 @@ export function validateSceneSpec(spec) {
   const idsOf = name => indexByCollection.get(name) ?? new Map()
 
   // ---- reference integrity ------------------------------------------------
+  for (const issue of referenceImageIssues(project.referenceImages ?? [], document.assets ?? [])) {
+    errors.push({ ...issue, severity: 'error', path: `project.referenceImages${issue.path}` })
+  }
   const requiresId = (collection, id, path, what) => {
     if (id === undefined || id === null) return
     if (!idsOf(collection).has(id)) {
@@ -235,6 +245,12 @@ export function validateSceneSpec(spec) {
       })
     }
   }
+  requiresId('entities', project.reviewSubjectId, 'project.reviewSubjectId', 'review subject')
+  if (project.reviewSubjectId !== undefined && document.entities.some(entity =>
+    entity.id === project.reviewSubjectId && entity.type === 'empty')) {
+    errors.push({ severity: 'error', code: 'SCENE_SPEC_INVALID', path: 'project.reviewSubjectId',
+      message: 'The review subject must be a renderable entity, not an empty.' })
+  }
 
   ;(document.assets ?? []).forEach((asset, position) => {
     // Path containment (SPEC §15.2). The project root is the only legal base.
@@ -254,6 +270,49 @@ export function validateSceneSpec(spec) {
     }
   })
 
+  if (document.world?.environment) {
+    const id = document.world.environment.assetId
+    requiresId('assets', id, 'world.environment.assetId', 'environment image')
+    const asset = (document.assets ?? []).find(entry => entry.id === id)
+    if (asset && !ENVIRONMENT_ASSET_TYPES.includes(asset.type)) errors.push({ severity: 'error',
+      code: 'SCENE_WORLD_ENVIRONMENT_INVALID', path: 'world.environment.assetId', message: 'environment requires an image asset' })
+  }
+
+  for (const [index, material] of (document.materials ?? []).entries()) {
+    if (material.texture?.coordinates === 'uv' && material.shader === 'emission') errors.push({ severity: 'error',
+      code: 'SCENE_MATERIAL_TEXTURE_INVALID', path: `materials[${index}].texture`,
+      message: 'UV procedural texture requires a principled or glass material' })
+    const anisotropicKeys = ['anisotropic', 'anisotropicRotation']
+    const anisotropicTracks = (document.animationTracks ?? []).filter(track => track.targetKind === 'material' &&
+      track.targetEntityId === material.id && anisotropicKeys.includes(track.property))
+    const declaredAnisotropy = material.tangent !== undefined || anisotropicTracks.length > 0 ||
+      anisotropicKeys.some(key => material.parameters?.[key] !== undefined)
+    if (declaredAnisotropy && material.shader === 'emission') errors.push({ severity: 'error',
+      code: 'SCENE_MATERIAL_ANISOTROPY_INVALID', path: `materials[${index}]`,
+      message: 'anisotropic parameters and tangents require a principled or glass material' })
+    const directionRequired = anisotropicKeys.some(key => (material.parameters?.[key] ?? 0) !== 0) ||
+      anisotropicTracks.some(track => track.keyframes.some(keyframe => keyframe.value !== 0))
+    if (directionRequired && material.tangent === undefined) errors.push({ severity: 'error',
+      code: 'SCENE_MATERIAL_ANISOTROPY_INVALID', path: `materials[${index}].tangent`,
+      message: 'nonzero anisotropy or rotation, including animation, requires an explicit uv or radial tangent' })
+    if (material.images && material.texture) errors.push({ severity: 'error', code: 'SCENE_MATERIAL_IMAGES_INVALID',
+      path: `materials[${index}].images`, message: 'image maps and procedural texture cannot be combined on one material yet' })
+    if (material.images && material.shader === 'emission') errors.push({ severity: 'error', code: 'SCENE_MATERIAL_IMAGES_INVALID',
+      path: `materials[${index}].images`, message: 'image maps require a principled or glass material' })
+    for (const [channel, binding] of Object.entries(material.images ?? {})) {
+      const path = `materials[${index}].images.${channel}`
+      requiresId('assets', binding.assetId, `${path}.assetId`, 'image asset')
+      const asset = (document.assets ?? []).find(entry => entry.id === binding.assetId)
+      if (asset && !IMAGE_ASSET_TYPES.includes(asset.type)) errors.push({ severity: 'error',
+        code: 'SCENE_MATERIAL_IMAGES_INVALID', path, message: 'material image maps require PNG or JPEG assets' })
+      if ((binding.strength !== undefined && channel !== 'normal') ||
+          (binding.channel !== undefined && !['roughness', 'metallic', 'alpha'].includes(channel))) {
+        errors.push({ severity: 'error', code: 'SCENE_MATERIAL_IMAGES_INVALID', path,
+          message: 'strength applies only to normals; channel selection applies only to scalar maps' })
+      }
+    }
+  }
+
   document.entities.forEach((entity, position) => {
     const at = `entities[${position}]`
     if (entity.type === 'asset-instance') {
@@ -264,6 +323,10 @@ export function validateSceneSpec(spec) {
         })
       } else {
         requiresId('assets', entity.assetId, `${at}.assetId`, 'asset')
+        if (ENVIRONMENT_ASSET_TYPES.includes((document.assets ?? []).find(asset => asset.id === entity.assetId)?.type)) {
+          errors.push({ severity: 'error', code: 'SCENE_ENTITY_ASSET_INVALID', path: `${at}.assetId`,
+            message: 'an image asset cannot be instantiated as a mesh' })
+        }
       }
       if (entity.generator !== undefined) {
         errors.push({
@@ -285,20 +348,119 @@ export function validateSceneSpec(spec) {
       })
     }
     requiresId('materials', entity.materialId, `${at}.materialId`, 'material')
+    if (entity.materialBindings !== undefined) {
+      if (entity.type !== 'asset-instance') errors.push({ severity: 'error', code: 'SCENE_MATERIAL_BINDING_INVALID',
+        path: `${at}.materialBindings`, message: 'materialBindings requires an asset-instance entity' })
+      const selectors = new Set()
+      for (const [index, binding] of entity.materialBindings.entries()) {
+        requiresId('materials', binding.materialId, `${at}.materialBindings[${index}].materialId`, 'material')
+        const key = JSON.stringify([binding.partId, binding.slotIndex ?? null])
+        if (selectors.has(key)) errors.push({ severity: 'error', code: 'SCENE_MATERIAL_BINDING_INVALID',
+          path: `${at}.materialBindings[${index}]`, message: 'duplicate part and slot material binding' })
+        selectors.add(key)
+      }
+    }
+    if (entity.generator?.shape === 'handled_cup') {
+      for (const message of handledCupIssues(entity.generator)) errors.push({ severity: 'error',
+        code: 'SCENE_GENERATOR_PARAMETERS_INVALID', path: `${at}.generator`, message })
+    } else if (entity.generator && HANDLED_CUP_FIELDS.some(key => entity.generator[key] !== undefined)) {
+      errors.push({ severity: 'error', code: 'SCENE_GENERATOR_PARAMETERS_INVALID', path: `${at}.generator`,
+        message: 'handled cup dimensions and resolutions apply only to handled_cup geometry' })
+    }
+    if (entity.generator?.shape === 'lathe') {
+      const profile = entity.generator.profile
+      const invalid = message => errors.push({ severity: 'error', code: 'SCENE_GENERATOR_PROFILE_INVALID',
+        path: `${at}.generator.profile`, message })
+      if (!Array.isArray(profile) || profile.length < 2) {
+        invalid('a lathe requires at least two [radius, height] profile points')
+      } else {
+        if (profile.some(point => point[0] < 0) || !profile.some(point => point[0] > 0)) {
+          invalid('lathe radii must be nonnegative, with at least one positive radius')
+        }
+        if (profile.some((point, index) => index > 0 && point[0] === profile[index - 1][0] && point[1] === profile[index - 1][1])) {
+          invalid('consecutive lathe profile points must differ')
+        }
+        if (profile.slice(1, -1).some(point => point[0] === 0)) invalid('axis points are allowed only at the two profile ends')
+        if (new Set(profile.map(point => point[1])).size < 2) invalid('a lathe profile must have nonzero height')
+        if (entity.generator.closedProfile && (profile.length < 3 ||
+          (profile[0][0] === profile.at(-1)[0] && profile[0][1] === profile.at(-1)[1]))) {
+          invalid('a closed profile needs at least three points and closes automatically; omit the repeated first point')
+        }
+        if (profileIntersects(profile, entity.generator.closedProfile === true)) invalid('lathe profile edges must not intersect')
+      }
+    } else if (entity.generator && ['profile', 'closedProfile', ...(entity.generator.shape === 'curve' ? [] : ['capEnds'])].some(key => entity.generator[key] !== undefined)) {
+      errors.push({ severity: 'error', code: 'SCENE_GENERATOR_PROFILE_INVALID', path: `${at}.generator`,
+        message: 'profile and closedProfile require lathe geometry; capEnds requires lathe or curve geometry' })
+    }
+    const generator = entity.generator
+    if (generator?.shape === 'curve') {
+      const path = generator.path
+      const invalid = message => errors.push({ severity: 'error', code: 'SCENE_GENERATOR_PATH_INVALID',
+        path: `${at}.generator.path`, message })
+      if (!Array.isArray(path) || path.length < (generator.pathClosed ? 3 : 2)) {
+        invalid('a curve needs two path points, or three for a closed path')
+      } else {
+        if (path.some((point, i) => i > 0 && point.every((value, axis) => value === path[i - 1][axis]))) {
+          invalid('consecutive curve path points must differ')
+        }
+        if (generator.pathClosed && path[0].every((value, axis) => value === path.at(-1)[axis])) {
+          invalid('a closed path closes automatically; omit the repeated first point')
+        }
+        for (let i = generator.pathClosed ? 0 : 1; i < (generator.pathClosed ? path.length : path.length - 1); i += 1) {
+          const a = path[(i + path.length - 1) % path.length].map((v, axis) => v - path[i][axis])
+          const b = path[(i + 1) % path.length].map((v, axis) => v - path[i][axis])
+          const cross = [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]
+          if (Math.hypot(...cross) < 1e-12 && a.reduce((sum, v, axis) => sum + v * b[axis], 0) > 0) {
+            invalid('a curve path must not reverse along the same segment')
+            break
+          }
+        }
+      }
+    } else if (generator && ['path', 'pathClosed', 'pathInterpolation', 'curveResolution', 'bevelResolution'].some(key => generator[key] !== undefined)) {
+      errors.push({ severity: 'error', code: 'SCENE_GENERATOR_PATH_INVALID', path: `${at}.generator`,
+        message: 'curve path parameters apply only to curve geometry' })
+    }
     // AND THE RIG IT IS SKINNED TO. MEASURED: this check was missing at first, and the contract suite
     // caught it — the schema can say `armatureId` is a string, but only a cross-reference can say it
     // names something the scene declares. An entity skinned to an armature nobody declares would render
     // as a static object while the file says it is rigged, which is the failure this code exists for.
     requiresId('armatures', entity.armatureId, `${at}.armatureId`, 'armature')
-    if (entity.type !== 'empty' && entity.materialId === undefined) {
+    if (entity.type === 'generator' && entity.materialId === undefined) {
       notices.push({
         severity: 'notice', code: 'SCENE_ENTITY_MATERIAL_DEFAULTED', path: at,
         message: `entity "${entity.id}" has no materialId; the default principled material will be applied`,
       })
     }
     checkScale(entity.transform?.scale, `${at}.transform.scale`, errors, entity.id)
+    for (const [i, modifier] of (entity.modifiers ?? []).entries()) {
+      const path = `${at}.modifiers[${i}]`
+      if (entity.type === 'empty' || (modifier.type === 'solidify' && modifier.thickness === 0) ||
+        (modifier.type === 'array' && modifier.offset.every(value => value === 0))) {
+        errors.push({ severity: 'error', code: 'SCENE_MODIFIER_INVALID', path,
+          message: 'mesh modifiers need geometry, nonzero thickness and nonzero array offset' })
+      }
+      if (modifier.type === 'boolean') requiresId('entities', modifier.targetEntityId, `${path}.targetEntityId`, 'boolean operand')
+    }
   })
 
+  const modifierEntities = new Map(document.entities.map(entity => [entity.id, entity]))
+  const visitedModifiers = new Set(), activeModifiers = new Set()
+  const visitModifiers = id => {
+    if (activeModifiers.has(id)) {
+      errors.push({ severity: 'error', code: 'SCENE_MODIFIER_CYCLE', path: 'entities',
+        message: `boolean dependency cycle includes entity "${id}"` })
+      return
+    }
+    if (visitedModifiers.has(id)) return
+    activeModifiers.add(id)
+    for (const modifier of modifierEntities.get(id)?.modifiers ?? []) {
+      if (modifier.type === 'boolean') visitModifiers(modifier.targetEntityId)
+    }
+    activeModifiers.delete(id)
+    visitedModifiers.add(id)
+  }
+  for (const id of modifierEntities.keys()) visitModifiers(id)
+
   ;(document.lights ?? []).forEach((light, position) => {
     checkScale(light.transform?.scale, `lights[${position}].transform.scale`, errors, light.id)
   })
@@ -521,8 +683,25 @@ export function compileSceneSpec(spec) {
   /** Entity centre and radius from generator footprint — the aiming substrate. */
   const entityBounds = {}
   for (const entity of entities) {
-    entityBounds[entity.id] = boundsOf(entity)
+    entityBounds[entity.id] = boundsOf({ ...entity, modifiers: [] })
   }
+  const boundsVisited = new Set()
+  const expandBooleanBounds = entity => {
+    if (boundsVisited.has(entity.id)) return
+    boundsVisited.add(entity.id)
+    for (const modifier of entity.modifiers ?? []) {
+      const scale = Math.max(...entity.transform.scale.map(Math.abs))
+      if (modifier.type === 'solidify') entityBounds[entity.id].radius += Math.abs(modifier.thickness) * scale
+      if (modifier.type === 'array') entityBounds[entity.id].radius += Math.hypot(...modifier.offset) * (modifier.count - 1) * scale
+      if (modifier.type !== 'boolean' || modifier.operation !== 'union') continue
+      const operand = entities.find(candidate => candidate.id === modifier.targetEntityId)
+      if (!operand) continue
+      expandBooleanBounds(operand)
+      const own = entityBounds[entity.id], other = entityBounds[operand.id]
+      own.radius = Math.max(own.radius, Math.hypot(...own.location.map((v, axis) => v - other.location[axis])) + other.radius)
+    }
+  }
+  for (const entity of entities) expandBooleanBounds(entity)
 
   const cameras = spec.cameras.map(camera => {
     const targetPoint = camera.targetEntityId !== undefined
@@ -573,6 +752,28 @@ export function compileSceneSpec(spec) {
   return { spec: resolved, notices, entityBounds }
 }
 
+/** Reject intersections and collinear reversals in a lathe boundary. */
+function profileIntersects(points, closed) {
+  const edges = points.slice(0, closed ? points.length : -1).map((point, index) => [point, points[(index + 1) % points.length]])
+  const cross = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])
+  const on = (a, b, p) => Math.abs(cross(a, b, p)) < 1e-12 &&
+    p.every((value, axis) => value >= Math.min(a[axis], b[axis]) - 1e-12 && value <= Math.max(a[axis], b[axis]) + 1e-12)
+  for (let i = closed ? 0 : 1; i < (closed ? points.length : points.length - 1); i += 1) {
+    const a = points[(i + points.length - 1) % points.length], b = points[i], c = points[(i + 1) % points.length]
+    if (Math.abs(cross(a, b, c)) < 1e-12 &&
+      (a[0] - b[0]) * (c[0] - b[0]) + (a[1] - b[1]) * (c[1] - b[1]) > 0) return true
+  }
+  for (let i = 0; i < edges.length; i += 1) {
+    for (let j = i + 2; j < edges.length; j += 1) {
+      if (closed && i === 0 && j === edges.length - 1) continue
+      const [a, b] = edges[i], [c, d] = edges[j]
+      if ((cross(a, b, c) * cross(a, b, d) < 0 && cross(c, d, a) * cross(c, d, b) < 0) ||
+        on(a, b, c) || on(a, b, d) || on(c, d, a) || on(c, d, b)) return true
+    }
+  }
+  return false
+}
+
 /** Generator defaults, applied per shape. */
 function resolveGenerator(generator) {
   const shape = generator?.shape
@@ -604,6 +805,15 @@ function resolveGenerator(generator) {
         segments: generator.segments ?? 48,
         ringCount: generator.ringCount ?? 12,
       }
+    case 'lathe':
+      return { ...base, ...generator, segments: generator.segments ?? 96,
+        closedProfile: generator.closedProfile ?? false, capEnds: generator.capEnds ?? true }
+    case 'curve':
+      return { ...base, ...generator, radius: generator.radius ?? 0.01, pathClosed: generator.pathClosed ?? false,
+        pathInterpolation: generator.pathInterpolation ?? 'poly', curveResolution: generator.curveResolution ?? 16,
+        bevelResolution: generator.bevelResolution ?? 8, capEnds: generator.capEnds ?? true }
+    case 'handled_cup':
+      return { ...base, ...resolveHandledCup(generator) }
     default:
       return { ...generator }
   }
@@ -659,9 +869,21 @@ export function entityBoundingRadius(entity) {
       case 'cone': radius = Math.hypot(generator.radius, generator.depth / 2); break
       case 'plane': radius = (generator.size / 2) * Math.SQRT2; break
       case 'torus': radius = generator.majorRadius + generator.minorRadius; break
+      case 'lathe': radius = Math.max(...generator.profile.map(([r, z]) => Math.hypot(r, z))); break
+      case 'curve': radius = Math.max(...generator.path.map(point => Math.hypot(...point))) *
+        (generator.pathInterpolation === 'bezier' ? 2 : 1) + generator.radius; break
+      case 'handled_cup': {
+        const p = resolveHandledCup(generator)
+        radius = Math.hypot(p.radius + p.rootLength + (p.handleUpper - p.handleLower) / 2 + p.handleRadius, p.height)
+        break
+      }
       default: radius = 1
     }
   }
+  for (const modifier of entity?.modifiers ?? []) {
+    if (modifier.type === 'solidify') radius += Math.abs(modifier.thickness)
+    if (modifier.type === 'array') radius += Math.hypot(...modifier.offset) * (modifier.count - 1)
+  }
   return radius * Math.max(Math.abs(scale[0]), Math.abs(scale[1]), Math.abs(scale[2]))
 }
 
@@ -703,7 +925,7 @@ function round4(value) {
 /**
  * The scene-relevant projection of a spec.
  *
- * `project.goal` and `project.title` are excluded on purpose: the digest exists
+ * Project metadata, including goal and referenceImages, is excluded on purpose: the digest exists
  * to answer "is the SCENE different?", and a re-worded brief over an unchanged
  * scene is not a new scene. Two revisions can therefore share a digest, which is
  * exactly the signal a caller wants when deciding whether a re-render is needed.
@@ -742,7 +964,7 @@ export function sceneSpecDigest(spec) {
  * Content hash of the WHOLE document, including `project`.
  *
  * Distinct from {@link sceneSpecDigest}, and the distinction is load-bearing.
- * The scene digest deliberately excludes `project.title` and `project.goal` so
+ * The scene digest deliberately excludes project metadata and the authored brief so
  * that re-wording a brief over an unchanged scene is not treated as a new scene.
  * But it also excludes `project.frameStart`, `project.frameEnd` and `project.fps`
  * — which ARE scene-relevant: changing the frame range changes what a render
@@ -767,6 +989,24 @@ export function specHash(spec) {
   return sha256Canonical(spec)
 }
 
+/** Identity of authored review inputs, independent of geometry and render settings.
+ * References and purposes are sets identified by id; display order does not change
+ * their meaning. Asset aliases are resolved from this document, never a live catalog.
+ * The Host must still verify these declared hashes against the actual file bytes.
+ */
+export function reviewInputsDigest(spec) {
+  const referenceImages = (spec?.project?.referenceImages ?? []).map(reference => {
+    const asset = (spec.assets ?? []).find(entry => entry.id === reference.assetId)
+    return {
+      id: reference.id, assetId: reference.assetId, sha256: reference.sha256,
+      label: reference.label, purposes: [...reference.purposes].sort(), notes: reference.notes ?? '',
+      asset: asset ? { id: asset.id, type: asset.type, path: asset.path, sha256: asset.sha256 ?? null } : null,
+    }
+  }).sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0)
+  return sha256Canonical({ goal: spec?.project?.goal ?? '', referenceImages,
+    ...(spec?.project?.reviewSubjectId === undefined ? {} : { reviewSubjectId: spec.project.reviewSubjectId }) })
+}
+
 /**
  * The compact `SceneDigest` handed to the model (SPEC §7.2 `getScene`, §18
  * "FullSceneSpec 明确需要时才读取"): counts, framing facts and profiles, never
@@ -828,6 +1068,8 @@ export function summarizeSceneSpec(document, context = {}) {
       id: spec.project.id,
       title: spec.project.title,
       goal: spec.project.goal ?? null,
+      referenceImages: structuredClone(spec.project.referenceImages ?? []),
+      reviewSubjectId: spec.project.reviewSubjectId ?? null,
       fps: spec.project.fps,
       frameStart: spec.project.frameStart,
       frameEnd: spec.project.frameEnd,
@@ -849,6 +1091,7 @@ export function summarizeSceneSpec(document, context = {}) {
       type: entity.type,
       shape: entity.generator?.shape ?? null,
       materialId: entity.materialId ?? null,
+      ...(entity.materialBindings?.length ? { materialBindings: entity.materialBindings } : {}),
       location: entity.transform.location.map(round4),
       visible: entity.visible !== false,
       locked: entity.locked === true,
@@ -858,6 +1101,7 @@ export function summarizeSceneSpec(document, context = {}) {
       id: material.id,
       shader: material.shader,
       parameters: material.parameters ?? {},
+      ...(material.tangent ? { tangent: material.tangent } : {}),
     })),
     lights: lights.map(light => ({
       id: light.id,
@@ -903,6 +1147,7 @@ export function summarizeSceneSpec(document, context = {}) {
       declared: spec.world !== undefined,
       color: spec.world?.color ?? DEFAULT_WORLD.color,
       strength: spec.world?.strength ?? DEFAULT_WORLD.strength,
+      ...(spec.world?.environment ? { environment: spec.world.environment } : {}),
     },
     bounds: enclosing,
     subjectBounds,

package/lib/schema-types.d.ts

@@ -0,0 +1,185 @@
+/** Generated by deepblend/tools/generate-sdk-types.mjs. Do not edit.
+ * Types describe JSON shape. Numeric bounds, ID grammar and references still require validation. */
+
+/** Source SHA-256: e1d0fab58ba2263925efdee9e2489f205fde30e957b62b128c085f4706d6c11d */
+export namespace SceneSpecSchema {
+  export type Id = string;
+  export type World = { "color"?: SceneSpecSchema.UnitColor; "strength"?: number; "environment"?: { "assetId": SceneSpecSchema.Id; "rotation"?: number; }; };
+  export type Vec3 = [number, number, number];
+  export type UnitColor = Array<number>;
+  export type PositiveNumber = number;
+  export type NonNegativeNumber = number;
+  export type Project = { "id": SceneSpecSchema.Id; "title": string; "goal"?: string; "units"?: "metric" | "imperial"; "fps": number; "frameStart": number; "frameEnd": number; "aspectRatio": string; "activeCamera"?: string; "referenceImages"?: SceneSpecSchema.ReferenceImages; "reviewSubjectId"?: SceneSpecSchema.Id; };
+  export type License = { "source"?: string; "commercialUse"?: boolean; "attribution"?: string; };
+  export type Asset = { "id": SceneSpecSchema.Id; "type": "glb" | "gltf" | "fbx" | "obj" | "usd" | "blend" | "png" | "jpg" | "jpeg" | "hdr" | "exr"; "path": string; "sha256"?: string; "license"?: SceneSpecSchema.License; };
+  export type ProceduralTexture = ({ "type": "noise" | "wave" | "voronoi"; "scale": number; "detail"?: number; "distortion"?: number; "stretch"?: [number, number, number]; "bump"?: number; "roughnessVariation"?: number; "colorVariation"?: number; "coordinates"?: "object"; }) | ({ "type": "noise" | "wave" | "voronoi"; "scale": number; "detail"?: number; "distortion"?: number; "stretch"?: [number, number, number]; "bump"?: number; "roughnessVariation"?: number; "colorVariation"?: number; "coordinates": "uv"; "uvMap"?: string; });
+  export type Material = { "id": SceneSpecSchema.Id; "shader": "principled" | "emission" | "glass"; "parameters"?: { "baseColor"?: SceneSpecSchema.UnitColor; "metallic"?: number; "roughness"?: number; "ior"?: number; "alpha"?: number; "emissionColor"?: SceneSpecSchema.UnitColor; "emissionStrength"?: SceneSpecSchema.NonNegativeNumber; "coatWeight"?: number; "transmissionWeight"?: number; "anisotropic"?: number; "anisotropicRotation"?: number; }; "texture"?: SceneSpecSchema.ProceduralTexture; "images"?: SceneSpecSchema.MaterialImages; "tangent"?: SceneSpecSchema.MaterialTangent; };
+  export type Transform = { "location"?: SceneSpecSchema.Vec3; "rotationEuler"?: SceneSpecSchema.Vec3; "scale"?: SceneSpecSchema.Vec3; };
+  export type Generator = { "shape": "cube" | "uv_sphere" | "cylinder" | "cone" | "plane" | "torus" | "rounded_box" | "lathe" | "curve" | "handled_cup"; "size"?: SceneSpecSchema.PositiveNumber; "radius"?: SceneSpecSchema.PositiveNumber; "depth"?: SceneSpecSchema.PositiveNumber; "segments"?: number; "ringCount"?: number; "majorRadius"?: SceneSpecSchema.PositiveNumber; "minorRadius"?: SceneSpecSchema.PositiveNumber; "bevel"?: { "width"?: SceneSpecSchema.PositiveNumber; "segments"?: number; }; "profile"?: Array<[number, number]>; "closedProfile"?: boolean; "capEnds"?: boolean; "path"?: Array<SceneSpecSchema.Vec3>; "pathClosed"?: boolean; "pathInterpolation"?: "poly" | "bezier"; "curveResolution"?: number; "bevelResolution"?: number; "height"?: SceneSpecSchema.PositiveNumber; "wallThickness"?: SceneSpecSchema.PositiveNumber; "baseThickness"?: SceneSpecSchema.PositiveNumber; "footRound"?: SceneSpecSchema.PositiveNumber; "handleRadius"?: SceneSpecSchema.PositiveNumber; "handleLower"?: SceneSpecSchema.PositiveNumber; "handleUpper"?: SceneSpecSchema.PositiveNumber; "rootRadius"?: SceneSpecSchema.PositiveNumber; "rootLength"?: SceneSpecSchema.PositiveNumber; "sectionSegments"?: number; "handleSegments"?: number; "rootSegments"?: number; "wallRows"?: number; "rootTension"?: number; };
+  export type Entity = { "id": SceneSpecSchema.Id; "type": "asset-instance" | "generator" | "empty"; "assetId"?: string; "armatureId"?: string; "rigidBody"?: SceneSpecSchema.RigidBody; "cloth"?: SceneSpecSchema.Cloth; "softBody"?: SceneSpecSchema.SoftBody; "fluid"?: SceneSpecSchema.Fluid; "generator"?: SceneSpecSchema.Generator; "materialId"?: string; "transform"?: SceneSpecSchema.Transform; "tags"?: Array<string>; "locked"?: boolean; "visible"?: boolean; "modifiers"?: Array<SceneSpecSchema.ModelModifier>; "materialBindings"?: SceneSpecSchema.MaterialBindings; };
+  export type Light = { "id": SceneSpecSchema.Id; "type": "area" | "point" | "spot" | "sun"; "transform"?: SceneSpecSchema.Transform; "energy"?: SceneSpecSchema.NonNegativeNumber; "color"?: SceneSpecSchema.UnitColor; "size"?: SceneSpecSchema.PositiveNumber; "spotSize"?: number; "spotBlend"?: number; "angle"?: number; };
+  export type Camera = { "id": SceneSpecSchema.Id; "role"?: "active-camera" | "three-quarter" | "top" | "detail"; "lens"?: SceneSpecSchema.PositiveNumber; "sensorWidth"?: SceneSpecSchema.PositiveNumber; "clipping"?: [SceneSpecSchema.PositiveNumber, SceneSpecSchema.PositiveNumber]; "transform"?: SceneSpecSchema.Transform; "targetEntityId"?: string; "targetPoint"?: SceneSpecSchema.Vec3; "fStop"?: SceneSpecSchema.PositiveNumber; };
+  export type Shot = { "id": SceneSpecSchema.Id; "cameraId": string; "frameRange"?: [number, number]; "description"?: string; };
+  export type AnimationKeyframe = { "frame": number; "value": number; "interpolation"?: "constant" | "linear" | "bezier" | "ease_in" | "ease_out" | "ease_in_out"; };
+  export type AnimationTrack = { "id": SceneSpecSchema.Id; "targetKind"?: "entity" | "camera" | "material" | "bone"; "targetEntityId": string; "boneName"?: string; "property": "location.x" | "location.y" | "location.z" | "rotationEuler.x" | "rotationEuler.y" | "rotationEuler.z" | "scale.x" | "scale.y" | "scale.z" | "emissionStrength" | "roughness" | "metallic" | "ior" | "alpha" | "coatWeight" | "transmissionWeight" | "baseColor.r" | "baseColor.g" | "baseColor.b" | "emissionColor.r" | "emissionColor.g" | "emissionColor.b" | "anisotropic" | "anisotropicRotation"; "keyframes": Array<SceneSpecSchema.AnimationKeyframe>; };
+  export type RenderProfile = { "engine": "eevee" | "cycles" | "workbench"; "resolution": [number, number]; "samples"?: number; "filmTransparent"?: boolean; "raytracing"?: boolean; "colorManagement"?: { "viewTransform"?: "Standard" | "AgX" | "Filmic" | "False Color" | "Raw"; "look"?: string; "exposure"?: number; }; "maxSamplesBudget"?: number; };
+  export type RenderProfiles = { "preview": SceneSpecSchema.RenderProfile; "final"?: SceneSpecSchema.RenderProfile; };
+  export type Bone = { "name": string; "head": SceneSpecSchema.Vec3; "tail": SceneSpecSchema.Vec3; "parent"?: string; };
+  export type Armature = { "id": SceneSpecSchema.Id; "bones": Array<SceneSpecSchema.Bone>; "transform"?: SceneSpecSchema.Transform; };
+  export type RigidBody = { "kind": "active" | "passive"; "mass"?: number; "friction"?: number; };
+  export type Cloth = { "pinTop"?: boolean; "mass"?: number; "stiffness"?: number; };
+  export type SoftBody = { "pinTop"?: boolean; "goal"?: number; "mass"?: number; };
+  export type Fluid = { "role": "domain" | "inflow" | "outflow"; "domainType"?: "liquid" | "gas"; "resolution"?: number; "flowType"?: "liquid" | "smoke" | "fire" | "both"; };
+  export type ModelModifier = ({ "type": "solidify"; "thickness": number; "offset"?: number; }) | ({ "type": "mirror"; "axis": "x" | "y" | "z"; "merge"?: boolean; }) | ({ "type": "array"; "count": number; "offset": SceneSpecSchema.Vec3; }) | ({ "type": "boolean"; "operation": "union" | "difference" | "intersect"; "targetEntityId": SceneSpecSchema.Id; }) | ({ "type": "bevel"; "width": number; "segments"?: number; "angle"?: number; "miterInner"?: "arc" | "sharp"; });
+  export type ImageBinding = { "assetId": SceneSpecSchema.Id; "scale"?: SceneSpecSchema.Vec3; "offset"?: SceneSpecSchema.Vec3; "uvMap"?: string; "channel"?: "r" | "g" | "b" | "a"; "strength"?: number; };
+  export type MaterialImages = { "baseColor"?: SceneSpecSchema.ImageBinding; "roughness"?: SceneSpecSchema.ImageBinding; "metallic"?: SceneSpecSchema.ImageBinding; "normal"?: SceneSpecSchema.ImageBinding; "alpha"?: SceneSpecSchema.ImageBinding; "emissionColor"?: SceneSpecSchema.ImageBinding; };
+  export type MaterialBinding = { "partId": string; "slotIndex"?: number; "materialId": SceneSpecSchema.Id; };
+  export type MaterialBindings = Array<SceneSpecSchema.MaterialBinding>;
+  export type MaterialTangent = ({ "mode": "uv"; "uvMap": string; }) | ({ "mode": "radial"; "axis": "x" | "y" | "z"; });
+  export type ReferenceImage = { "id": SceneSpecSchema.Id; "assetId": SceneSpecSchema.Id; "sha256": string; "label": string; "purposes": Array<"geometry" | "materials" | "lighting" | "goalFit">; "notes"?: string; };
+  export type ReferenceImages = Array<SceneSpecSchema.ReferenceImage>;
+  export type Document = { "schemaVersion": "deepblend.scene/v1"; "project": SceneSpecSchema.Project; "assets"?: Array<SceneSpecSchema.Asset>; "armatures"?: Array<SceneSpecSchema.Armature>; "simulation"?: { "gravity"?: number; "bake"?: boolean; }; "materials"?: Array<SceneSpecSchema.Material>; "entities": Array<SceneSpecSchema.Entity>; "lights"?: Array<SceneSpecSchema.Light>; "cameras": Array<SceneSpecSchema.Camera>; "shots"?: Array<SceneSpecSchema.Shot>; "animationTracks"?: Array<SceneSpecSchema.AnimationTrack>; "renderProfiles": SceneSpecSchema.RenderProfiles; "world"?: SceneSpecSchema.World; };
+}
+export type SceneSpec = SceneSpecSchema.Document;
+
+/** Source SHA-256: e71dceb0a4aa93c664dbb8d894a1ffb156f4db13bc34ae4f0fdb2b10db386c06 */
+export namespace ScenePatchSchema {
+  export type Id = string;
+  export type License = { "source"?: string; "commercialUse"?: boolean; "attribution"?: string; };
+  export type Vec3 = [number, number, number];
+  export type World = { "color"?: ScenePatchSchema.UnitColor; "strength"?: number; "environment"?: { "assetId": ScenePatchSchema.Id; "rotation"?: number; }; };
+  export type UnitColor = Array<number>;
+  export type PositiveNumber = number;
+  export type NonNegativeNumber = number;
+  export type TransformPatch = { "location"?: ScenePatchSchema.Vec3; "rotationEuler"?: ScenePatchSchema.Vec3; "scale"?: ScenePatchSchema.Vec3; };
+  export type MaterialParameters = { "baseColor"?: ScenePatchSchema.UnitColor; "metallic"?: number; "roughness"?: number; "ior"?: number; "alpha"?: number; "emissionColor"?: ScenePatchSchema.UnitColor; "emissionStrength"?: ScenePatchSchema.NonNegativeNumber; "coatWeight"?: number; "transmissionWeight"?: number; "anisotropic"?: number; "anisotropicRotation"?: number; };
+  export type ProceduralTexture = ({ "type": "noise" | "wave" | "voronoi"; "scale": number; "detail"?: number; "distortion"?: number; "stretch"?: [number, number, number]; "bump"?: number; "roughnessVariation"?: number; "colorVariation"?: number; "coordinates"?: "object"; }) | ({ "type": "noise" | "wave" | "voronoi"; "scale": number; "detail"?: number; "distortion"?: number; "stretch"?: [number, number, number]; "bump"?: number; "roughnessVariation"?: number; "colorVariation"?: number; "coordinates": "uv"; "uvMap"?: string; });
+  export type Generator = { "shape": "cube" | "uv_sphere" | "cylinder" | "cone" | "plane" | "torus" | "rounded_box" | "lathe" | "curve" | "handled_cup"; "size"?: ScenePatchSchema.PositiveNumber; "radius"?: ScenePatchSchema.PositiveNumber; "depth"?: ScenePatchSchema.PositiveNumber; "segments"?: number; "ringCount"?: number; "majorRadius"?: ScenePatchSchema.PositiveNumber; "minorRadius"?: ScenePatchSchema.PositiveNumber; "bevel"?: { "width"?: ScenePatchSchema.PositiveNumber; "segments"?: number; }; "profile"?: Array<[number, number]>; "closedProfile"?: boolean; "capEnds"?: boolean; "path"?: Array<ScenePatchSchema.Vec3>; "pathClosed"?: boolean; "pathInterpolation"?: "poly" | "bezier"; "curveResolution"?: number; "bevelResolution"?: number; "height"?: ScenePatchSchema.PositiveNumber; "wallThickness"?: ScenePatchSchema.PositiveNumber; "baseThickness"?: ScenePatchSchema.PositiveNumber; "footRound"?: ScenePatchSchema.PositiveNumber; "handleRadius"?: ScenePatchSchema.PositiveNumber; "handleLower"?: ScenePatchSchema.PositiveNumber; "handleUpper"?: ScenePatchSchema.PositiveNumber; "rootRadius"?: ScenePatchSchema.PositiveNumber; "rootLength"?: ScenePatchSchema.PositiveNumber; "sectionSegments"?: number; "handleSegments"?: number; "rootSegments"?: number; "wallRows"?: number; "rootTension"?: number; };
+  export type Entity = { "id": ScenePatchSchema.Id; "type": "asset-instance" | "generator" | "empty"; "assetId"?: string; "generator"?: ScenePatchSchema.Generator; "materialId"?: string; "transform"?: { "location"?: ScenePatchSchema.Vec3; "rotationEuler"?: ScenePatchSchema.Vec3; "scale"?: ScenePatchSchema.Vec3; }; "tags"?: Array<string>; "locked"?: boolean; "visible"?: boolean; "modifiers"?: Array<ScenePatchSchema.ModelModifier>; "materialBindings"?: ScenePatchSchema.MaterialBindings; };
+  export type Light = { "id": ScenePatchSchema.Id; "type": "area" | "point" | "spot" | "sun"; "transform"?: { "location"?: ScenePatchSchema.Vec3; "rotationEuler"?: ScenePatchSchema.Vec3; "scale"?: ScenePatchSchema.Vec3; }; "energy"?: ScenePatchSchema.NonNegativeNumber; "color"?: ScenePatchSchema.UnitColor; "size"?: ScenePatchSchema.PositiveNumber; "spotSize"?: number; "spotBlend"?: number; "angle"?: number; };
+  export type Camera = { "id": ScenePatchSchema.Id; "role"?: "active-camera" | "three-quarter" | "top" | "detail"; "lens"?: ScenePatchSchema.PositiveNumber; "sensorWidth"?: ScenePatchSchema.PositiveNumber; "clipping"?: [ScenePatchSchema.PositiveNumber, ScenePatchSchema.PositiveNumber]; "transform"?: { "location"?: ScenePatchSchema.Vec3; "rotationEuler"?: ScenePatchSchema.Vec3; "scale"?: ScenePatchSchema.Vec3; }; "targetEntityId"?: string; "targetPoint"?: ScenePatchSchema.Vec3; "fStop"?: ScenePatchSchema.PositiveNumber; };
+  export type AnimationTrack = { "id": ScenePatchSchema.Id; "targetKind"?: "entity" | "camera" | "material"; "targetEntityId": string; "property": "location.x" | "location.y" | "location.z" | "rotationEuler.x" | "rotationEuler.y" | "rotationEuler.z" | "scale.x" | "scale.y" | "scale.z" | "emissionStrength" | "roughness" | "metallic" | "ior" | "alpha" | "coatWeight" | "transmissionWeight" | "baseColor.r" | "baseColor.g" | "baseColor.b" | "emissionColor.r" | "emissionColor.g" | "emissionColor.b" | "anisotropic" | "anisotropicRotation"; "keyframes": Array<{ "frame": number; "value": number; "interpolation"?: "constant" | "linear" | "bezier" | "ease_in" | "ease_out" | "ease_in_out"; }>; };
+  export type RenderProfile = { "engine"?: "eevee" | "cycles" | "workbench"; "resolution"?: [number, number]; "samples"?: number; "filmTransparent"?: boolean; "colorManagement"?: { "viewTransform"?: "Standard" | "AgX" | "Filmic" | "False Color" | "Raw"; "look"?: string; "exposure"?: number; }; "maxSamplesBudget"?: number; "raytracing"?: boolean; };
+  export type Operation = ({ "op": "entity.transform.update"; "entityId": ScenePatchSchema.Id; "location"?: ScenePatchSchema.Vec3; "rotationEuler"?: ScenePatchSchema.Vec3; "scale"?: ScenePatchSchema.Vec3; }) | ({ "op": "entity.visibility.set"; "entityId": ScenePatchSchema.Id; "visible": boolean; }) | ({ "op": "entity.tags.set"; "entityId": ScenePatchSchema.Id; "tags": Array<string>; }) | ({ "op": "entity.add"; "entity": ScenePatchSchema.Entity; }) | ({ "op": "entity.remove"; "entityId": ScenePatchSchema.Id; }) | ({ "op": "entity.material.set"; "entityId": ScenePatchSchema.Id; "materialId": string | null; }) | ({ "op": "material.texture.set"; "materialId": ScenePatchSchema.Id; "texture": (ScenePatchSchema.ProceduralTexture) | (null); }) | ({ "op": "material.add"; "material": { "id": ScenePatchSchema.Id; "shader": "principled" | "emission" | "glass"; "parameters"?: ScenePatchSchema.MaterialParameters; "texture"?: ScenePatchSchema.ProceduralTexture; "images"?: ScenePatchSchema.MaterialImages; "tangent"?: ScenePatchSchema.MaterialTangent; }; }) | ({ "op": "material.parameter.update"; "materialId": ScenePatchSchema.Id; "parameter": "baseColor" | "metallic" | "roughness" | "ior" | "alpha" | "emissionColor" | "emissionStrength" | "coatWeight" | "transmissionWeight" | "anisotropic" | "anisotropicRotation"; "value": (number) | (ScenePatchSchema.UnitColor); }) | ({ "op": "light.add"; "light": ScenePatchSchema.Light; }) | ({ "op": "light.update"; "lightId": ScenePatchSchema.Id; "transform"?: { "location"?: ScenePatchSchema.Vec3; "rotationEuler"?: ScenePatchSchema.Vec3; "scale"?: ScenePatchSchema.Vec3; }; "energy"?: ScenePatchSchema.NonNegativeNumber; "color"?: ScenePatchSchema.UnitColor; "size"?: ScenePatchSchema.PositiveNumber; "spotSize"?: number; "spotBlend"?: number; "angle"?: number; }) | ({ "op": "light.remove"; "lightId": ScenePatchSchema.Id; }) | ({ "op": "camera.add"; "camera": ScenePatchSchema.Camera; }) | ({ "op": "camera.update"; "cameraId": ScenePatchSchema.Id; "role"?: "active-camera" | "three-quarter" | "top" | "detail"; "lens"?: ScenePatchSchema.PositiveNumber; "sensorWidth"?: ScenePatchSchema.PositiveNumber; "clipping"?: [ScenePatchSchema.PositiveNumber, ScenePatchSchema.PositiveNumber]; "transform"?: { "location"?: ScenePatchSchema.Vec3; "rotationEuler"?: ScenePatchSchema.Vec3; "scale"?: ScenePatchSchema.Vec3; }; "targetEntityId"?: string; "targetPoint"?: ScenePatchSchema.Vec3; "fStop"?: ScenePatchSchema.PositiveNumber; }) | ({ "op": "camera.remove"; "cameraId": ScenePatchSchema.Id; }) | ({ "op": "animation.track.set"; "track": ScenePatchSchema.AnimationTrack; }) | ({ "op": "animation.track.remove"; "trackId": ScenePatchSchema.Id; }) | ({ "op": "shot.set"; "shot": { "id": ScenePatchSchema.Id; "cameraId": string; "frameRange"?: [number, number]; "description"?: string; }; }) | ({ "op": "shot.remove"; "shotId": ScenePatchSchema.Id; }) | ({ "op": "project.frameRange.set"; "frameStart": number; "frameEnd": number; "fps"?: number; }) | ({ "op": "render.profile.set"; "profileName": "preview" | "final"; "profile": ScenePatchSchema.RenderProfile; }) | ({ "op": "world.set"; "world": ScenePatchSchema.World; }) | ({ "op": "asset.add"; "asset": { "id": ScenePatchSchema.Id; "type": "glb" | "gltf" | "fbx" | "obj" | "usd" | "blend" | "png" | "jpg" | "jpeg" | "hdr" | "exr"; "path": string; "sha256"?: string; "license"?: ScenePatchSchema.License; }; }) | ({ "op": "asset.remove"; "assetId": ScenePatchSchema.Id; }) | ({ "op": "entity.generator.set"; "entityId": ScenePatchSchema.Id; "generator": ScenePatchSchema.Generator; }) | ({ "op": "entity.modifiers.set"; "entityId": ScenePatchSchema.Id; "modifiers": Array<ScenePatchSchema.ModelModifier>; }) | ({ "op": "material.images.set"; "materialId": ScenePatchSchema.Id; "images": (ScenePatchSchema.MaterialImages) | (null); }) | ({ "op": "entity.materialBindings.set"; "entityId": ScenePatchSchema.Id; "materialBindings": ScenePatchSchema.MaterialBindings; }) | ({ "op": "material.tangent.set"; "materialId": ScenePatchSchema.Id; "tangent": (ScenePatchSchema.MaterialTangent) | (null); }) | ({ "op": "project.brief.set"; "goal": string; "referenceImages": ScenePatchSchema.ReferenceImages; }) | ({ "op": "project.reviewSubject.set"; "entityId": (ScenePatchSchema.Id) | (null); });
+  export type ModelModifier = ({ "type": "solidify"; "thickness": number; "offset"?: number; }) | ({ "type": "mirror"; "axis": "x" | "y" | "z"; "merge"?: boolean; }) | ({ "type": "array"; "count": number; "offset": ScenePatchSchema.Vec3; }) | ({ "type": "boolean"; "operation": "union" | "difference" | "intersect"; "targetEntityId": ScenePatchSchema.Id; }) | ({ "type": "bevel"; "width": number; "segments"?: number; "angle"?: number; "miterInner"?: "arc" | "sharp"; });
+  export type ImageBinding = { "assetId": ScenePatchSchema.Id; "scale"?: ScenePatchSchema.Vec3; "offset"?: ScenePatchSchema.Vec3; "uvMap"?: string; "channel"?: "r" | "g" | "b" | "a"; "strength"?: number; };
+  export type MaterialImages = { "baseColor"?: ScenePatchSchema.ImageBinding; "roughness"?: ScenePatchSchema.ImageBinding; "metallic"?: ScenePatchSchema.ImageBinding; "normal"?: ScenePatchSchema.ImageBinding; "alpha"?: ScenePatchSchema.ImageBinding; "emissionColor"?: ScenePatchSchema.ImageBinding; };
+  export type MaterialBinding = { "partId": string; "slotIndex"?: number; "materialId": ScenePatchSchema.Id; };
+  export type MaterialBindings = Array<ScenePatchSchema.MaterialBinding>;
+  export type MaterialTangent = ({ "mode": "uv"; "uvMap": string; }) | ({ "mode": "radial"; "axis": "x" | "y" | "z"; });
+  export type ReferenceImage = { "id": ScenePatchSchema.Id; "assetId": ScenePatchSchema.Id; "sha256": string; "label": string; "purposes": Array<"geometry" | "materials" | "lighting" | "goalFit">; "notes"?: string; };
+  export type ReferenceImages = Array<ScenePatchSchema.ReferenceImage>;
+  export type Document = { "projectId": string; "baseRevision": string; "idempotencyKey"?: string; "operations": Array<ScenePatchSchema.Operation>; "saveCheckpoint"?: boolean; "renderPreview"?: boolean; "actor"?: string; "stage"?: string; "note"?: string; };
+}
+export type ScenePatch = ScenePatchSchema.Document;
+
+/** Source SHA-256: d1f5b189bbf0e5cab018be87ce52757acfd208c24b1fa07d087947ed98e20ad5 */
+export namespace RecipeSchema {
+  export type Binding = ({ "kind": "material"; "materialId": string; "property": "baseColor" | "roughness"; }) | ({ "kind": "render-profile"; "profile": "preview" | "final"; "property": "exposure"; });
+  export type ColorParameter = { "id": string; "title": string; "description"?: string; "bindings": Array<RecipeSchema.Binding>; "type": "color"; "default": [number, number, number]; };
+  export type NumberParameter = { "id": string; "title": string; "description"?: string; "bindings": Array<RecipeSchema.Binding>; "type": "number"; "default": number; "minimum": number; "maximum": number; };
+  export type Document = { "schemaVersion": "deepblend.recipe/v1"; "id": string; "version": string; "title": string; "description": string; "author": { "name": string; "url"?: string; }; "license": string; "source": { "url": string; "note"?: string; }; "compatibility": { "sceneSchemaVersion": "deepblend.scene/v1"; "capabilities": Array<"geometry.primitive" | "geometry.lathe" | "geometry.curve" | "geometry.handled_cup" | "geometry.handled_cup.tension" | "geometry.handled_cup.tension.extended" | "geometry.modifiers" | "material.principled" | "material.glass" | "material.emission" | "material.procedural" | "material.procedural.uv" | "material.anisotropy" | "animation.transform" | "animation.material">; }; "input": { "path": "scene-spec.json"; "sha256": string; }; "preview": { "path": "preview.png"; "sha256": string; "mediaType": "image/png"; "alt": string; }; "parameters": Array<(RecipeSchema.ColorParameter) | (RecipeSchema.NumberParameter)>; };
+}
+export type RecipeManifest = RecipeSchema.Document;
+export type Entity = SceneSpecSchema.Entity;
+export type Generator = SceneSpecSchema.Generator;
+export type ModelModifier = SceneSpecSchema.ModelModifier;
+export type Material = SceneSpecSchema.Material;
+export type Asset = SceneSpecSchema.Asset;
+export type Camera = SceneSpecSchema.Camera;
+export type Light = SceneSpecSchema.Light;
+export type Transform = SceneSpecSchema.Transform;
+export type AnimationTrack = SceneSpecSchema.AnimationTrack;
+export type RenderProfile = SceneSpecSchema.RenderProfile;
+export type ReferenceImage = SceneSpecSchema.ReferenceImage;
+export type MaterialBinding = SceneSpecSchema.MaterialBinding;
+export type MaterialTangent = SceneSpecSchema.MaterialTangent;
+export type Vec3 = SceneSpecSchema.Vec3;
+export type ScenePatchOperation = ScenePatchSchema.Operation;
+export type RecipeCapability = RecipeManifest["compatibility"]["capabilities"][number];
+export interface BlenderErrorCodeMap {
+  readonly NOT_FOUND: "BLENDER_NOT_FOUND";
+  readonly EXECUTABLE_NOT_EXECUTABLE: "BLENDER_EXECUTABLE_NOT_EXECUTABLE";
+  readonly EXECUTABLE_OUTSIDE_ALLOWLIST: "BLENDER_EXECUTABLE_OUTSIDE_ALLOWLIST";
+  readonly SPAWN_FAILED: "BLENDER_SPAWN_FAILED";
+  readonly NONZERO_EXIT: "BLENDER_NONZERO_EXIT";
+  readonly TIMEOUT: "BLENDER_TIMEOUT";
+  readonly ABORTED: "BLENDER_ABORTED";
+  readonly RESULT_MISSING: "BLENDER_RESULT_MISSING";
+  readonly RESULT_UNPARSEABLE: "BLENDER_RESULT_UNPARSEABLE";
+  readonly SCRIPT_ERROR: "BLENDER_SCRIPT_ERROR";
+  readonly PROTOCOL_VERSION_MISMATCH: "BLENDER_PROTOCOL_VERSION_MISMATCH";
+  readonly UNSUPPORTED_ACTION: "BLENDER_UNSUPPORTED_ACTION";
+  readonly CAPABILITY_PROBE_FAILED: "BLENDER_CAPABILITY_PROBE_FAILED";
+  readonly BOOTSTRAP_MISSING: "BLENDER_BOOTSTRAP_MISSING";
+  readonly ENGINE_UNAVAILABLE: "BLENDER_ENGINE_UNAVAILABLE";
+  readonly RUNTIME_UNAVAILABLE: "BLENDER_RUNTIME_UNAVAILABLE";
+  readonly PROJECT_NOT_FOUND: "PROJECT_NOT_FOUND";
+  readonly PROJECT_CORRUPT: "PROJECT_CORRUPT";
+  readonly PROJECT_EXISTS: "PROJECT_EXISTS";
+  readonly PROJECT_ID_INVALID: "PROJECT_ID_INVALID";
+  readonly REVISION_NOT_FOUND: "REVISION_NOT_FOUND";
+  readonly REVISION_CORRUPT: "REVISION_CORRUPT";
+  readonly REVISION_CHECKPOINT_MISSING: "REVISION_CHECKPOINT_MISSING";
+  readonly REVISION_CONFLICT: "REVISION_CONFLICT";
+  readonly REVISION_ALLOCATION_FAILED: "REVISION_ALLOCATION_FAILED";
+  readonly REVISION_ID_INVALID: "REVISION_ID_INVALID";
+  readonly SCENE_SPEC_INVALID: "SCENE_SPEC_INVALID";
+  readonly SCENE_PATCH_INVALID: "SCENE_PATCH_INVALID";
+  readonly SCENE_PATCH_REJECTED: "SCENE_PATCH_REJECTED";
+  readonly SCENE_VALIDATION_FAILED: "SCENE_VALIDATION_FAILED";
+  readonly SCENE_CAMERA_MISSING: "SCENE_CAMERA_MISSING";
+  readonly PATH_OUTSIDE_WORKSPACE: "PATH_OUTSIDE_WORKSPACE";
+  readonly PATH_SEGMENT_INVALID: "PATH_SEGMENT_INVALID";
+  readonly ASSET_MISSING: "ASSET_MISSING";
+  readonly ASSET_FORMAT_UNAVAILABLE: "ASSET_FORMAT_UNAVAILABLE";
+  readonly ASSET_HASH_MISMATCH: "ASSET_HASH_MISMATCH";
+  readonly ASSET_REQUEST_INVALID: "ASSET_REQUEST_INVALID";
+  readonly ASSET_SOURCE_NOT_FOUND: "ASSET_SOURCE_NOT_FOUND";
+  readonly ASSET_TOO_LARGE: "ASSET_TOO_LARGE";
+  readonly ASSET_FETCH_FAILED: "ASSET_FETCH_FAILED";
+  readonly ASSET_CONTENT_MISMATCH: "ASSET_CONTENT_MISMATCH";
+  readonly DISK_FULL: "DISK_FULL";
+  readonly SCENE_TOO_HEAVY: "SCENE_TOO_HEAVY";
+  readonly ASSET_APPROVAL_REQUIRED: "ASSET_APPROVAL_REQUIRED";
+  readonly RENDER_PROFILE_MISSING: "RENDER_PROFILE_MISSING";
+  readonly VISUAL_REVIEW_MODEL_UNAVAILABLE: "VISUAL_REVIEW_MODEL_UNAVAILABLE";
+  readonly RENDER_BUDGET_EXCEEDED: "RENDER_BUDGET_EXCEEDED";
+  readonly RENDER_NO_OUTPUT: "RENDER_NO_OUTPUT";
+  readonly RENDER_JOB_NOT_FOUND: "RENDER_JOB_NOT_FOUND";
+  readonly RENDER_JOB_CONFLICT: "RENDER_JOB_CONFLICT";
+  readonly RENDER_JOB_STATE_INVALID: "RENDER_JOB_STATE_INVALID";
+  readonly RENDER_RANGE_INVALID: "RENDER_RANGE_INVALID";
+  readonly RENDER_FRAMES_INCOMPLETE: "RENDER_FRAMES_INCOMPLETE";
+  readonly ENCODER_NOT_FOUND: "ENCODER_NOT_FOUND";
+  readonly ENCODE_FAILED: "ENCODE_FAILED";
+  readonly ENCODE_VERIFY_FAILED: "ENCODE_VERIFY_FAILED";
+  readonly PROBE_FAILED: "PROBE_FAILED";
+  readonly DELIVERY_INCOMPLETE: "DELIVERY_INCOMPLETE";
+  readonly EXPORT_IN_PROGRESS: "EXPORT_IN_PROGRESS";
+  readonly RENDER_APPROVAL_REQUIRED: "RENDER_APPROVAL_REQUIRED";
+  readonly UI_ROUTE_NOT_FOUND: "UI_ROUTE_NOT_FOUND";
+  readonly ARTIFACT_NOT_FOUND: "ARTIFACT_NOT_FOUND";
+  readonly UI_REQUEST_FAILED: "UI_REQUEST_FAILED";
+  readonly UI_HOST_API_STALE: "UI_HOST_API_STALE";
+}
+export interface BlenderWarningCodeMap {
+  readonly BLENDER_NOT_INSTALLED: "BLENDER_NOT_INSTALLED";
+  readonly ENGINE_NOT_IN_STATIC_ENUM: "ENGINE_NOT_IN_STATIC_ENUM";
+  readonly ENGINE_UNAVAILABLE: "ENGINE_UNAVAILABLE";
+  readonly ENGINE_DOWNGRADED: "ENGINE_DOWNGRADED";
+  readonly GPU_UNAVAILABLE: "GPU_UNAVAILABLE";
+  readonly FORMAT_UNAVAILABLE: "FORMAT_UNAVAILABLE";
+  readonly ADDON_ENABLE_FAILED: "ADDON_ENABLE_FAILED";
+  readonly PROBE_WARNING: "PROBE_WARNING";
+  readonly STALE_CAPABILITIES: "STALE_CAPABILITIES";
+  readonly SCENE_PATCH_NO_CHANGE: "SCENE_PATCH_NO_CHANGE";
+  readonly RENDER_ENGINE_DOWNGRADED: "RENDER_ENGINE_DOWNGRADED";
+  readonly RENDER_SAMPLES_REDUCED: "RENDER_SAMPLES_REDUCED";
+  readonly SCENE_COMPILER_DECISION: "SCENE_COMPILER_DECISION";
+  readonly SCENE_ASSET_NOT_INGESTED: "SCENE_ASSET_NOT_INGESTED";
+  readonly SCENE_ANIMATION_KEYFRAMES_ADJUSTED: "SCENE_ANIMATION_KEYFRAMES_ADJUSTED";
+  readonly JOB_PROJECTION_UNAVAILABLE: "JOB_PROJECTION_UNAVAILABLE";
+  readonly DELIVERY_CLAIM_UNAVAILABLE: "DELIVERY_CLAIM_UNAVAILABLE";
+  readonly JOURNAL_INCOMPLETE: "JOURNAL_INCOMPLETE";
+}