@vgai/engine 0.5.2 → 0.5.4

package/src/scene/scene-query.ts

@@ -1,63 +0,0 @@
-import type * as THREE from 'three';
-import { getUserData } from './user-data';
-
-/**
- * Runtime queries over a loaded THREE scene graph (P1.6d).
- *
- * The scene's `tags` schema field is documented as "for runtime queries" but,
- * until now, no query existed. These helpers walk a THREE.Object3D graph and
- * read entity metadata off `userData`, so gameplay code can find objects by tag,
- * name, or attached component without bookkeeping its own indexes.
- *
- * Canonical metadata locations (in priority order):
- *   - tags:       `userData['tags']` (string[])     — falls back to `userData['entity'].tags`
- *   - name:       `Object3D.name`
- *   - components: `userData['components']` (record or string[]) — falls back to
- *                 `userData['entity'].components` (record keyed by component name)
- */
-
-function getTags(obj: THREE.Object3D): string[] {
-  const direct = getUserData(obj, 'tags');
-  if (Array.isArray(direct)) return direct;
-  const fromDef = getUserData(obj, 'entity')?.tags;
-  return Array.isArray(fromDef) ? fromDef : [];
-}
-
-function getComponentNames(obj: THREE.Object3D): string[] {
-  const direct = getUserData(obj, 'components');
-  if (Array.isArray(direct)) return direct;
-  if (direct && typeof direct === 'object') return Object.keys(direct);
-  const fromDef = getUserData(obj, 'entity')?.components;
-  if (fromDef && typeof fromDef === 'object') return Object.keys(fromDef);
-  return [];
-}
-
-/** All objects in the graph carrying the given tag (depth-first, document order). */
-export function queryByTag(root: THREE.Object3D, tag: string): THREE.Object3D[] {
-  const matches: THREE.Object3D[] = [];
-  root.traverse((obj) => {
-    if (getTags(obj).includes(tag)) matches.push(obj);
-  });
-  return matches;
-}
-
-/** All objects in the graph with the given name (depth-first, document order). */
-export function queryByName(root: THREE.Object3D, name: string): THREE.Object3D[] {
-  const matches: THREE.Object3D[] = [];
-  root.traverse((obj) => {
-    if (obj.name === name) matches.push(obj);
-  });
-  return matches;
-}
-
-/**
- * All objects in the graph that have the named component attached
- * (depth-first, document order).
- */
-export function queryByComponent(root: THREE.Object3D, componentName: string): THREE.Object3D[] {
-  const matches: THREE.Object3D[] = [];
-  root.traverse((obj) => {
-    if (getComponentNames(obj).includes(componentName)) matches.push(obj);
-  });
-  return matches;
-}

package/src/scene/scene-types.ts

@@ -1,33 +0,0 @@
-/**
- * Scene file types — derived from Zod schemas (single source of truth).
- *
- * Raw types for the .vscn.json file format. Both the editor and the runtime
- * loader work with these directly, applying DEFAULTS (./defaults.ts) for omitted
- * fields — DEFAULTS is the single source of truth for default values.
- */
-
-export type {
-  InstancesFile,
-  MaterialFile,
-  PrefabFile,
-  SceneAnimation,
-  SceneAudio,
-  SceneCamera,
-  SceneCollider,
-  SceneEntity,
-  SceneEnvironment,
-  SceneFile,
-  SceneJoint,
-  SceneLight,
-  SceneMaterial,
-  SceneMesh,
-  SceneNavigation,
-  SceneParticles,
-  ScenePhysics,
-  ScenePhysicsSettings,
-  ScenePostProcessing,
-  SceneSpline,
-  SceneToneMapping,
-} from './schema';
-
-export { mergePrefabInstance } from './schema';

package/src/scene/scene-version.ts

@@ -1,40 +0,0 @@
-/**
- * The scene/prefab file format `version` range this engine checkout can
- * load (T2.3/D3 §1.E, docs/ENGINE-UPGRADE-DESIGN.md). `[min, max]` — today
- * `[1, 1]`: every shipped `.vscn.json`/`.prefab.json` is version 1, and no
- * migration machinery exists yet (a future format bump widens `max`, and a
- * future engine that drops support for `1` would raise `min`).
- *
- * Deliberately NOT in `./schema/` (that directory's byte contents are
- * pinned by `packages/engine/schemas/engine-capabilities.json`'s
- * `schemaDirHash`, refreshed only by `scripts/capabilities-hash.ts` — this
- * slice does not run that script). This is also why the check below is a
- * POST-Zod-parse function here in `scene/`, not a Zod refinement inside
- * `SceneFileSchema`/`PrefabFileSchema`: the generated `vscn.schema.json`/
- * `prefab.schema.json` stay byte-identical (the `version` field itself is
- * still just `z.number()`).
- */
-export const SUPPORTED_SCENE_VERSION_RANGE: readonly [number, number] = [1, 1];
-
-/**
- * Throw if `version` falls outside `SUPPORTED_SCENE_VERSION_RANGE`; silently
- * accept in-range versions. `fileKind` only changes the error message's noun
- * (`.vscn.json` and `.prefab.json` share this single version axis — verified
- * both schemas declare their own `version: z.number()` field, not a shared
- * ref, but the same counter/semantics per docs/ENGINE-UPGRADE-DESIGN.md).
- */
-export function checkSceneVersionInRange(
-  version: number,
-  fileKind: 'scene' | 'prefab' = 'scene',
-): void {
-  const [min, max] = SUPPORTED_SCENE_VERSION_RANGE;
-  if (version >= min && version <= max) return;
-  const cause =
-    version > max
-      ? `the engine checkout is older than this ${fileKind}`
-      : `this ${fileKind} predates the oldest supported format version`;
-  throw new Error(
-    `${fileKind} version ${version} is outside the supported range [${min}, ${max}] — ` +
-      `${cause}; see docs/ENGINE-UPGRADE-DESIGN.md`,
-  );
-}

package/src/scene/schema/animation.ts

@@ -1,46 +0,0 @@
-import { z } from 'zod';
-
-// ---------------------------------------------------------------------------
-// D8 — declarative property tracks (formerly F5,
-// docs/VSCN-STRUCTURAL-GAPS-DESIGN.md) were REMOVED: Theatre
-// (`@theatre/core`) is the sole authored continuous-animation source (spec
-// §3.2, §10 D2-D4/D8). `PropertyTrackSchema`/`PropertyTrackRunner` and the
-// `tracks` field are deleted, not deprecated-in-place — see
-// packages/engine/src/scene/parse.ts (`assertNoRemovedPropertyTracks`) for
-// the loud migration-error guard that rejects any `.vscn`/`.prefab.json`
-// still authoring `animation.tracks`, since Zod would otherwise silently
-// strip an unrecognized field rather than failing loudly (Global AC §6).
-//
-// E5 — the AnimGraph state-machine runtime, `.animgraph.json` format, and
-// every consumer were removed (spec §3.3, §11 E5; XState + native Three
-// `AnimationMixer` replace it — see `xstate-animation-binding.ts`). The
-// `animGraph` field is deleted outright, not deprecated-in-place, for the
-// same reason as `tracks` above: Zod's default object mode would otherwise
-// silently STRIP an authored `animation.animGraph` rather than reporting it,
-// violating Global AC §6 ("Removed formats fail with a concise migration/
-// removal error rather than being partially read"). The raw-JSON guard
-// (`assertNoRemovedAnimGraph` in packages/engine/src/scene/parse.ts) rejects
-// any `.vscn`/`.prefab.json` still authoring it before Zod ever parses the
-// data — see packages/engine/test/anim-graph-removed.test.ts.
-//
-// `parameters` is deleted alongside `animGraph`, though it isn't itself named
-// in the spec/removal-inventory: its ONLY documented purpose was seeding an
-// `AnimGraph`'s initial parameter values (its only readers were
-// `scene-loader.ts`'s former animGraph branch, the editor's entity-factory.ts,
-// and AnimationSection.tsx's parameter-row UI — all deleted with the runtime).
-// Leaving it declared with zero remaining readers would violate this repo's
-// "no schema field without a runtime reader" policy (CLAUDE.md).
-// ---------------------------------------------------------------------------
-
-export const SceneAnimationSchema = z
-  .object({
-    autoplay: z.string().optional().describe('Clip name to play automatically on load'),
-    loop: z.boolean().optional().describe('Whether the autoplay clip should loop'),
-    clipAliases: z
-      .record(z.string(), z.string())
-      .optional()
-      .describe('Map raw GLTF clip names to clean names'),
-  })
-  .describe('Animation playback configuration');
-
-export type SceneAnimation = z.infer<typeof SceneAnimationSchema>;

package/src/scene/schema/audio.ts

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-
-export const SceneAudioSchema = z
-  .object({
-    src: z.string().optional().describe('Path to audio file (WAV, MP3, OGG)'),
-    spatial: z.boolean().optional().describe('Enable 3D spatial audio (positional sound)'),
-    volume: z.number().optional().describe('Playback volume 0–1'),
-    refDistance: z
-      .number()
-      .optional()
-      .describe('Distance at which volume starts to attenuate (spatial only)'),
-    rolloffFactor: z
-      .number()
-      .optional()
-      .describe('How quickly volume attenuates with distance (spatial only)'),
-    maxDistance: z
-      .number()
-      .optional()
-      .describe('Maximum distance at which sound is audible (spatial only)'),
-    loop: z.boolean().optional().describe('Whether the audio should loop'),
-    autoplay: z.boolean().optional().describe('Start playing automatically when the scene loads'),
-  })
-  .describe('Audio source configuration');
-
-export type SceneAudio = z.infer<typeof SceneAudioSchema>;

package/src/scene/schema/entity-ref.ts

@@ -1,78 +0,0 @@
-import { z } from 'zod';
-
-/**
- * F6 (`docs/VSCN-STRUCTURAL-GAPS-DESIGN.md`) — a first-class, reusable
- * reference from one entity to another, for a `GameComponent`'s own static
- * Zod schema (e.g. `target: EntityRefSchema` — "this button opens THAT
- * door"). A branded string: on disk (and through generic component-data
- * validation) it is a plain string id, but a component field typed
- * `EntityRef` is compile-time distinct from an arbitrary `string` field, so a
- * bare label can't be assigned where a ref is expected.
- *
- * Resolution is a runtime concern, not a schema one: `scene-loader.ts`'s
- * `resolveEntityRefs` (the post-spawn pass, modeled on `joint.target`'s
- * existing resolution) rewrites the field from the authored string id to the
- * live `THREE.Object3D` — through the SAME `idMap` `createSceneJoints`
- * already uses, no new registry (G3) — before the referencing component's
- * `init()` runs.
- */
-export const EntityRefSchema = z
-  .string()
-  .brand<'EntityRef'>()
-  .describe(
-    'A reference to another entity by its authored id. On disk it is a plain string id; the ' +
-      'scene loader resolves it to the live THREE.Object3D (WorldNode-as-truth) before the ' +
-      "referencing component's init() runs. A ref to a missing id is a loud load error.",
-  );
-
-export type EntityRef = z.infer<typeof EntityRefSchema>;
-
-/**
- * Identity registry of the `EntityRefSchema` object (there is exactly one —
- * this module's export), used by {@link isEntityRefSchema}.
- *
- * Why identity rather than a Zod "type name" check: zod 4's `.brand()` is a
- * type-only cast (see zod's own source — `inst.brand = () => inst`), not a
- * distinct wrapper class runtime code could switch on. A branded schema is,
- * at runtime, just the underlying `ZodString` (here, after `.describe()`
- * clones it once more — see zod's `check()`/`clone()`). So "is this an
- * EntityRef field" can only be answered by reference identity against the
- * one schema object every ref field is declared with — which is exactly
- * what we want anyway: a look-alike `z.string()` field must NOT count.
- */
-const ENTITY_REF_SCHEMAS = new WeakSet<object>();
-ENTITY_REF_SCHEMAS.add(EntityRefSchema);
-
-/**
- * Just enough of zod 4's internal `_def` shape to unwrap wrapper schemas.
- * Typed against `z.core.$ZodType` (the base/"core" schema type, NOT the
- * fuller "classic" `z.ZodType`) because that's what a `z.ZodObject`'s
- * `.shape` values are typed as (`ZodRawShape = core.$ZodShape`) — the type
- * every field schema `resolveEntityRefs` (`scene-loader.ts`) actually walks
- * arrives as.
- */
-interface UnwrappableDef {
-  innerType?: z.core.$ZodType;
-}
-
-/**
- * Is `schema` an {@link EntityRefSchema} field — including when wrapped by
- * `.optional()`, `.default(...)`, or `.nullable()` (the common ways a
- * component author would declare an optional ref)? Unwraps those via zod 4's
- * internal `_def.innerType` (there is no public reflection API for this —
- * `packages/editor/src/components/inspectors/zod-fields.ts` uses the same
- * mechanism to introspect component schemas for the inspector) down to the
- * core schema, then checks it against the registered `EntityRefSchema`
- * instance by reference.
- */
-export function isEntityRefSchema(schema: z.core.$ZodType): boolean {
-  let cur: z.core.$ZodType | undefined = schema;
-  while (cur) {
-    if (ENTITY_REF_SCHEMAS.has(cur)) return true;
-    const inner: z.core.$ZodType | undefined = (cur as unknown as { _def?: UnwrappableDef })._def
-      ?.innerType;
-    if (!inner) return false;
-    cur = inner;
-  }
-  return false;
-}

package/src/scene/schema/entity.ts

@@ -1,189 +0,0 @@
-import { z } from 'zod';
-import { buildRenderingZod } from '../../render/render-features';
-import { SceneAnimationSchema } from './animation';
-import { SceneAudioSchema } from './audio';
-import { SceneCameraOverrideSchema, SceneCameraSchema } from './camera';
-import { SceneJointSchema } from './joint';
-import { SceneLightOverrideSchema, SceneLightSchema } from './light';
-import { SceneMaterialOverrideSchema, SceneMaterialSchema } from './material';
-import { SceneMeshOverrideSchema, SceneMeshSchema } from './mesh';
-import { SceneParticlesOverrideSchema, SceneParticlesSchema } from './particles';
-import { ScenePhysicsOverrideSchema, ScenePhysicsSchema } from './physics';
-import { SceneShadowOverrideSchema, SceneShadowSchema } from './shadow';
-import { SceneSplineOverrideSchema, SceneSplineSchema } from './spline';
-import { TransformSchema, Vec3Schema } from './tuples';
-
-const BoneAttachmentSchema = z
-  .object({
-    target: z.string().describe('Entity ID whose animated skeleton owns the target bone'),
-    bone: z.string().describe('Exact name of the target bone or socket Object3D'),
-  })
-  .describe(
-    'Attach this entity to a named bone/socket after the complete scene has loaded. The entity transform becomes its local attachment offset',
-  );
-
-/**
- * User-defined ECS component data. Validated at runtime against ComponentRegistry.
- *
- * Scalars (number/string/boolean) plus homogeneous arrays of those scalars so
- * that vec3 (number[3]) and other array fields produced by the schema-driven
- * inspector round-trip through parse/validate. The component's own static Zod
- * schema (GameComponent.schema) does the precise per-field validation at load.
- *
- * F6 (`docs/VSCN-STRUCTURAL-GAPS-DESIGN.md`) entity refs (`EntityRefSchema`,
- * `./entity-ref.ts`) are branded strings — structurally still a `string` on
- * disk and through this coarse, per-component-agnostic schema, so they
- * already parse via the `z.string()` branch below without a dedicated union
- * member. (Deliberately not added as an explicit branch: this record's VALUE
- * schema is the one place in the file with no `.describe()` calls anywhere in
- * it — see `schema-consumption-map.ts`'s `entity.components` entry — and
- * `EntityRefSchema` carries one, which would flip `entity.components` from a
- * plain leaf into a `subtree: true` entry for no behavioral gain: the
- * precise, per-field validation of a ref — and the brand — comes from the
- * referencing component's OWN static schema in `applyComponents`, not from
- * this generic envelope.)
- */
-const ComponentScalarSchema = z.union([z.number(), z.string(), z.boolean()]);
-const ComponentValueSchema = z.union([
-  ComponentScalarSchema,
-  z.array(z.number()),
-  z.array(z.string()),
-  z.array(z.boolean()),
-]);
-const ComponentDataSchema = z.record(z.string(), ComponentValueSchema);
-const ComponentsSchema = z.record(z.string(), ComponentDataSchema);
-
-const NavigationRoleSchema = z
-  .object({
-    role: z
-      .enum(['walkable', 'obstacle'])
-      .describe('Whether this entity is walkable surface or an obstacle'),
-  })
-  .describe('Navigation mesh role');
-
-// Fields shared by both standalone and prefab instance entities
-const SharedEntityFields = {
-  id: z.string().optional().describe('Unique entity ID. Auto-generated if omitted'),
-  name: z.string().describe('Human-readable entity name (shown in hierarchy panel)'),
-  visible: z.boolean().optional().describe('Whether the entity and its children are rendered'),
-  locked: z.boolean().optional().describe('Prevent selection and editing in the scene editor'),
-  tags: z.array(z.string()).optional().describe('Arbitrary string tags for runtime queries'),
-  prefab: z.string().optional().describe('Path to .prefab.json file to instantiate'),
-  materialRef: z
-    .string()
-    .optional()
-    .describe('Path to shared .mat.json material asset. Mutually exclusive with inline material'),
-  transform: TransformSchema.optional().describe('Local transform relative to parent'),
-  boneAttachment: BoneAttachmentSchema.optional().describe(
-    'Animated bone/socket attachment. Use transform for the local position, rotation, and scale offset',
-  ),
-  pivot: Vec3Schema.optional().describe(
-    'Local-space pivot point for rotation/scale. [0,0,0] = geometry center',
-  ),
-  navigation: NavigationRoleSchema.optional().describe('Navigation mesh role for this entity'),
-  render: buildRenderingZod({ perEntityOnly: true })
-    .optional()
-    .describe(
-      'Per-entity render overrides (e.g. autoBatch:false to keep a custom-shader entity out of batching). Omit to inherit from the scene/engine default.',
-    ),
-  components: ComponentsSchema.optional().describe(
-    'User-defined ECS component data (validated against component registry)',
-  ),
-};
-
-// Standalone entities: full section validation (type fields required)
-const StandaloneEntityBase = z.object({
-  ...SharedEntityFields,
-  mesh: SceneMeshSchema.optional().describe('Mesh geometry'),
-  material: SceneMaterialSchema.optional().describe('Material appearance'),
-  light: SceneLightSchema.optional().describe('Light source'),
-  shadow: SceneShadowSchema.optional().describe('Shadow configuration'),
-  physics: ScenePhysicsSchema.optional().describe('Physics rigid body'),
-  camera: SceneCameraSchema.optional().describe('Camera'),
-  audio: SceneAudioSchema.optional().describe('Audio source'),
-  animation: SceneAnimationSchema.optional().describe('Animation configuration'),
-  particles: SceneParticlesSchema.optional().describe('Particle system'),
-  spline: SceneSplineSchema.optional().describe('Spline path'),
-  joints: z
-    .array(SceneJointSchema)
-    .optional()
-    .describe('Physics joints connecting to other bodies'),
-});
-
-// Prefab instance entities: section overrides are partial (merged with prefab root at load time)
-const PrefabInstanceBase = z.object({
-  ...SharedEntityFields,
-  prefab: z.string().describe('Path to .prefab.json file to instantiate'),
-  mesh: SceneMeshOverrideSchema.optional().describe('Mesh overrides merged with prefab'),
-  material: SceneMaterialOverrideSchema.optional().describe(
-    'Material overrides merged with prefab',
-  ),
-  light: SceneLightOverrideSchema.optional().describe('Light overrides merged with prefab'),
-  shadow: SceneShadowOverrideSchema.optional().describe('Shadow overrides merged with prefab'),
-  physics: ScenePhysicsOverrideSchema.optional().describe('Physics overrides merged with prefab'),
-  camera: SceneCameraOverrideSchema.optional().describe('Camera overrides merged with prefab'),
-  audio: SceneAudioSchema.optional().describe('Audio source'),
-  animation: SceneAnimationSchema.optional().describe('Animation configuration'),
-  particles: SceneParticlesOverrideSchema.optional().describe(
-    'Particle overrides merged with prefab',
-  ),
-  spline: SceneSplineOverrideSchema.optional().describe('Spline overrides merged with prefab'),
-  joints: z
-    .array(SceneJointSchema)
-    .optional()
-    .describe('Physics joints connecting to other bodies'),
-});
-
-/**
- * SceneEntity type — the strict form used by all consumer code.
- * Section types have required discriminant fields (type, bodyType, etc.).
- *
- * Prefab instances in scene files may have partial sections, but they are
- * always completed by mergePrefabInstance() before being consumed.
- */
-export type SceneEntity = z.infer<typeof StandaloneEntityBase> & {
-  children?: SceneEntity[] | undefined;
-};
-
-/**
- * Validation schema for scene entity JSON.
- *
- * Standalone entities are validated strictly (section discriminants required).
- * Prefab instances accept partial section overrides — these are merged with
- * the prefab root at load time via mergePrefabInstance().
- *
- * Typed as SceneEntity (strict) because prefab instances always go through
- * mergePrefabInstance() before any code reads their section data.
- */
-export const SceneEntitySchema: z.ZodType<SceneEntity> = z.lazy(() =>
-  z
-    .union([
-      StandaloneEntityBase.extend({
-        children: z.array(SceneEntitySchema).optional().describe('Child entities'),
-      }),
-      PrefabInstanceBase.extend({
-        children: z.array(SceneEntitySchema).optional().describe('Child entities'),
-      }),
-    ])
-    // P1.6a: `material` (inline) and `materialRef` (shared .mat.json asset) are
-    // mutually exclusive — allowing both lets one silently win at load time.
-    // Reject up front instead of trapping the author.
-    .superRefine((entity, ctx) => {
-      if (entity.material !== undefined && entity.materialRef !== undefined) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message:
-            'An entity cannot set both `material` (inline) and `materialRef` (shared .mat.json asset). Choose one.',
-          path: ['material'],
-        });
-      }
-      if (entity.boneAttachment !== undefined && entity.physics !== undefined) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message:
-            'A bone-attached entity cannot declare physics. Attachments follow an animated transform; add gameplay collision to a separate entity.',
-          path: ['boneAttachment'],
-        });
-      }
-    }),
-) as z.ZodType<SceneEntity>;

package/src/scene/schema/index.ts

@@ -1,51 +0,0 @@
-// Zod schemas
-
-export type { SceneAnimation } from './animation';
-export { SceneAnimationSchema } from './animation';
-export type { SceneAudio } from './audio';
-export { SceneAudioSchema } from './audio';
-export type { SceneCamera } from './camera';
-export { SceneCameraSchema } from './camera';
-export type { SceneCollider } from './collider';
-export { SceneColliderSchema } from './collider';
-export type { SceneEntity } from './entity';
-export { SceneEntitySchema } from './entity';
-export type { EntityRef } from './entity-ref';
-export { EntityRefSchema, isEntityRefSchema } from './entity-ref';
-export type {
-  SceneEnvironment,
-  SceneNavigation,
-  ScenePhysicsSettings,
-  ScenePostProcessing,
-  SceneToneMapping,
-} from './environment';
-export {
-  SceneEnvironmentSchema,
-  SceneNavigationSchema,
-  ScenePhysicsSettingsSchema,
-  ScenePostProcessingSchema,
-  SceneToneMappingSchema,
-} from './environment';
-export type { InstancesFile } from './instances';
-export { InstancesFileSchema } from './instances';
-export type { SceneJoint } from './joint';
-export { SceneJointSchema } from './joint';
-export type { SceneLight } from './light';
-export { SceneLightSchema } from './light';
-export type { MaterialFile, SceneMaterial } from './material';
-export { MaterialFileSchema, SceneMaterialSchema } from './material';
-export type { SceneMesh } from './mesh';
-export { SceneMeshSchema } from './mesh';
-export type { SceneParticles } from './particles';
-export { SceneParticlesOverrideSchema, SceneParticlesSchema } from './particles';
-export type { ScenePhysics } from './physics';
-export { ScenePhysicsSchema } from './physics';
-export type { PrefabFile, SceneFile } from './scene-file';
-export { mergePrefabInstance, PrefabFileSchema, SceneFileSchema } from './scene-file';
-export type { SceneShadow } from './shadow';
-export { SceneShadowSchema } from './shadow';
-export type { SceneSpline } from './spline';
-export { SceneSplineOverrideSchema, SceneSplineSchema } from './spline';
-// Inferred types
-export type { Quat, SceneTransform, Vec3 } from './tuples';
-export { QuatSchema, TransformSchema, Vec3Schema } from './tuples';

package/src/scene/schema/joint.ts

@@ -1,26 +0,0 @@
-import { z } from 'zod';
-import { Vec3Schema } from './tuples';
-
-export const SceneJointSchema = z
-  .object({
-    type: z
-      .enum(['fixed', 'revolute', 'prismatic', 'spherical', 'spring'])
-      .describe('Joint constraint type'),
-    target: z.string().describe('Entity ID of the body this joint connects to'),
-    anchor: Vec3Schema.optional().describe('Local anchor point on this body'),
-    targetAnchor: Vec3Schema.optional().describe('Local anchor point on the target body'),
-    axis: Vec3Schema.optional().describe('Rotation/slide axis for revolute and prismatic joints'),
-    limits: z
-      .object({
-        min: z.number().describe('Minimum angle (degrees) or distance'),
-        max: z.number().describe('Maximum angle (degrees) or distance'),
-      })
-      .optional()
-      .describe('Angle or distance limits for revolute/prismatic joints'),
-    stiffness: z.number().optional().describe('Spring stiffness coefficient'),
-    damping: z.number().optional().describe('Spring damping coefficient'),
-    restLength: z.number().optional().describe('Spring rest length'),
-  })
-  .describe('Physics joint constraint between two bodies');
-
-export type SceneJoint = z.infer<typeof SceneJointSchema>;

package/src/scene/schema/physics.ts

@@ -1,49 +0,0 @@
-import { z } from 'zod';
-import { SceneColliderOverrideSchema, SceneColliderSchema } from './collider';
-
-export const ScenePhysicsSchema = z
-  .object({
-    bodyType: z
-      .enum(['dynamic', 'fixed', 'kinematic'])
-      .describe(
-        'Physics body type: dynamic (simulated), fixed (immovable), kinematic (script-driven). ' +
-          'T1.1/R1c: ANY physics body (dynamic, fixed, OR kinematic) nested under an ancestor ' +
-          'entity that itself has a "dynamic" or "kinematic" body is unsupported (loud load ' +
-          'error) — Rapier has no parent/child body relationship, so a moving ancestor cannot ' +
-          "carry a nested body of ANY type with it; the child's Object3D would stay pinned to " +
-          "its own (non-moving) body's pose while the ancestor moves out from under it. " +
-          'Nesting under a "fixed"/static or physics-less transformed ancestor is fine.',
-      ),
-    mass: z
-      .number()
-      .optional()
-      .describe('Explicit mass override. If omitted, computed from collider density and volume'),
-    collider: SceneColliderSchema.describe(
-      'Collider shape attached to this body. T1.1/T1.2: the Rapier body is created at this ' +
-        "entity's COMPOSED WORLD transform (parent chain × own local transform) — Rapier has " +
-        "no concept of a parent Object3D, so nested entities' transforms are baked in at spawn " +
-        'time, not read live thereafter.',
-    ),
-  })
-  .describe('Physics rigid body configuration');
-
-/** Partial override — uses SceneColliderOverrideSchema for deep partial on collider. */
-export const ScenePhysicsOverrideSchema = z.object({
-  bodyType: z
-    .enum(['dynamic', 'fixed', 'kinematic'])
-    .optional()
-    .describe(
-      'Physics body type: dynamic (simulated), fixed (immovable), kinematic (script-driven). ' +
-        'A body of ANY type nested under a "dynamic"/"kinematic"-bodied ancestor throws a loud ' +
-        'load error (T1.1/R1c) — see ScenePhysicsSchema.bodyType.',
-    ),
-  mass: z
-    .number()
-    .optional()
-    .describe('Explicit mass override. If omitted, computed from collider density and volume'),
-  collider: SceneColliderOverrideSchema.optional().describe(
-    'Partial collider overrides merged with prefab',
-  ),
-});
-
-export type ScenePhysics = z.infer<typeof ScenePhysicsSchema>;