@vgai/engine 0.5.2 → 0.5.3

package/src/scene/schema/scene-file.ts

@@ -1,292 +0,0 @@
-import { z } from 'zod';
-import { type SceneEntity, SceneEntitySchema } from './entity';
-import { SceneEnvironmentSchema } from './environment';
-
-export const SceneFileSchema = z
-  .object({
-    version: z.number().describe('Scene file format version'),
-    name: z.string().describe('Scene display name'),
-    environment: SceneEnvironmentSchema.optional().describe('Scene-level environment settings'),
-    entities: z.array(SceneEntitySchema).describe('Top-level entities in the scene'),
-  })
-  .strict()
-  .describe('Scene file (.vscn.json)');
-
-export type SceneFile = z.infer<typeof SceneFileSchema>;
-
-export const PrefabFileSchema = z
-  .object({
-    version: z.number().describe('Prefab file format version'),
-    name: z.string().describe('Prefab display name'),
-    root: SceneEntitySchema.describe('Root entity of the prefab'),
-  })
-  .describe('Prefab file (.prefab.json)');
-
-export type PrefabFile = z.infer<typeof PrefabFileSchema>;
-
-/**
- * Shallow-merge a section, but deep-merge specific named nested sub-objects
- * within it (e.g. `physics.collider`, `material.clearcoat`). A partial
- * instance override of a nested sub-object would otherwise wholesale-replace
- * it and drop the prefab's other fields in that sub-object (e.g. an instance
- * overriding one collider field would silently lose the prefab's `type`).
- */
-function mergeSectionDeepNested<T extends Record<string, unknown>>(
-  prefabSection: T | undefined,
-  instanceSection: T | undefined,
-  nestedKeys: readonly (keyof T)[],
-): T | undefined {
-  if (instanceSection === undefined) return prefabSection;
-  if (prefabSection === undefined) return instanceSection;
-  const merged: Record<string, unknown> = { ...prefabSection, ...instanceSection };
-  for (const key of nestedKeys) {
-    const p = prefabSection[key];
-    const i = instanceSection[key];
-    if (
-      i !== undefined &&
-      p !== undefined &&
-      typeof i === 'object' &&
-      typeof p === 'object' &&
-      !Array.isArray(i) &&
-      !Array.isArray(p)
-    ) {
-      merged[key as string] = { ...(p as object), ...(i as object) };
-    }
-  }
-  return merged as T;
-}
-
-/**
- * Sections whose nested sub-object needs deep merging (T1.10) — see the
- * `mergePrefabInstance` docstring for the reasoning behind each.
- */
-const DEEP_NESTED_SECTIONS = [
-  { key: 'physics', nestedKeys: ['collider'] },
-  { key: 'material', nestedKeys: ['clearcoat', 'transmission', 'sheen', 'iridescence'] },
-  { key: 'shadow', nestedKeys: ['camera'] },
-] as const;
-
-/**
- * Re-validate a merged entity through `SceneEntitySchema` (T1.10). This is
- * the gate that catches a prefab's inline `material` combined with an
- * instance's `materialRef` (or vice versa) — each half is individually valid,
- * so only the MERGED entity can trip the material/materialRef
- * mutual-exclusion refine. Throws naming the offending prefab path + instance
- * so a bad scene file points straight at the offender.
- */
-function validateMergedEntity(merged: SceneEntity, instance: SceneEntity): SceneEntity {
-  const validated = SceneEntitySchema.safeParse(merged);
-  if (validated.success) return validated.data;
-  const issues = validated.error.issues.map((issue) => issue.message).join('; ');
-  const prefabPath = instance.prefab ?? '<unknown prefab>';
-  throw new Error(
-    `Prefab merge produced an invalid entity — prefab "${prefabPath}", instance "${instance.name}": ${issues}`,
-  );
-}
-
-/**
- * Merge a prefab root definition with an instance's overrides.
- *
- * Per-field merge rules (exactly as implemented below):
- *
- * - transform: instance wins entirely if set, else the prefab root's transform
- *   (placement is per-instance; transforms are not blended field-by-field).
- * - name: instance always wins.
- * - id: instance wins if set (each instance has its own id); else prefab's.
- * - prefab: stripped from the result so spawnEntity recursion terminates.
- *
- * - Sections — `mesh`, `light`, `camera`, `animation`, `audio`, `particles`,
- *   `spline`, `render`: SHALLOW merge per section. If the instance sets the
- *   section, its top-level fields override the prefab root's same-named
- *   fields ({ ...prefabSection, ...instanceSection }); fields the instance
- *   omits fall through to the prefab. Nested objects are replaced, not
- *   deep-merged. If only the prefab has the section it is kept as-is.
- *   (CB4: `spline` is included here; CB5: see metadata below; T1.10: `render`
- *   is now included — an instance's per-entity render overrides are honored
- *   and merged the same way as `mesh`/`material`.)
- *
- *   NOTE (T1.10 audit): `animation.parameters`/`animation.clipAliases` are keyed dict maps nested
- *   one level down, and `particles` nests discriminated-union shapes/behaviors
- *   arrays. These have the same "shallow replace" defect as `material`/
- *   `physics` did, but no single well-defined field-merge semantics (dict keys
- *   authors may legitimately want fully replaced; discriminated unions can't
- *   be safely field-merged across different variants). Left as wholesale
- *   per-section replace; flagged here rather than silently "fixed" with a
- *   guess. Revisit if this causes real authoring pain.
- *
- * - `material`: shallow merge at the top level, PLUS deep-merge of the four
- *   nested physical-material feature groups (`clearcoat`, `transmission`,
- *   `sheen`, `iridescence`) so an instance overriding e.g. `clearcoat.clearcoat`
- *   preserves the prefab's `clearcoat.clearcoatRoughness` (T1.10 — previously
- *   these nested groups were wholesale-replaced like any other shallow field).
- *
- * - `physics`: shallow merge at the top level (`bodyType`, `mass`), PLUS
- *   deep-merge of the nested `collider` object so a partial instance collider
- *   override (e.g. just `isSensor`) preserves the prefab's `type` and other
- *   collider fields instead of dropping them (T1.10 AC).
- *
- * - `shadow`: shallow merge at the top level, PLUS deep-merge of the nested
- *   `camera` (shadow-camera frustum bounds) object, for the same reason as
- *   `physics.collider` (T1.10 audit — same defect, same fix).
- *
- * - components: DEEP merge, keyed by component name. The union of component
- *   names is taken; for each, instance fields override prefab fields
- *   ({ ...prefabComp, ...instanceComp }).
- *
- * - joints: REPLACE — if the instance sets joints, its array wins wholesale
- *   (arrays are not field-mergeable); else the prefab's joints are kept.
- * - children: APPEND — prefab children first, then instance-only children.
- *
- * - Instance-level metadata `visible`, `materialRef`, `tags`, `locked`,
- *   `navigation`, `pivot`: instance wins if explicitly set, otherwise the
- *   prefab root's value is inherited. (CB5: spline + these metadata fields are
- *   now instance-wins; previously dropped.)
- *
- * - Re-validation (T1.10): the merged entity is re-parsed through
- *   `SceneEntitySchema` before being returned. This is what makes the
- *   material/materialRef mutual-exclusion refine fire on the MERGED result —
- *   previously a prefab's inline `material` plus an instance's `materialRef`
- *   (or vice versa) silently combined into an entity carrying both, bypassing
- *   the refine entirely (it only ever saw the pre-merge, individually-valid
- *   halves). A merge that produces an invalid entity now throws, naming the
- *   offending prefab path + instance name.
- */
-export function mergePrefabInstance(prefabRoot: SceneEntity, instance: SceneEntity): SceneEntity {
-  const merged: SceneEntity = {
-    ...prefabRoot,
-    name: instance.name,
-  };
-
-  // Handle optional fields explicitly to satisfy exactOptionalPropertyTypes
-  const resolvedTransform = instance.transform ?? prefabRoot.transform;
-  if (resolvedTransform) merged.transform = resolvedTransform;
-  if (instance.id) merged.id = instance.id;
-
-  // Strip prefab field so spawnEntity won't recurse infinitely
-  delete merged.prefab;
-
-  applyInstanceMetadata(merged, prefabRoot, instance);
-  applyDeepNestedSections(merged, prefabRoot, instance);
-  applyShallowSections(merged, prefabRoot, instance);
-
-  const components = mergeComponents(prefabRoot, instance);
-  if (components !== undefined) merged.components = components;
-
-  // Joints: instance wins (array, not shallow-mergeable)
-  if (instance.joints !== undefined) {
-    merged.joints = instance.joints;
-  }
-
-  const children = mergeChildren(prefabRoot, instance);
-  if (children !== undefined) merged.children = children;
-
-  // Re-validate the merged result (T1.10) — see `validateMergedEntity` above.
-  return validateMergedEntity(merged, instance);
-}
-
-/**
- * Visibility + instance-level metadata (`materialRef`, `tags`, `locked`,
- * `navigation`, `pivot`): instance wins if explicitly set, otherwise the
- * prefab root's value (already present on `merged` via the initial spread in
- * `mergePrefabInstance`) is kept.
- */
-function applyInstanceMetadata(
-  merged: SceneEntity,
-  prefabRoot: SceneEntity,
-  instance: SceneEntity,
-): void {
-  if (instance.visible !== undefined) merged.visible = instance.visible;
-  if (instance.materialRef !== undefined) merged.materialRef = instance.materialRef;
-  if (instance.tags !== undefined) merged.tags = instance.tags;
-  if (instance.locked !== undefined) merged.locked = instance.locked;
-  if (instance.navigation !== undefined) merged.navigation = instance.navigation;
-
-  if (instance.pivot !== undefined) {
-    merged.pivot = instance.pivot;
-  } else if (prefabRoot.pivot !== undefined) {
-    merged.pivot = prefabRoot.pivot;
-  }
-}
-
-/**
- * Sections whose nested sub-object needs deep (not shallow) merging — see the
- * `mergePrefabInstance` docstring for the reasoning behind each.
- */
-function applyDeepNestedSections(
-  merged: SceneEntity,
-  prefabRoot: SceneEntity,
-  instance: SceneEntity,
-): void {
-  for (const { key, nestedKeys } of DEEP_NESTED_SECTIONS) {
-    const result = mergeSectionDeepNested(
-      // biome-ignore lint/suspicious/noExplicitAny: TS can't correlate indexed access across a union of keys
-      (prefabRoot as any)[key],
-      // biome-ignore lint/suspicious/noExplicitAny: TS can't correlate indexed access across a union of keys
-      (instance as any)[key],
-      nestedKeys,
-    );
-    // biome-ignore lint/suspicious/noExplicitAny: TS can't correlate indexed access across a union of keys
-    if (result !== undefined) (merged as any)[key] = result;
-  }
-}
-
-/** Sections shallow-merged whole (material/physics/shadow handled separately above). */
-const SHALLOW_SECTIONS = [
-  'mesh',
-  'light',
-  'camera',
-  'animation',
-  'audio',
-  'particles',
-  'spline',
-  'render',
-] as const;
-
-/**
- * Shallow merge per remaining section — instance fields override within the
- * section ({ ...prefabSection, ...instanceSection }); if only the prefab has
- * the section it is kept as-is.
- */
-function applyShallowSections(
-  merged: SceneEntity,
-  prefabRoot: SceneEntity,
-  instance: SceneEntity,
-): void {
-  for (const key of SHALLOW_SECTIONS) {
-    if (instance[key] === undefined) continue;
-    // biome-ignore lint/suspicious/noExplicitAny: TS can't correlate indexed access across a union of keys
-    (merged as any)[key] =
-      prefabRoot[key] !== undefined
-        ? // biome-ignore lint/suspicious/noExplicitAny: TS can't correlate indexed access across a union of keys
-          { ...(prefabRoot as any)[key], ...(instance as any)[key] }
-        : instance[key];
-  }
-}
-
-/** Deep merge `components`, keyed by component name (instance fields win per-component). */
-function mergeComponents(
-  prefabRoot: SceneEntity,
-  instance: SceneEntity,
-):
-  | Record<string, Record<string, number | string | boolean | number[] | string[] | boolean[]>>
-  | undefined {
-  if (!instance.components && !prefabRoot.components) return undefined;
-  const base = prefabRoot.components ?? {};
-  const over = instance.components ?? {};
-  const result: Record<
-    string,
-    Record<string, number | string | boolean | number[] | string[] | boolean[]>
-  > = {};
-  for (const comp of new Set([...Object.keys(base), ...Object.keys(over)])) {
-    result[comp] = { ...base[comp], ...over[comp] };
-  }
-  return result;
-}
-
-/** Children: prefab children first, then instance-only children appended. */
-function mergeChildren(prefabRoot: SceneEntity, instance: SceneEntity): SceneEntity[] | undefined {
-  const prefabChildren = prefabRoot.children ?? [];
-  const instanceChildren = instance.children ?? [];
-  if (prefabChildren.length === 0 && instanceChildren.length === 0) return undefined;
-  return [...prefabChildren, ...instanceChildren];
-}

package/src/scene/schema/shadow.ts

@@ -1,24 +0,0 @@
-import { z } from 'zod';
-
-export const SceneShadowSchema = z
-  .object({
-    enabled: z.boolean().describe('Whether this light casts shadows'),
-    mapSize: z.number().optional().describe('Shadow map resolution in pixels (e.g. 1024, 2048)'),
-    camera: z
-      .object({
-        left: z.number().optional().describe('Left bound of shadow camera frustum'),
-        right: z.number().optional().describe('Right bound of shadow camera frustum'),
-        top: z.number().optional().describe('Top bound of shadow camera frustum'),
-        bottom: z.number().optional().describe('Bottom bound of shadow camera frustum'),
-      })
-      .optional()
-      .describe('Shadow camera frustum bounds (directional lights)'),
-    radius: z.number().optional().describe('Shadow map blur radius for soft shadows'),
-    bias: z.number().optional().describe('Shadow bias to reduce shadow acne artifacts'),
-  })
-  .describe('Shadow casting configuration');
-
-/** Partial schema for prefab instance overrides (enabled not required). */
-export const SceneShadowOverrideSchema = SceneShadowSchema.partial();
-
-export type SceneShadow = z.infer<typeof SceneShadowSchema>;

package/src/scene/schema/spline.ts

@@ -1,21 +0,0 @@
-import { z } from 'zod';
-import { Vec3Schema } from './tuples';
-
-export const SceneSplineSchema = z.object({
-  curveType: z
-    .enum(['centripetal', 'chordal', 'catmullrom'])
-    .describe('CatmullRomCurve3 parameterization type. Matches Three.js curveType parameter'),
-  points: z.array(Vec3Schema).min(2).describe('Control point positions in local space'),
-  closed: z.boolean().optional().describe('Whether the spline forms a closed loop'),
-  tension: z
-    .number()
-    .optional()
-    .describe(
-      'Curve tension (default 0.5). Only used when curveType is catmullrom; ignored for centripetal and chordal',
-    ),
-  resolution: z.number().optional().describe('Number of line segments for rendering the curve'),
-});
-
-export type SceneSpline = z.infer<typeof SceneSplineSchema>;
-
-export const SceneSplineOverrideSchema = SceneSplineSchema.partial();

package/src/world2d/asset-paths2d.ts

@@ -1,44 +0,0 @@
-import type { Entity2D, Entity2DAsset, Scene2DFile } from './schema/entity2d';
-
-function visit(entities: Entity2D[], apply: (entity: Entity2D) => void): void {
-  for (const entity of entities) {
-    apply(entity);
-    if (entity.children) visit(entity.children, apply);
-  }
-}
-
-export function collectEntity2DAssetPaths(entities: Entity2D[]): Set<string> {
-  const paths = new Set<string>();
-  visit(entities, (entity) => {
-    if (entity.sprite?.texture) paths.add(entity.sprite.texture);
-    if (entity.tilemap?.texture) paths.add(entity.tilemap.texture);
-  });
-  return paths;
-}
-
-function rename(entities: Entity2D[], oldPath: string, newPath: string): void {
-  visit(entities, (entity) => {
-    if (entity.sprite?.texture === oldPath) entity.sprite.texture = newPath;
-    if (entity.tilemap?.texture === oldPath) entity.tilemap.texture = newPath;
-  });
-}
-
-export function applyScene2DAssetRename(
-  document: Scene2DFile,
-  oldPath: string,
-  newPath: string,
-): Scene2DFile {
-  const cloned = structuredClone(document);
-  rename(cloned.entities, oldPath, newPath);
-  return cloned;
-}
-
-export function applyEntity2DAssetRename(
-  asset: Entity2DAsset,
-  oldPath: string,
-  newPath: string,
-): Entity2DAsset {
-  const cloned = structuredClone(asset);
-  rename([cloned.root], oldPath, newPath);
-  return cloned;
-}

package/src/world2d/capture-to-scene2d.ts

@@ -1,52 +0,0 @@
-import type { Container } from 'pixi.js';
-import type { Entity2D, Scene2DFile } from './schema/entity2d';
-
-/**
- * Capture an ingested/live PixiJS subtree into authored Scene2D entities — the
- * world2d analog of capture-to-vscn (`ingest-capture.ts`). Recognizable sprites/
- * text/containers map to first-party `sprite`/`text`/`transform2d` sections;
- * turns inspection into portable authored content.
- *
- * Honest ceiling (mirrors the 3D one): a Scene2D `sprite` expresses tint + size +
- * anchor, not an arbitrary texture/GraphicsContext, so a captured display keeps its
- * transform + tint + size; bespoke Graphics geometry is captured as a plain tinted
- * sprite placeholder.
- */
-function numToHex(n: number | undefined): string {
-  return `#${((n ?? 0xffffff) & 0xffffff).toString(16).padStart(6, '0')}`;
-}
-
-function captureNode(o: Container): Entity2D {
-  const ctor = o.constructor?.name?.toLowerCase() ?? '';
-  const entity: Entity2D = {
-    name: o.label ?? ctor ?? 'entity',
-    surface: 'world2d',
-    transform2d: {
-      position: [o.position.x, o.position.y],
-      rotation: o.rotation,
-      scale: [o.scale.x, o.scale.y],
-    },
-  };
-  if (ctor.includes('text')) {
-    entity.text = { text: (o as { text?: string }).text ?? '' };
-  } else if (ctor.includes('sprite')) {
-    entity.sprite = {
-      tint: numToHex((o as { tint?: number }).tint),
-      width: Math.round(o.width),
-      height: Math.round(o.height),
-    };
-  }
-  const kids = o.children?.filter((c) => (c as Container).label !== undefined) ?? [];
-  if (kids.length) entity.children = kids.map((c) => captureNode(c as Container));
-  return entity;
-}
-
-/** Capture selected subtree roots (by display object) into a Scene2D file. */
-export function captureToScene2D(roots: Container[], name = 'captured-world2d'): Scene2DFile {
-  return {
-    version: 1,
-    name,
-    surface: 'world2d',
-    entities: roots.map(captureNode),
-  };
-}

package/src/world2d/collision-2d.ts

@@ -1,99 +0,0 @@
-import type RAPIER from '@dimforge/rapier2d-compat';
-import type { NodeOf } from '../ecs/game-component';
-import type { Physics2DRegistry } from './physics2d-registry';
-import type { World2DContext } from './types';
-
-export type Collision2DHandler = (handleA: number, handleB: number, started: boolean) => void;
-
-/**
- * Drains the Rapier 2D event queue each postPhysics and dispatches collision
- * events — the world2d analog of `createCollisionSystem`. Events are buffered then
- * handlers run after the drain returns (same re-entrancy guard as the 3D system:
- * a handler must not call back into Rapier while the queue is borrowed).
- */
-export function createCollision2DSystem(rapierWorld: RAPIER.World, eventQueue: RAPIER.EventQueue) {
-  const handlers: Collision2DHandler[] = [];
-  return {
-    onCollision(handler: Collision2DHandler) {
-      handlers.push(handler);
-    },
-    offCollision(handler: Collision2DHandler) {
-      const idx = handlers.indexOf(handler);
-      if (idx !== -1) handlers.splice(idx, 1);
-    },
-    drain() {
-      const events: Array<[number, number, boolean]> = [];
-      eventQueue.drainCollisionEvents((h1, h2, started) => {
-        events.push([h1, h2, started]);
-      });
-      for (const [h1, h2, started] of events) {
-        for (let i = 0; i < handlers.length; i++) handlers[i]!(h1, h2, started);
-      }
-    },
-    getBodyHandleFromCollider(colliderHandle: number): number | undefined {
-      const collider = rapierWorld.getCollider(colliderHandle);
-      return collider?.parent()?.handle;
-    },
-  };
-}
-
-export type Collision2DSystem = ReturnType<typeof createCollision2DSystem>;
-
-/**
- * The minimal component-manager capability `createTriggerDispatch2D` needs —
- * `getComponents` returning instances with optional trigger callbacks, typed
- * honestly against `NodeOf<'pixijs'>` (T7.2, D8 — this dispatch is always
- * pixi-world-scoped) rather than the full manager type. Deliberately a
- * structural slice: the unified `ComponentManager` (`ecs/component-manager.ts`,
- * what production wires up since T7.3 slice 1, and the only manager left —
- * the world2d silo's manager is deleted, T7.3 slice 2) satisfies it — this
- * dispatcher has no dependency on which `AdapterSurface` a caller's manager was
- * constructed for.
- */
-export interface TriggerDispatchComponents {
-  getComponents(node: NodeOf<'pixijs'>): ReadonlyArray<{
-    onTriggerEnter?(other: NodeOf<'pixijs'>, ctx: World2DContext): void;
-    onTriggerExit?(other: NodeOf<'pixijs'>, ctx: World2DContext): void;
-  }>;
-}
-
-/**
- * Turn Rapier 2D sensor overlaps into `onTriggerEnter`/`onTriggerExit` callbacks on
- * the GameComponents of the two involved display objects — the 2D analog of
- * `createTriggerDispatch`. Only sensor-involved collisions dispatch triggers.
- *
- * The callback receives the native `World2DContext`; Pixi components do not
- * widen or cast their lifecycle context to reach their own first-party APIs.
- */
-export function createTriggerDispatch2D(
-  physics: Physics2DRegistry,
-  components: TriggerDispatchComponents,
-  rapierWorld: RAPIER.World,
-  ctx: World2DContext,
-): Collision2DHandler {
-  return (handleA, handleB, started) => {
-    const colA = rapierWorld.getCollider(handleA);
-    const colB = rapierWorld.getCollider(handleB);
-    if (!colA?.isSensor() && !colB?.isSensor()) return;
-
-    const objA = physics.getByColliderHandle(handleA);
-    const objB = physics.getByColliderHandle(handleB);
-    if (!objA || !objB) return;
-
-    notify(components, objA, objB, started, ctx);
-    notify(components, objB, objA, started, ctx);
-  };
-}
-
-function notify(
-  components: TriggerDispatchComponents,
-  self: NodeOf<'pixijs'>,
-  other: NodeOf<'pixijs'>,
-  started: boolean,
-  ctx: World2DContext,
-): void {
-  for (const inst of components.getComponents(self)) {
-    if (started) inst.onTriggerEnter?.(other, ctx);
-    else inst.onTriggerExit?.(other, ctx);
-  }
-}

package/src/world2d/entity2d-asset.ts

@@ -1,22 +0,0 @@
-import { SceneParseError } from '../scene/parse';
-import { type Entity2D, type Entity2DAsset, Entity2DAssetSchema } from './schema/entity2d';
-
-/** Parse fetched reusable 2D entity bytes through the same named-error
- * convention as every other authored project asset. */
-export function parseEntity2DAsset(value: unknown, sourceName?: string): Entity2DAsset {
-  const result = Entity2DAssetSchema.safeParse(value);
-  if (!result.success) throw new SceneParseError(result.error.issues, sourceName);
-  return result.data;
-}
-
-/** Copy a reusable subtree into a scene. Every copy receives fresh authored
- * identities so repeated drops cannot alias hierarchy/history targets. */
-export function instantiateEntity2DAsset(asset: Entity2DAsset): Entity2D {
-  const root = structuredClone(asset.root);
-  const assignFreshIds = (entity: Entity2D): void => {
-    entity.id = crypto.randomUUID();
-    for (const child of entity.children ?? []) assignFreshIds(child);
-  };
-  assignFreshIds(root);
-  return root;
-}

package/src/world2d/index.ts

@@ -1,91 +0,0 @@
-/**
- * world2d — the PixiJS 2D render surface for vgai.
- *
- * A peer to the Three.js world3d surface and the React UI surface (ARCHITECTURE.md
- * §Render Surfaces). It LITERALLY reuses the engine's loop primitives (`createGameLoop`,
- * `createSystemRunner`, `PHASE_ORDER`) and faithfully MIRRORS the entity / authored-data
- * model as a 2D twin (`Scene2D`), instantiating entities as PixiJS display objects
- * instead of Object3Ds, with 2D physics/collision via native Rapier 2D — built on
- * native libraries with thin adapters. Gameplay behavior attaches via the SAME
- * `GameComponent<'pixijs'>` (`ecs/game-component.ts`) and unified `ComponentManager`
- * (`ecs/component-manager.ts`) every threejs world uses (T7.3).
- *
- * See docs/PIXI-WORLD2D-MAXIMAL-SPEC.json (FROZEN).
- */
-
-export {
-  applyEntity2DAssetRename,
-  applyScene2DAssetRename,
-  collectEntity2DAssetPaths,
-} from './asset-paths2d';
-export {
-  AuthoringAdapter2D,
-  type EditorNode2D,
-  type Overlay2D,
-  type Override2D,
-  type Property2D,
-  type Transform2DValue,
-} from './authoring-2d';
-export { captureToScene2D } from './capture-to-scene2d';
-export {
-  type Collision2DSystem,
-  createCollision2DSystem,
-  createTriggerDispatch2D,
-} from './collision-2d';
-export { instantiateEntity2DAsset, parseEntity2DAsset } from './entity2d-asset';
-export {
-  type EmbedMount2D,
-  type IframeReachableMount2D,
-  mountIngestGame2DEmbed,
-  mountIngestGame2DIframeReachable,
-} from './ingest-iframe-2d';
-export { type IngestGame2D, type IngestMount2D, mountIngestGame2D } from './ingest2d';
-export {
-  createPhysics2DRegistry,
-  type Physics2DRefs,
-  type Physics2DRegistry,
-} from './physics2d-registry';
-export {
-  assertMovingPhysicsParent2D,
-  computePhysicsPose2D,
-  type PhysicsPose2D,
-  relativeTransform2D,
-  type ScaledCollider2D,
-  scaleCollider2D,
-} from './physics2d-transform';
-export {
-  DEFAULT_WORLD2D_GRAVITY_METERS_PER_SECOND_SQUARED,
-  DEFAULT_WORLD2D_PIXELS_PER_METER,
-  defaultWorld2DGravityY,
-} from './physics2d-units';
-export {
-  createWorld2DRuntime,
-  type MountedGame2D,
-  type PixiSceneConfig,
-  PixiSceneGameAdapter,
-  type World2DHost,
-  type World2DSession,
-  type World2DSetupFn,
-} from './pixi-game-adapter';
-export { createPixiSurface, type PixiSurface, type PixiSurfaceOptions } from './pixi-surface';
-export {
-  type CapturedRuntime2D,
-  installSceneCapture2D,
-  type SceneCapture2DHandle,
-} from './scene-capture-2d';
-export { materializeScene2DEntityIds, resolveScene2DEntityIds } from './scene2d-identity';
-export {
-  applySceneEntityTransform2D,
-  captureSceneSpriteBaseScale2D,
-  getSceneTilemapTextures2D,
-  loadScene2DFromData,
-  type Scene2DInstance,
-} from './scene2d-loader';
-export * from './schema/entity2d';
-export * from './schema/physics2d';
-export * from './schema/sprite';
-export * from './schema/tilemap';
-export * from './schema/tuples2d';
-export { createPhysicsAdapter2D, type PhysicsAdapter2D } from './system-adapters-2d';
-export { createTransformWriter2D } from './transform-writer-2d';
-export type { Component2DRegistry, World2DContext } from './types';