@vgai/engine 0.4.1 → 0.5.0-canary.20260719.0

package/schemas/vscn.schema.json

@@ -1109,19 +1109,20 @@
                     "plane",
                     "cylinder",
                     "capsule",
-                    "gltf"
+                    "gltf",
+                    "splat"
                   ],
-                  "description": "Mesh primitive type, or \"gltf\" for an external 3D model"
+                  "description": "Renderable type: a built-in mesh primitive, \"gltf\" for an external 3D model, or \"splat\" for a native Gaussian-splat asset"
                 },
                 "args": {
-                  "description": "Geometry constructor args — box: [w,h,d], sphere: [radius], cylinder: [rTop,rBot,h], capsule: [radius,length], plane: [w,h]",
+                  "description": "Geometry constructor args — box: [w,h,d], sphere: [radius], cylinder: [rTop,rBot,h], capsule: [radius,length], plane: [w,h,widthSegments,heightSegments]",
                   "type": "array",
                   "items": {
                     "type": "number"
                   }
                 },
                 "src": {
-                  "description": "Path to GLTF/GLB model file. Required when type is \"gltf\"",
+                  "description": "Path to the external render asset. Required for \"gltf\" (GLTF/GLB) and \"splat\" (SPZ)",
                   "type": "string"
                 },
                 "node": {
@@ -1132,56 +1133,8 @@
                   "description": "Path to an instance-transform asset (.instances.json: an array of [posX,posY,posZ, quatX,quatY,quatZ,quatW, scaleX,scaleY,scaleZ] tuples). Renders one THREE.InstancedMesh (one draw call). Bulk transform data is referenced as an asset, never inlined — keeps vscn thin.",
                   "type": "string"
                 },
-                "instancer": {
-                  "description": "Registered instancer name. When set, the mesh renders as a single THREE.InstancedMesh (one draw call) with code-generated per-instance transforms instead of one THREE.Mesh",
-                  "type": "string"
-                },
-                "instancerParams": {
-                  "description": "Params for the instancer (e.g. count, spacing), keyed by name",
-                  "type": "object",
-                  "propertyNames": {
-                    "type": "string"
-                  },
-                  "additionalProperties": {
-                    "anyOf": [
-                      {
-                        "type": "number"
-                      },
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "boolean"
-                      }
-                    ]
-                  }
-                },
-                "generator": {
-                  "description": "Registered geometry-generator name (e.g. \"Terrain\"). When set, the mesh geometry is produced procedurally in code instead of from `type`/`args`. Pairs with a \"trimesh\" collider for matching physics.",
-                  "type": "string"
-                },
-                "generatorParams": {
-                  "description": "Params for the geometry generator (e.g. width, segments, amplitude)",
-                  "type": "object",
-                  "propertyNames": {
-                    "type": "string"
-                  },
-                  "additionalProperties": {
-                    "anyOf": [
-                      {
-                        "type": "number"
-                      },
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "boolean"
-                      }
-                    ]
-                  }
-                },
                 "lod": {
-                  "description": "Per-entity Level-of-Detail: distance-keyed glTF sub-nodes swapped by camera distance (THREE.LOD). gltf-only. Gated by the environment.rendering.lod master toggle — when off, only the closest level renders. Cannot combine with node/instances/instancer.",
+                  "description": "Per-entity Level-of-Detail: distance-keyed glTF sub-nodes swapped by camera distance (THREE.LOD). gltf-only. Gated by the environment.rendering.lod master toggle — when off, only the closest level renders. Cannot combine with node/instances.",
                   "type": "array",
                   "items": {
                     "type": "object",
@@ -1218,40 +1171,9 @@
                     "standard",
                     "physical",
                     "basic",
-                    "toon",
-                    "custom"
+                    "toon"
                   ],
-                  "description": "Material shading model. \"custom\" resolves `def` against the material registry"
-                },
-                "def": {
-                  "description": "Registered custom-material name (required when type is \"custom\")",
-                  "type": "string"
-                },
-                "uniforms": {
-                  "description": "Authored uniform values for a custom material, keyed by uniform name",
-                  "type": "object",
-                  "propertyNames": {
-                    "type": "string"
-                  },
-                  "additionalProperties": {
-                    "anyOf": [
-                      {
-                        "type": "number"
-                      },
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "boolean"
-                      },
-                      {
-                        "type": "array",
-                        "items": {
-                          "type": "number"
-                        }
-                      }
-                    ]
-                  }
+                  "description": "Material shading model"
                 },
                 "color": {
                   "description": "Base color as CSS hex string (e.g. \"#ff0000\")",
@@ -6181,19 +6103,20 @@
                     "plane",
                     "cylinder",
                     "capsule",
-                    "gltf"
+                    "gltf",
+                    "splat"
                   ],
-                  "description": "Mesh primitive type, or \"gltf\" for an external 3D model"
+                  "description": "Renderable type: a built-in mesh primitive, \"gltf\" for an external 3D model, or \"splat\" for a native Gaussian-splat asset"
                 },
                 "args": {
-                  "description": "Geometry constructor args — box: [w,h,d], sphere: [radius], cylinder: [rTop,rBot,h], capsule: [radius,length], plane: [w,h]",
+                  "description": "Geometry constructor args — box: [w,h,d], sphere: [radius], cylinder: [rTop,rBot,h], capsule: [radius,length], plane: [w,h,widthSegments,heightSegments]",
                   "type": "array",
                   "items": {
                     "type": "number"
                   }
                 },
                 "src": {
-                  "description": "Path to GLTF/GLB model file. Required when type is \"gltf\"",
+                  "description": "Path to the external render asset. Required for \"gltf\" (GLTF/GLB) and \"splat\" (SPZ)",
                   "type": "string"
                 },
                 "node": {
@@ -6204,56 +6127,8 @@
                   "description": "Path to an instance-transform asset (.instances.json: an array of [posX,posY,posZ, quatX,quatY,quatZ,quatW, scaleX,scaleY,scaleZ] tuples). Renders one THREE.InstancedMesh (one draw call). Bulk transform data is referenced as an asset, never inlined — keeps vscn thin.",
                   "type": "string"
                 },
-                "instancer": {
-                  "description": "Registered instancer name. When set, the mesh renders as a single THREE.InstancedMesh (one draw call) with code-generated per-instance transforms instead of one THREE.Mesh",
-                  "type": "string"
-                },
-                "instancerParams": {
-                  "description": "Params for the instancer (e.g. count, spacing), keyed by name",
-                  "type": "object",
-                  "propertyNames": {
-                    "type": "string"
-                  },
-                  "additionalProperties": {
-                    "anyOf": [
-                      {
-                        "type": "number"
-                      },
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "boolean"
-                      }
-                    ]
-                  }
-                },
-                "generator": {
-                  "description": "Registered geometry-generator name (e.g. \"Terrain\"). When set, the mesh geometry is produced procedurally in code instead of from `type`/`args`. Pairs with a \"trimesh\" collider for matching physics.",
-                  "type": "string"
-                },
-                "generatorParams": {
-                  "description": "Params for the geometry generator (e.g. width, segments, amplitude)",
-                  "type": "object",
-                  "propertyNames": {
-                    "type": "string"
-                  },
-                  "additionalProperties": {
-                    "anyOf": [
-                      {
-                        "type": "number"
-                      },
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "boolean"
-                      }
-                    ]
-                  }
-                },
                 "lod": {
-                  "description": "Per-entity Level-of-Detail: distance-keyed glTF sub-nodes swapped by camera distance (THREE.LOD). gltf-only. Gated by the environment.rendering.lod master toggle — when off, only the closest level renders. Cannot combine with node/instances/instancer.",
+                  "description": "Per-entity Level-of-Detail: distance-keyed glTF sub-nodes swapped by camera distance (THREE.LOD). gltf-only. Gated by the environment.rendering.lod master toggle — when off, only the closest level renders. Cannot combine with node/instances.",
                   "type": "array",
                   "items": {
                     "type": "object",
@@ -6287,40 +6162,9 @@
                     "standard",
                     "physical",
                     "basic",
-                    "toon",
-                    "custom"
+                    "toon"
                   ],
-                  "description": "Material shading model. \"custom\" resolves `def` against the material registry"
-                },
-                "def": {
-                  "description": "Registered custom-material name (required when type is \"custom\")",
-                  "type": "string"
-                },
-                "uniforms": {
-                  "description": "Authored uniform values for a custom material, keyed by uniform name",
-                  "type": "object",
-                  "propertyNames": {
-                    "type": "string"
-                  },
-                  "additionalProperties": {
-                    "anyOf": [
-                      {
-                        "type": "number"
-                      },
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "boolean"
-                      },
-                      {
-                        "type": "array",
-                        "items": {
-                          "type": "number"
-                        }
-                      }
-                    ]
-                  }
+                  "description": "Material shading model"
                 },
                 "color": {
                   "description": "Base color as CSS hex string (e.g. \"#ff0000\")",

package/src/adapter/authoring.ts

@@ -156,6 +156,8 @@ export interface SelectionProvider {
 }
 
 export interface TransformProvider {
+  /** Honest inspector presentation for the substrate's transform vocabulary. */
+  dimensions?(id: string): '2d' | '3d' | null;
   get(id: string): Transform;
   owner(id: string): TransformOwner;
   /** Pause whatever controller fights the gizmo (physics/script) for editing. */
@@ -355,7 +357,22 @@ export interface ComponentsProvider {
 /** Asset drop (hierarchy + viewport). */
 export interface AssetDropProvider {
   accepts(nodeId: string, assetPath: string): boolean;
-  drop(nodeId: string, assetPath: string): void;
+  drop(nodeId: string, assetPath: string): void | Promise<void>;
+}
+
+/** One adapter-owned reusable-entity format the shared hierarchy can save.
+ * The adapter owns the bytes and semantics; the shell owns only the filename
+ * dialog. This keeps native 2D entity assets out of Three prefab code while
+ * preserving one editor language for the operation. */
+export interface EntityAssetSaveDescriptor {
+  defaultFolder: string;
+  extension: string;
+  label: string;
+}
+
+export interface EntityAssetProvider {
+  describeSave(nodeId: string): EntityAssetSaveDescriptor | null;
+  save(nodeId: string, path: string): Promise<boolean>;
 }
 
 /** Plain-object rect shape shared by {@link RectProvider} — the same fields a real
@@ -395,13 +412,138 @@ export interface RectProvider {
   emptyContainers?(): { id: string; rect: DOMRectLike; displayName: string }[];
 }
 
+/** One adapter-owned reference point rendered by the shared world overlay.
+ * Coordinates are host-relative px, the same frame as {@link RectProvider}.
+ * A provider deliberately exposes at most one point for a node so coincident
+ * native concepts (for example an anchor and pivot) never become ambiguous. */
+export interface BoxEditReferencePoint {
+  /** True when the native source constrains this point (for example a
+   * normalized 0..1 Sprite anchor). The overlay then uses only exact native
+   * snap points, never an unreachable axis-aligned bounding-box target. */
+  bounded?: boolean;
+  id: string;
+  kind: 'anchor' | 'pivot';
+  label: string;
+  /** Exact host-space points the native reference can reach and should snap
+   * to. Useful for transformed corner/edge/center grids on rotated content. */
+  snapPoints?: ReadonlyArray<{ x: number; y: number }>;
+  x: number;
+  y: number;
+}
+
 /** Spatial gesture → source/data write, for non-Object3D (DOM) nodes. Distinct from the
  *  3D TransformProvider. begin/apply/end bracket a single undo step; apply is live-preview. */
 export interface BoxEditProvider {
   begin(id: string): void;
-  /** patch: any of x,y,width,height,marginTop… paddingLeft… — px deltas or absolutes */
+  /** patch: any of x,y,width,height,marginTop… paddingLeft… — px deltas or absolutes.
+   * `referenceX`/`referenceY` are the absolute host-relative coordinates of
+   * the active {@link referencePoint}; only providers exposing that optional
+   * capability receive those keys. The provider owns conversion to native
+   * source units and any placement-preserving compensation. */
   apply(id: string, patch: Record<string, number>): void;
   end(id: string): void;
+  /** Optional single native anchor/pivot affordance for this node. */
+  referencePoint?(id: string): BoxEditReferencePoint | null;
+}
+
+export interface TilemapCell {
+  column: number;
+  row: number;
+}
+
+/** One bounded native tile grid projected into the shared world overlay.
+ * Geometry is affine and host-relative: `origin` is local cell corner [0,0],
+ * while `columnStep`/`rowStep` are the transformed one-cell basis vectors.
+ * This compact shape represents nested rotation, non-uniform scale, reflection,
+ * and zoom without fabricating axis-aligned cell polygons. */
+export interface TilemapEditGrid {
+  columns: number;
+  columnStep: { x: number; y: number };
+  origin: { x: number; y: number };
+  palette: ReadonlyArray<{ frame: string; index: number }>;
+  rows: number;
+  rowStep: { x: number; y: number };
+}
+
+/** Native tile-cell authoring. Palette selection is editor-session state;
+ * source truth receives only atlas-frame indices, with -1 meaning an empty cell.
+ * begin/apply/end bracket one exact project-history transaction. */
+export interface TilemapEditProvider {
+  apply(id: string, cell: TilemapCell): void;
+  begin(id: string, tileIndex: number): void;
+  /** Resolve a host-relative pointer through the adapter's native transform. */
+  cellAt(id: string, point: { x: number; y: number }): TilemapCell | null;
+  end(id: string): void;
+  grid(id: string): TilemapEditGrid | null;
+  /** Load the native Pixi atlas used to render palette thumbnails. */
+  loadTileset(id: string): Promise<SpriteAtlas2D>;
+}
+
+export type PhysicsShape2DHandle = 'half-height' | 'half-width' | 'radius';
+
+/** One native 2D physics shape projected into host-relative viewport pixels.
+ * `origin` is collider-local [0,0]; `xAxis`/`yAxis` are the transformed
+ * one-pixel basis vectors. Keeping the complete affine basis preserves nested
+ * rotation, non-uniform scale, reflection, centered canvas placement, and
+ * viewport zoom without teaching the shared shell about Pixi or Rapier. */
+export interface PhysicsShape2DProjection {
+  collider:
+    | { shape: 'cuboid'; halfExtents: readonly [number, number] }
+    | { shape: 'ball'; radius: number }
+    | { shape: 'capsule'; halfHeight: number; radius: number };
+  editable: boolean;
+  id: string;
+  origin: { x: number; y: number };
+  sensor: boolean;
+  xAxis: { x: number; y: number };
+  yAxis: { x: number; y: number };
+}
+
+/** Adapter-owned native collider inspection and spatial editing. Shapes are
+ * readable independently of editability so locked/read-only source remains
+ * inspectable. begin/apply/end bracket one exact project-history transaction. */
+export interface PhysicsShape2DProvider {
+  apply(id: string, handle: PhysicsShape2DHandle, point: { x: number; y: number }): void;
+  begin(id: string, handle: PhysicsShape2DHandle): void;
+  end(id: string): void;
+  shapes(): readonly PhysicsShape2DProjection[];
+}
+
+/** One named sub-texture in a Pixi-compatible spritesheet atlas. `x`/`y` are
+ * source-image pixels; width/height are the runtime-facing dimensions Pixi
+ * swaps when `rotated` reports packed 90-degree storage. */
+export interface SpriteAtlasFrame2D {
+  height: number;
+  name: string;
+  rotated: boolean;
+  width: number;
+  x: number;
+  y: number;
+}
+
+export interface SpriteAtlas2D {
+  atlasPath: string;
+  frames: readonly SpriteAtlasFrame2D[];
+  /** Project-relative image source named by the atlas. */
+  imagePath: string;
+  /** Image bytes loaded through the owning adapter's storage backend. */
+  imageBytes: Uint8Array;
+  imageMediaType: string;
+}
+
+export interface SpriteFrames2DDescriptor {
+  atlasPath: string;
+  editable: boolean;
+  selectedFrame: string | null;
+}
+
+/** Source-backed Pixi spritesheet discovery and frame selection. Atlas parsing
+ * remains adapter-owned; the universal Inspector only renders this projection.
+ * `select` writes source truth and creates one project-history transaction. */
+export interface SpriteFrames2DProvider {
+  describe(id: string): SpriteFrames2DDescriptor | null;
+  load(id: string): Promise<SpriteAtlas2D>;
+  select(id: string, frame: string | null): void;
 }
 
 /** Text-content editing — currently OFF-contract (the react adapter has an `editText(id)`
@@ -458,6 +600,12 @@ export interface AuthoringAdapter {
   /** T0 (spec 27 §2) — spatial drag-resize/move → source/data write for non-Object3D
    *  (DOM) nodes. Absent ⇒ no box-edit gesture for this adapter. */
   readonly boxEdit?: BoxEditProvider;
+  /** Native 2D physics debug geometry and shape handles. */
+  readonly physicsShapes2D?: PhysicsShape2DProvider;
+  /** Native Pixi spritesheet frame discovery/selection. */
+  readonly spriteFrames2D?: SpriteFrames2DProvider;
+  /** Native bounded tile-cell painting. Absent means no viewport tile editor. */
+  readonly tilemapEdit?: TilemapEditProvider;
   /** T0 (spec 27 §2) — double-click-to-edit-text on the contract (wires the react
    *  adapter's existing off-contract `editText`). Absent ⇒ no in-place text edit. */
   readonly text?: TextProvider;
@@ -470,6 +618,8 @@ export interface AuthoringAdapter {
   readonly components?: ComponentsProvider;
   /** Asset drop (hierarchy + viewport). Absent ⇒ this adapter accepts no drops. */
   readonly assetDrop?: AssetDropProvider;
+  /** Save a native entity subtree as an adapter-owned reusable asset. */
+  readonly entityAssets?: EntityAssetProvider;
   /** Undo/redo for this adapter's edits (first-party delegates to the store; an
    *  ingest adapter keeps its own overlay-backed stack). Absent ⇒ host falls back. */
   undo?(): void;

package/src/adapter/colyseus-networking-adapter.ts

@@ -16,7 +16,10 @@
 import type * as THREE from 'three';
 import type {
   ConnectionState,
+  NetConditioning,
+  NetMessageEvent,
   NetPeer,
+  NetRates,
   NetworkingAdapter,
   ReplicationStats,
   RoomInfo,
@@ -47,10 +50,25 @@ export interface ColyseusNetworkingConfig {
   /** Subscribe to changes in connection state / room / replication stats.
    *  Optional — defaults to a no-op subscription. */
   subscribe?(cb: () => void): Unsubscribe;
+  /** Optional CAPABILITY: plain-data replicated-state snapshot (Colyseus
+   *  `state.toJSON()`), for the inspector's state tree (W3b). Unlike the
+   *  defaulted accessors above, this and the remaining optional accessors
+   *  propagate their ABSENCE to the built adapter — a config that omits one
+   *  yields an adapter without that method, so the inspector marks the
+   *  section absent instead of rendering fabricated empties. */
+  stateSnapshot?(): unknown;
+  /** Optional capability: message-log events with `seq > sinceSeq`. */
+  messageEvents?(sinceSeq?: number): NetMessageEvent[];
+  /** Optional capability: msg + byte rates for the inspector sparklines. */
+  rates?(): NetRates;
+  /** Optional capability pair: link conditioning at the adapter seam. Both
+   *  must be supplied together for the inspector to show the controls. */
+  getConditioning?(): NetConditioning;
+  setConditioning?(c: NetConditioning): void;
 }
 
 export function createColyseusNetworkingAdapter(cfg: ColyseusNetworkingConfig): NetworkingAdapter {
-  return {
+  const adapter: NetworkingAdapter = {
     peers: () => cfg.peers(),
     networkId: (o) => cfg.networkId(o),
     authority: (o) => {
@@ -69,4 +87,20 @@ export function createColyseusNetworkingAdapter(cfg: ColyseusNetworkingConfig):
       cfg.replicationStats?.() ?? { entities: 0, msgsInPerSec: 0, msgsOutPerSec: 0 },
     subscribe: (cb) => cfg.subscribe?.(cb) ?? (() => {}),
   };
+  // The W3b inspector capabilities attach ONLY when supplied: their absence
+  // is the editor's degradation signal (`getStateSnapshot` in adapter ⇒ tree,
+  // missing ⇒ "not provided by this adapter" — never a fabricated empty).
+  const stateSnapshot = cfg.stateSnapshot?.bind(cfg);
+  if (stateSnapshot) adapter.getStateSnapshot = () => stateSnapshot();
+  const messageEvents = cfg.messageEvents?.bind(cfg);
+  if (messageEvents) adapter.messageEvents = (sinceSeq) => messageEvents(sinceSeq);
+  const rates = cfg.rates?.bind(cfg);
+  if (rates) adapter.getRates = () => rates();
+  const getConditioning = cfg.getConditioning?.bind(cfg);
+  const setConditioning = cfg.setConditioning?.bind(cfg);
+  if (getConditioning && setConditioning) {
+    adapter.getConditioning = () => getConditioning();
+    adapter.setConditioning = (c) => setConditioning(c);
+  }
+  return adapter;
 }

package/src/adapter/first-party-systems.ts

@@ -68,6 +68,7 @@ export function createAudioSystemAdapter(audio: GameAudio): AudioAdapter {
   let muted = false;
   let priorGain = audio.masterGain.gain.value;
   return {
+    resume: () => audio.resume(),
     setMuted(next: boolean) {
       if (next === muted) return;
       muted = next;
@@ -82,11 +83,16 @@ export function createAudioSystemAdapter(audio: GameAudio): AudioAdapter {
   };
 }
 
-/** First-party `NavigationAdapter` over the engine `NavMeshManager`. */
+/** First-party `NavigationAdapter` over the engine `NavMeshManager` — the
+ *  blessed recast implementation, including the optional bake/export/crowd
+ *  capabilities the editor's Navigation panel binds through. */
 export function createNavigationAdapter(nav: NavMeshManager): NavigationAdapter {
   return {
     hasNavMesh: () => nav.hasNavMesh(),
     findPath: (start: NavPoint, end: NavPoint) => nav.findPath(start, end) as NavPoint[],
     debugMesh: (scene: THREE.Scene) => nav.getDebugMesh(scene) as unknown as THREE.Object3D | null,
+    bake: (meshes, params) => nav.buildFromMeshes(meshes, params),
+    exportData: () => nav.exportData(),
+    crowdAgents: () => nav.getCrowdAgents(),
   };
 }

package/src/adapter/game-adapter.ts

@@ -10,6 +10,7 @@
 
 import type { Container } from 'pixi.js';
 import type * as THREE from 'three';
+import type { ComponentManager } from '../ecs/component-manager';
 import type { AdapterSurface } from './adapter-surface';
 import type { AuthoringAdapter } from './authoring';
 import type { HostContext } from './host-context';
@@ -80,6 +81,18 @@ export interface MountedWorldBase {
   /** Optional capability providers — absence = "not supported", host degrades. */
   readonly authoring?: AuthoringAdapter;
   readonly systems?: SystemAdapters;
+  /**
+   * Optional component-query capability: an adapter that runs the engine's
+   * REAL `ComponentManager` without being the classic first-party mount
+   * (e.g. `@engine/world3d-react`'s R3F adapter — `<Behavior>` attaches
+   * through a real manager) exposes it here so `Game.queryByComponent`
+   * (`runtime/game.ts`) aggregates this world's instances and
+   * `registerThreeWorld` (`runtime/create-runtime.ts`) backfills
+   * `instance.world` at registration, exactly like a first-party world.
+   * Absent for a genuinely foreign mount that hosts no GameComponents —
+   * such a world legitimately answers "no components".
+   */
+  readonly components?: ComponentManager;
   /** Optional state-observation capability (T7.4 slice 2, §4) — absent means
    *  "no state bridge"; `Game.registerWorld` reports this loudly, once, for
    *  any non-first-party mount. First-party mounts are exempt — their state

package/src/adapter/index.ts

@@ -17,26 +17,39 @@ export type {
   AuthoringCapabilities,
   AuthoringProvenance,
   BoxEditProvider,
+  BoxEditReferencePoint,
   ColorSampleProvider,
   ComponentsProvider,
   DOMRectLike,
   EditorNode,
   EditorNodeRole,
+  EntityAssetProvider,
+  EntityAssetSaveDescriptor,
   FileMapProvider,
   HierarchyProvider,
   InspectorProvider,
   LayoutProvider,
   PersistenceProvider,
+  PhysicsShape2DHandle,
+  PhysicsShape2DProjection,
+  PhysicsShape2DProvider,
   PickProvider,
   PropertyDescriptor,
   RectProvider,
   RootGroup,
   RootGroupsProvider,
   SelectionProvider,
+  SpriteAtlas2D,
+  SpriteAtlasFrame2D,
+  SpriteFrames2DDescriptor,
+  SpriteFrames2DProvider,
   StoriesProvider,
   StoryRef,
   StructureProvider,
   TextProvider,
+  TilemapCell,
+  TilemapEditGrid,
+  TilemapEditProvider,
   TransformProvider,
 } from './authoring';
 export {
@@ -64,13 +77,25 @@ export { createRapierPhysicsAdapter } from './rapier-physics-adapter';
 export type {
   ActionValueSnapshot,
   AssetAdapter,
+  AudioAdapter,
+  AudioDebugEvent,
+  AudioGraphNode,
+  AudioMeterFrame,
+  AudioMeterHandle,
+  AudioTransportState,
   ConnectionState,
   InputAdapter,
+  NavBakeParams,
+  NavCrowdAgentState,
   NavigationAdapter,
   NavPoint,
+  NetConditioning,
+  NetMessageEvent,
   NetPeer,
+  NetRates,
   NetworkingAdapter,
   PhysicsAdapter,
+  RenderDebugAdapter,
   ReplicationStats,
   RoomInfo,
   SystemAdapters,