@crowdedkingdoms/construct 0.3.7 → 0.3.8

package/src/platform/studio/clientModHost.test.ts

@@ -7,7 +7,9 @@ const {
   bytesToBase64,
   parseVoxelSetArgs,
   routeClientHostCall,
+  voxelStateToWire,
   voxelsFromBase64,
+  voxelsListRows,
 } = await import('./clientModHost');
 
 const grid = { low: { x: -1n, y: 0n, z: -1n }, high: { x: 1n, y: 0n, z: 1n } };
@@ -33,7 +35,7 @@ function sampleGrid(): Uint8Array {
 }
 
 describe('routeClientHostCall', () => {
-  it('offers world_read plus voxel_set and pointer_clicks', () => {
+  it('offers world_read, scene catalog, and chunk gameplay', () => {
     expect([...OFFERED_HOST_CALLS]).toEqual([
       'actors_list',
       'actors_list_radius',
@@ -41,6 +43,28 @@ describe('routeClientHostCall', () => {
       'voxels_list',
       'voxel_set',
       'pointer_clicks',
+      'input_axes',
+      'input_look',
+      'input_key',
+      'events_poll',
+      'voice_set',
+      'video_set',
+      'send_client_event',
+      'send_text',
+      'send_actor_message',
+      'send_channel_message',
+      'pose_get',
+      'pose_set',
+      'pose_release',
+      'actor_spawn',
+      'actor_pose',
+      'actor_despawn',
+      'avatar_appearance',
+      'avatar_state_set',
+      'teleport_request',
+      'scene_catalog',
+      'scene_instances',
+      'clock',
     ]);
   });
 
@@ -66,7 +90,7 @@ describe('routeClientHostCall', () => {
     expect(r.calls.every((c) => c.split(',').every((v) => Math.abs(Number(v)) <= 1))).toBe(true);
   });
 
-  it('reads crowdy-client-sdk radii and clamps them as the platform does (3 across, 1 up)', async () => {
+  it('reads crowdy-client-sdk radii and keeps a claim-wide scan inside the grid', async () => {
     const r = reads();
     const wide = { low: { x: -9n, y: -9n, z: -9n }, high: { x: 9n, y: 9n, z: 9n } };
     await routeClientHostCall(
@@ -77,10 +101,11 @@ describe('routeClientHostCall', () => {
       r.reads,
       wide,
     );
-    expect(r.calls.length).toBe(7 * 3 * 7);
+    // radiusXz 9 covers the grid (±9). Vertical radius stays 1.
+    expect(r.calls.length).toBe(19 * 3 * 19);
     const ys = new Set(r.calls.map((c) => Number(c.split(',')[1])));
     expect([...ys].sort()).toEqual([-1, 0, 1]);
-    expect(r.calls.every((c) => Math.abs(Number(c.split(',')[0])) <= 3)).toBe(true);
+    expect(r.calls.every((c) => Math.abs(Number(c.split(',')[0])) <= 9)).toBe(true);
   });
 
   it('serves chunk_get as base64 and voxels_list as sparse rows', async () => {
@@ -185,6 +210,28 @@ describe('routeClientHostCall', () => {
     ]);
   });
 
+  it('parses the SDK voxel_set shape (voxelX/stateBase64)', () => {
+    expect(
+      parseVoxelSetArgs({
+        chunkX: -1,
+        chunkY: 0,
+        chunkZ: -1,
+        voxelX: 4,
+        voxelY: 15,
+        voxelZ: 15,
+        voxelType: 1,
+        stateBase64: '{"u":"abc","shot":1}',
+      }),
+    ).toEqual({
+      chunk: { x: -1, y: 0, z: -1 },
+      x: 4,
+      y: 15,
+      z: 15,
+      voxelType: 1,
+      state: '{"u":"abc","shot":1}',
+    });
+  });
+
   it('writes no voxel outside the grid, whatever second chunk the call carries', async () => {
     const r = reads();
     const written: Array<{ chunk: { x: number; y: number; z: number } }> = [];
@@ -255,6 +302,112 @@ describe('routeClientHostCall', () => {
     });
   });
 
+  it('refuses a pose outside the grid and returns input axes', async () => {
+    const { bindModGrid, bindModInput, releaseModChunk } = await import('./modChunkRuntime');
+    bindModGrid(grid);
+    bindModInput({ axes: () => ({ x: 1, y: 0 }) } as never);
+    const { bindModSession } = await import('./modChunkRuntime');
+    bindModSession({
+      client: {
+        udp: { sendClientEvent: async () => true },
+        kit: () => ({ inventory: {} }),
+      } as never,
+      appId: '1',
+      gridId: '1',
+      selfUuid: 'self',
+      userId: '1',
+      moveTo: async () => undefined,
+      players: () => [{ uuid: 'self', pose: { x: 0, y: 0, z: 0 } }],
+      voiceStart: async () => undefined,
+      voiceStop: () => undefined,
+      videoStart: async () => undefined,
+      videoStop: () => undefined,
+    });
+    const outside = await routeClientHostCall(
+      { fn: 'pose_set', args: { x: 1000, y: 0, z: 0 } } as never,
+      reads().reads,
+      grid,
+    );
+    expect(outside).toEqual({ ok: false, error: 'outside the player grid' });
+    const axes = await routeClientHostCall(
+      { fn: 'input_axes', args: {} } as never,
+      reads().reads,
+      grid,
+    );
+    expect(axes).toEqual({ x: 1, y: 0 });
+    const other = await routeClientHostCall(
+      { fn: 'actor_spawn', args: { uuid: 'self', x: 0, y: 0, z: 0 } } as never,
+      reads().reads,
+      grid,
+    );
+    expect(other).toEqual({ ok: false, error: 'refusing a live player uuid' });
+    const kit = await routeClientHostCall(
+      {
+        fn: 'inventory_transfer',
+        args: { targetUuid: 'bob', fromStackId: 'a', toStackId: 'b' },
+      } as never,
+      reads().reads,
+      grid,
+    );
+    expect(kit).toEqual({ ok: false, error: 'target is outside the grid' });
+    const far = await routeClientHostCall(
+      {
+        fn: 'teleport_request',
+        args: { destChunkX: 9, destChunkY: 0, destChunkZ: 0, uuid: 'self' },
+      } as never,
+      reads().reads,
+      grid,
+    );
+    expect(far).toEqual({ ok: false, error: 'outside the player grid' });
+    const { modProjectiles } = await import('./modChunkRuntime');
+    await routeClientHostCall(
+      {
+        fn: 'send_client_event',
+        args: {
+          x: 0,
+          y: 0,
+          z: 0,
+          payloadBase64: btoa(
+            JSON.stringify({
+              kind: 'projectile',
+              origin: { x: 1, y: 1.7, z: 2 },
+              direction: { x: 0, y: 0, z: -1 },
+              speed: 40,
+              startMs: 0,
+              lifeMs: 1000,
+            }),
+          ),
+        },
+      } as never,
+      reads().reads,
+      grid,
+    );
+    expect(modProjectiles(0)).toHaveLength(1);
+    releaseModChunk();
+    await routeClientHostCall(
+      {
+        fn: 'send_client_event',
+        args: {
+          chunkX: -2,
+          chunkY: 0,
+          chunkZ: -1,
+          payload: {
+            kind: 'projectile',
+            origin: { x: 4, y: 1.7, z: 5 },
+            direction: { x: 1, y: 0, z: 0 },
+            speed: 1320,
+            lifeMs: 1800,
+          },
+        },
+      } as never,
+      reads().reads,
+      grid,
+    );
+    expect(modProjectiles(0)).toHaveLength(1);
+    releaseModChunk();
+    bindModInput(null);
+  });
+
   it('parses the voxel_set arguments crowdy-client-sdk sends', () => {
     expect(
       parseVoxelSetArgs({
@@ -281,4 +434,51 @@ describe('routeClientHostCall', () => {
     expect(voxelsFromBase64(null)).toEqual([]);
     expect(voxelsFromBase64(bytesToBase64(new Uint8Array(4096)))).toEqual([]);
   });
+
+  it('attaches sparse voxel state onto voxels_list rows', () => {
+    const packed = new Uint8Array(4096);
+    packed[2 + 15 * 16 + 0 * 256] = 1;
+    const json = '{"players":[{"uuid":"fake1","name":"Alice"}]}';
+    expect(voxelStateToWire(json)).toBe(bytesToBase64(new TextEncoder().encode(json)));
+    expect(voxelStateToWire('AA==')).toBe('AA==');
+    expect(voxelsListRows(bytesToBase64(packed), [{ x: 2, y: 15, z: 0, state: json }])).toEqual([
+      { x: 2, y: 15, z: 0, voxelType: 1, state: json },
+    ]);
+  });
+
+  it('stores a scene catalog for the running module', async () => {
+    const { ModSceneStore } = await import('./modScene');
+    const store = new ModSceneStore();
+    const target = { source: 'mod', store };
+    const catalog = await routeClientHostCall(
+      { fn: 'scene_catalog', args: { v: 1, revision: 3, nodes: [] } } as never,
+      reads().reads,
+      grid,
+      undefined,
+      undefined,
+      target,
+    );
+    expect(catalog).toEqual({ ok: true, revision: 3 });
+    const again = await routeClientHostCall(
+      { fn: 'scene_catalog', args: { v: 1, revision: 3, nodes: [] } } as never,
+      reads().reads,
+      grid,
+      undefined,
+      undefined,
+      target,
+    );
+    expect(again).toEqual({ ok: true, revision: 3, ignored: true });
+    const instances = await routeClientHostCall(
+      {
+        fn: 'scene_instances',
+        args: { instances: [{ id: 'me', template: 'body' }] },
+      } as never,
+      reads().reads,
+      grid,
+      undefined,
+      undefined,
+      target,
+    );
+    expect(instances).toEqual({ ok: true, count: 1 });
+  });
 });

package/src/platform/studio/clientModHost.ts

@@ -5,17 +5,34 @@
  * The SDK's `PlayerCodeBroker` has already validated every call against the
  * platform allowlist, clamped chunk coordinates to the mod's grid AABB, rate-
  * limited it, and answered `grid_info` / `hud_set` / `overlay_draw` itself.
- * What reaches `routeClientHostCall` is world_read, `voxel_set`, and
- * `pointer_clicks`, in the argument shapes `crowdy-client-sdk` sends. Reads
- * return only what the running player can already lawfully see. Writes go
- * through ChunkStore.setVoxel (optimistic + UDP) and markDirty (durable
- * write-back), the same route Paint uses. Never hand a mod the raw client.
+ * What reaches `routeClientHostCall` is world_read, `voxel_set`,
+ * `pointer_clicks`, pose, input, and scene_catalog / scene_instances, in the
+ * argument shapes `crowdy-client-sdk` sends. Reads return only what the
+ * running player can already lawfully see. Writes go through
+ * ChunkStore.setVoxel (optimistic + UDP) and markDirty (durable write-back),
+ * the same route Paint uses. Never hand a mod the raw client.
  */
 import type { PlayerCodeGridBounds, PlayerCodeHostCall } from '@crowdedkingdoms/crowdyjs';
+import { routeModGameplay } from './modChunkRuntime';
+import type { ModSceneStore } from './modScene';
+
+export interface ClientVoxelState {
+  x: number;
+  y: number;
+  z: number;
+  state: string;
+}
 
 export interface ClientModHostReads {
   actorsInChunk(x: bigint, y: bigint, z: bigint): Array<Record<string, unknown>>;
-  chunkVoxels(x: bigint, y: bigint, z: bigint): { voxelsBase64: string | null } | null;
+  chunkVoxels(
+    x: bigint,
+    y: bigint,
+    z: bigint,
+  ):
+    | { voxelsBase64: string | null; states?: ClientVoxelState[] }
+    | null
+    | Promise<{ voxelsBase64: string | null; states?: ClientVoxelState[] } | null>;
 }
 
 export interface ClientModHostWrites {
@@ -31,6 +48,9 @@ export interface ClientModHostWrites {
 
 export interface ClientModHostInput {
   drainPointerClicks(): unknown;
+  axes?: () => { x: number; y: number };
+  look?: () => { dx: number; dy: number };
+  keyDown?: (code: string) => boolean;
 }
 
 /** The host calls this game answers. Exported so the docs and tests agree. */
@@ -41,13 +61,35 @@ export const OFFERED_HOST_CALLS = [
   'voxels_list',
   'voxel_set',
   'pointer_clicks',
+  'input_axes',
+  'input_look',
+  'input_key',
+  'events_poll',
+  'voice_set',
+  'video_set',
+  'send_client_event',
+  'send_text',
+  'send_actor_message',
+  'send_channel_message',
+  'pose_get',
+  'pose_set',
+  'pose_release',
+  'actor_spawn',
+  'actor_pose',
+  'actor_despawn',
+  'avatar_appearance',
+  'avatar_state_set',
+  'teleport_request',
+  'scene_catalog',
+  'scene_instances',
+  'clock',
 ] as const;
 
 /** One zero byte, base64: the smallest non-empty voxel state the API accepts. */
 export const DEFAULT_VOXEL_STATE = 'AA==';
 
-/** `actors_list_radius` reaches this far, as the platform clamps it. */
-const MAX_RADIUS_XZ = 3;
+/** `actors_list_radius` reaches this far. The claim arena is wider than the platform default of 3. */
+const MAX_RADIUS_XZ = 32;
 const MAX_RADIUS_Y = 1;
 
 function toBigInt(value: unknown): bigint {
@@ -66,12 +108,18 @@ export class HostCallRefusedError extends Error {
   }
 }
 
+export interface ClientModSceneTarget {
+  source: string;
+  store: ModSceneStore;
+}
+
 export async function routeClientHostCall(
   call: PlayerCodeHostCall,
   reads: ClientModHostReads,
   grid?: PlayerCodeGridBounds,
   writes?: ClientModHostWrites,
   input?: ClientModHostInput,
+  scene?: ClientModSceneTarget,
 ): Promise<unknown> {
   const { fn, args } = call;
   switch (fn) {
@@ -103,11 +151,11 @@ export async function routeClientHostCall(
     }
     case 'chunk_get':
     case 'voxels_list': {
-      const chunk = reads.chunkVoxels(toBigInt(args.x), toBigInt(args.y), toBigInt(args.z));
+      const chunk = await reads.chunkVoxels(toBigInt(args.x), toBigInt(args.y), toBigInt(args.z));
       if (!chunk) return fn === 'chunk_get' ? { voxelsBase64: null } : { voxels: [] };
       return fn === 'chunk_get'
         ? { voxelsBase64: chunk.voxelsBase64 }
-        : { voxels: voxelsFromBase64(chunk.voxelsBase64) };
+        : { voxels: voxelsListRows(chunk.voxelsBase64, chunk.states) };
     }
     case 'voxel_set': {
       if (!writes || !grid) throw new HostCallRefusedError(fn);
@@ -128,8 +176,28 @@ export async function routeClientHostCall(
       if (!input) throw new HostCallRefusedError(fn);
       return input.drainPointerClicks();
     }
-    default:
-      throw new HostCallRefusedError(fn);
+    case 'clock':
+      return { ms: Date.now() };
+    case 'input_key':
+      return { down: input?.keyDown?.(String(args.code ?? '')) ?? false };
+    case 'scene_catalog':
+      if (!scene) return { ok: false };
+      return scene.store.setCatalog(scene.source, args);
+    case 'scene_instances':
+      if (!scene) return { ok: false };
+      return scene.store.setInstances(scene.source, args);
+    default: {
+      const answered = await routeModGameplay(call);
+      if (
+        answered &&
+        typeof answered === 'object' &&
+        'error' in answered &&
+        String((answered as { error: unknown }).error).startsWith('unrouted')
+      ) {
+        throw new HostCallRefusedError(fn);
+      }
+      return answered;
+    }
   }
 }
 
@@ -189,9 +257,9 @@ export function parseVoxelSetArgs(args: Record<string, unknown>): {
   const voxelRaw =
     asCoord3(args.voxel) ??
     ({
-      x: coordField(args, 'voxelX', 'x', 'vx'),
-      y: coordField(args, 'voxelY', 'y', 'vy'),
-      z: coordField(args, 'voxelZ', 'z', 'vz'),
+      x: coordField(args, 'voxelX', 'voxel_x', 'x', 'vx'),
+      y: coordField(args, 'voxelY', 'voxel_y', 'y', 'vy'),
+      z: coordField(args, 'voxelZ', 'voxel_z', 'z', 'vz'),
     } as { x: unknown; y: unknown; z: unknown });
   const cx = intInRange(chunkRaw.x, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
   const cy = intInRange(chunkRaw.y, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
@@ -220,10 +288,10 @@ export function parseVoxelSetArgs(args: Record<string, unknown>): {
 /** Sparse `{x,y,z,voxelType}` rows for the non-zero cells of a dense grid. */
 export function voxelsFromBase64(
   voxelsBase64: string | null,
-): Array<{ x: number; y: number; z: number; voxelType: number }> {
+): Array<{ x: number; y: number; z: number; voxelType: number; state?: string }> {
   if (!voxelsBase64) return [];
   const binary = atob(voxelsBase64);
-  const out: Array<{ x: number; y: number; z: number; voxelType: number }> = [];
+  const out: Array<{ x: number; y: number; z: number; voxelType: number; state?: string }> = [];
   for (let i = 0; i < binary.length && i < 4096; i++) {
     const type = binary.charCodeAt(i);
     if (type === 0) continue;
@@ -232,6 +300,30 @@ export function voxelsFromBase64(
   return out;
 }
 
+/** Dense types plus sparse per-cell state so mailbox voxels can carry JSON. */
+export function voxelsListRows(
+  voxelsBase64: string | null,
+  states?: ClientVoxelState[],
+): Array<{ x: number; y: number; z: number; voxelType: number; state?: string }> {
+  const rows = voxelsFromBase64(voxelsBase64);
+  if (!states?.length) return rows;
+  for (const extra of states) {
+    const row = rows.find((v) => v.x === extra.x && v.y === extra.y && v.z === extra.z);
+    if (row) row.state = extra.state;
+    else rows.push({ x: extra.x, y: extra.y, z: extra.z, voxelType: 0, state: extra.state });
+  }
+  return rows;
+}
+
+/** JSON mailbox payloads become base64; values that are already base64 pass through. */
+export function voxelStateToWire(state: string): string {
+  const trimmed = state.trimStart();
+  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+    return bytesToBase64(new TextEncoder().encode(state));
+  }
+  return state;
+}
+
 export function bytesToBase64(bytes: Uint8Array): string {
   let binary = '';
   for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]!);

package/src/platform/studio/instanceSchema.test.ts

@@ -79,6 +79,49 @@ describe('parseSceneCatalog', () => {
     expect(catalog?.nodes[0]?.mesh).toBe('tri');
   });
 
+  it('keeps flat lambert shading and treats unlit as basic', () => {
+    const catalog = parseSceneCatalog({
+      v: 1,
+      revision: 1,
+      meshes: [],
+      nodes: [
+        { id: 'body', x: 0, y: 0, z: 0, shading: 'lambert', flat: true },
+        { id: 'bolt', x: 0, y: 0, z: 0, unlit: true },
+      ],
+    });
+    expect(catalog?.nodes[0]).toMatchObject({ shading: 'lambert', flat: true, unlit: false });
+    expect(catalog?.nodes[1]).toMatchObject({ shading: 'basic', unlit: true, fog: false });
+  });
+
+  it('keeps additive, emissive, double-sided, and fog opt-out', () => {
+    const catalog = parseSceneCatalog({
+      v: 1,
+      revision: 1,
+      meshes: [],
+      nodes: [
+        {
+          id: 'shield',
+          x: 0,
+          y: 0,
+          z: 0,
+          shading: 'lambert',
+          blend: 'additive',
+          depthWrite: false,
+          emissive: 0x88ccff,
+          side: 'double',
+          fog: false,
+        },
+      ],
+    });
+    expect(catalog?.nodes[0]).toMatchObject({
+      blend: 'additive',
+      depthWrite: false,
+      emissive: 0x88ccff,
+      side: 'double',
+      fog: false,
+    });
+  });
+
   it('drops over-cap vertex lists and parent-less garbage', () => {
     const positions = Array.from({ length: (MAX_VERTS + 1) * 3 }, () => 1);
     expect(

package/src/platform/studio/instanceSchema.ts

@@ -27,6 +27,9 @@ export const MAX_EVENT_STATE_BYTES = 1022;
 const CATALOG_CHUNK_HEADER = 8;
 
 export type MeshKind = 'box' | 'sphere' | 'cylinder' | 'capsule' | 'plane' | 'mesh';
+export type SceneShading = 'standard' | 'lambert' | 'basic';
+export type SceneBlend = 'normal' | 'additive';
+export type SceneSide = 'front' | 'double';
 export type ModOverlayShape = MeshKind;
 
 export interface SceneMesh {
@@ -56,6 +59,20 @@ export interface SceneNode {
   color: number;
   visible: boolean;
   bindActor?: string;
+  /** Unlit bolt, matching Afterburn's MeshBasicMaterial streak. */
+  unlit?: boolean;
+  /** standard is the lit default. lambert + flat is the robot and jet. basic is unlit. */
+  shading?: SceneShading;
+  flat?: boolean;
+  opacity?: number;
+  /** additive brightens what is behind the part. depthWrite false keeps it from punching a hole. */
+  blend?: SceneBlend;
+  depthWrite?: boolean;
+  /** Lit glow. Ignored on basic, which is already unlit. */
+  emissive?: number;
+  side?: SceneSide;
+  /** false keeps a lit part from fading in fog. basic already skips fog unless set true. */
+  fog?: boolean;
 }
 
 /** Overlay objects are scene nodes; `shape` is an alias of `kind` for older payloads. */
@@ -92,6 +109,18 @@ export interface ComposedInstance {
   sz: number;
   color: number;
   visible: boolean;
+  unlit?: boolean;
+  shading?: SceneShading;
+  flat?: boolean;
+  opacity?: number;
+  /** additive brightens what is behind the part. depthWrite false keeps it from punching a hole. */
+  blend?: SceneBlend;
+  depthWrite?: boolean;
+  /** Lit glow. Ignored on basic, which is already unlit. */
+  emissive?: number;
+  side?: SceneSide;
+  /** false keeps a lit part from fading in fog. basic already skips fog unless set true. */
+  fog?: boolean;
 }
 
 export interface WorldAabb {
@@ -144,6 +173,18 @@ export function parseColor(value: unknown): number {
   return 0xf8fafc;
 }
 
+function parseFog(rec: Record<string, unknown>, shading: SceneShading): boolean {
+  if (rec.fog === false) return false;
+  if (rec.fog === true) return true;
+  return shading !== 'basic';
+}
+
+function parseShading(rec: Record<string, unknown>): SceneShading {
+  if (rec.unlit === true || rec.basic === true || rec.shading === 'basic') return 'basic';
+  if (rec.shading === 'lambert') return 'lambert';
+  return 'standard';
+}
+
 function parseKind(value: unknown): MeshKind {
   if (
     value === 'sphere' ||
@@ -290,6 +331,15 @@ function parseNode(
     color: parseColor(rec.color ?? rec.colour),
     visible,
     bindActor: parseBindActor(rec.bindActor ?? rec.bind_actor ?? rec.actor),
+    unlit: rec.unlit === true || rec.basic === true || rec.shading === 'basic',
+    shading: parseShading(rec),
+    flat: rec.flat === true || rec.flatShading === true,
+    opacity: clamp(finiteNumber(rec.opacity, 1) ?? 1, 0, 1),
+    blend: rec.blend === 'additive' ? 'additive' : 'normal',
+    depthWrite: rec.depthWrite !== false && rec.depth_write !== false,
+    emissive: rec.emissive === undefined ? undefined : parseColor(rec.emissive),
+    side: rec.side === 'double' ? 'double' : 'front',
+    fog: parseFog(rec, parseShading(rec)),
   };
 }
 
@@ -538,6 +588,15 @@ export function composeScene(
       sz,
       color: node.color || mesh?.color || 0xf8fafc,
       visible: true,
+      unlit: node.unlit,
+      shading: node.shading,
+      flat: node.flat,
+      opacity: node.opacity,
+      blend: node.blend,
+      depthWrite: node.depthWrite,
+      emissive: node.emissive,
+      side: node.side,
+      fog: node.fog,
     };
     world.set(id, composed);
     return composed;

package/src/platform/studio/instanceStore.ts

@@ -18,6 +18,7 @@ import {
   type ActorXform,
   type ComposedInstance,
   type SceneCatalog,
+  type SceneMesh,
   type SceneNode,
 } from './instanceSchema';
 import type { ModOverlayObject } from './modOverlay';
@@ -31,6 +32,7 @@ export interface InstanceSnapshotInput {
   overlay?: readonly ModOverlayObject[];
   actors?: readonly ActorXform[];
   grid?: PlayerCodeGridBounds;
+  meshes?: readonly SceneMesh[];
 }
 
 export class InstanceStore {
@@ -71,7 +73,7 @@ export class InstanceStore {
     const overlay = input.overlay ?? [];
     const overlayIds = new Set(overlay.map((n) => n.id));
     const nodes: SceneNode[] = [...catalogNodes.filter((n) => !overlayIds.has(n.id)), ...overlay];
-    const meshes = this.catalog?.meshes ?? [];
+    const meshes = [...(this.catalog?.meshes ?? []), ...(input.meshes ?? [])];
     return {
       revision: this.revisionValue,
       instances: composeScene(nodes, meshes, input.actors ?? [], input.grid),