@wildshard/shard-format 0.0.1 → 0.4.6

package/src/format/spawnScriptV2.ts

@@ -0,0 +1,145 @@
+import * as v from 'valibot';
+import { createV2QuerySnapshotSchema } from './scriptQueryStateV2.ts';
+import { ScriptArtifactV2Schema } from './scriptAdmissionV2.ts';
+import { ObservationColumnsV2Schema } from './scriptObservationColumnsV2.ts';
+import { ScriptInputStateV2Schema } from './scriptInputStateV2.ts';
+
+const natural = v.pipe(v.number(),v.safeInteger(),v.minValue(0));
+const identity = v.pipe(v.string(),v.minLength(1),v.maxLength(128));
+const finite = v.pipe(v.number(),v.finite());
+/** Explicit operation rights; concrete entered owners are lent separately. */
+const worldActions = v.strictObject({
+  targets: v.pipe(v.array(v.strictObject({ handle: v.pipe(natural,v.minValue(1),v.maxValue(256)),identity,
+    kind: v.picklist(['player','mount','cell-field']) })),v.minLength(1),v.maxLength(256)),
+  operations: v.pipe(v.array(v.picklist([14,23,24])),v.minLength(1),v.maxLength(3)),
+  maxCommands: v.pipe(natural,v.minValue(1),v.maxValue(32)),
+  bounds: v.strictObject({ coordinate: v.pipe(finite,v.minValue(Number.MIN_VALUE)),velocity: v.pipe(finite,v.minValue(0)) }),
+});
+/** Explicit production actor-module selection. No Developer gate or byte
+ * sniffing selects an ABI. Empty bytes are resolved by the product reader. */
+export const SpawnScriptV2Schema: v.GenericSchema<SpawnScriptV2RowsInput, SpawnScriptV2Rows> = v.strictObject({ version: v.literal(1),
+  artifact: v.strictObject({ ...ScriptArtifactV2Schema.entries,lane: v.literal('sim'),
+    hash: v.pipe(v.string(),v.regex(/^[a-f0-9]{64}$/)) }),
+  bytes: v.string(),io: v.pipe(natural,v.maxValue(4*65536)),
+  capacities: v.pipe(v.array(v.strictObject({ kind: v.pipe(natural,v.minValue(1),v.maxValue(22)),capacity: v.pipe(natural,v.maxValue(4096)) })),v.maxLength(22)),
+  divisor: v.union([v.literal(2),v.literal(6)]),
+  fuel: v.pipe(natural,v.minValue(1),v.maxValue(0x7fffffff)),initFuel: v.pipe(natural,v.maxValue(0x7fffffff)),
+  queries: v.exactOptional(v.strictObject({ pending: v.pipe(natural,v.minValue(1),v.maxValue(32)),
+    operations: v.pipe(v.array(v.strictObject({ op: v.picklist([4,5,8,9,10,11,12,13]),scalars: v.pipe(natural,v.maxValue(4096)) })),v.minLength(1),v.maxLength(8)) })),
+  effects: v.exactOptional(v.strictObject({ world: v.exactOptional(worldActions),elites: v.exactOptional(v.literal(true)) })),
+  self: v.exactOptional(v.pipe(v.string(),v.minLength(1),v.maxLength(128))),columns: ObservationColumnsV2Schema,
+});
+
+/** Only logical input/quarantine state joins the SAME SpawnScript envelope.
+ * No module bytes, Wasm memory, cached observations or native body is saved. */
+export const SpawnInputV2Schema: v.GenericSchema<SpawnInputV2Input, SpawnInputV2> = v.strictObject({ version: v.literal(1),contract: v.string(),input: ScriptInputStateV2Schema,
+  failures: v.pipe(natural,v.maxValue(3)),queries: v.exactOptional(createV2QuerySnapshotSchema({ bindings: 64,requests: 4096,scalars: 4096 })) });
+
+
+/** Admitted data contracts, independent of validator implementation metadata. */
+interface SpawnScriptV2RowsInputFields {
+    version: 1;
+    artifact: Omit<v.InferInput<typeof ScriptArtifactV2Schema>, keyof ({
+        lane: 'sim';
+        hash: string;
+    })> & {
+        lane: 'sim';
+        hash: string;
+    };
+    bytes: string;
+    io: number;
+    capacities: ({
+        kind: number;
+        capacity: number;
+    })[];
+    divisor: (2) | (6);
+    fuel: number;
+    initFuel: number;
+    queries?: {
+        pending: number;
+        operations: ({
+            op: 4 | 5 | 8 | 9 | 10 | 11 | 12 | 13;
+            scalars: number;
+        })[];
+    };
+    effects?: {
+        world?: {
+            targets: ({
+                handle: number;
+                identity: string;
+                kind: 'player' | 'mount' | 'cell-field';
+            })[];
+            operations: (14 | 23 | 24)[];
+            maxCommands: number;
+            bounds: {
+                coordinate: number;
+                velocity: number;
+            };
+        };
+        elites?: true;
+    };
+    self?: string;
+    columns: v.InferInput<typeof ObservationColumnsV2Schema>;
+}
+export type SpawnScriptV2RowsInput = { [Key in keyof SpawnScriptV2RowsInputFields]: SpawnScriptV2RowsInputFields[Key] };
+interface SpawnScriptV2RowsFields {
+    version: 1;
+    artifact: Omit<v.InferOutput<typeof ScriptArtifactV2Schema>, keyof ({
+        lane: 'sim';
+        hash: string;
+    })> & {
+        lane: 'sim';
+        hash: string;
+    };
+    bytes: string;
+    io: number;
+    capacities: ({
+        kind: number;
+        capacity: number;
+    })[];
+    divisor: (2) | (6);
+    fuel: number;
+    initFuel: number;
+    queries?: {
+        pending: number;
+        operations: ({
+            op: 4 | 5 | 8 | 9 | 10 | 11 | 12 | 13;
+            scalars: number;
+        })[];
+    };
+    effects?: {
+        world?: {
+            targets: ({
+                handle: number;
+                identity: string;
+                kind: 'player' | 'mount' | 'cell-field';
+            })[];
+            operations: (14 | 23 | 24)[];
+            maxCommands: number;
+            bounds: {
+                coordinate: number;
+                velocity: number;
+            };
+        };
+        elites?: true;
+    };
+    self?: string;
+    columns: v.InferOutput<typeof ObservationColumnsV2Schema>;
+}
+export type SpawnScriptV2Rows = { [Key in keyof SpawnScriptV2RowsFields]: SpawnScriptV2RowsFields[Key] };
+interface SpawnInputV2InputFields {
+    version: 1;
+    contract: string;
+    input: v.InferInput<typeof ScriptInputStateV2Schema>;
+    failures: number;
+    queries?: v.InferInput<ReturnType<typeof createV2QuerySnapshotSchema>>;
+}
+export type SpawnInputV2Input = { [Key in keyof SpawnInputV2InputFields]: SpawnInputV2InputFields[Key] };
+interface SpawnInputV2Fields {
+    version: 1;
+    contract: string;
+    input: v.InferOutput<typeof ScriptInputStateV2Schema>;
+    failures: number;
+    queries?: v.InferOutput<ReturnType<typeof createV2QuerySnapshotSchema>>;
+}
+export type SpawnInputV2 = { [Key in keyof SpawnInputV2Fields]: SpawnInputV2Fields[Key] };

package/src/format/spawnScripts.ts

@@ -0,0 +1,229 @@
+import * as v from 'valibot';
+import { SpawnScriptV2Schema } from './spawnScriptV2.ts';
+import { layoutV2 } from './scriptWireV2.ts';
+import { isJsonData } from './json.ts';
+import { SpawnCombatSchema } from './spawnCombat.ts';
+import { actorDecisionRows,parseDecisionScripts, type DecisionScriptRow } from './decisionScripts.ts';
+import { actorMoveRules, parseActorMoves } from './actorMoves.ts';
+import type { DecisionRegistries } from './decisionBindings.ts';
+
+const key = v.pipe(v.string(), v.minLength(1), v.maxLength(128));
+const finite = v.pipe(v.number(), v.finite());
+const handle = v.pipe(finite, v.integer(), v.minValue(1), v.maxValue(256));
+export const SpawnScriptRowSchema: v.StrictObjectSchema<{ readonly v2: v.ExactOptionalSchema<v.GenericSchema<Exclude<SpawnScriptRowDataInput['v2'], undefined>, Exclude<SpawnScriptRowData['v2'], undefined>>, undefined>; readonly step: v.GenericSchema<SpawnScriptRowDataInput['step'], SpawnScriptRowData['step']>; readonly roster: v.GenericSchema<SpawnScriptRowDataInput['roster'], SpawnScriptRowData['roster']>; readonly seed: v.GenericSchema<SpawnScriptRowDataInput['seed'], SpawnScriptRowData['seed']>; readonly script: v.GenericSchema<SpawnScriptRowDataInput['script'], SpawnScriptRowData['script']>; readonly bytes: v.GenericSchema<SpawnScriptRowDataInput['bytes'], SpawnScriptRowData['bytes']>; readonly controlState: v.GenericSchema<SpawnScriptRowDataInput['controlState'], SpawnScriptRowData['controlState']>; readonly maximum: v.GenericSchema<SpawnScriptRowDataInput['maximum'], SpawnScriptRowData['maximum']>; readonly slots: v.GenericSchema<SpawnScriptRowDataInput['slots'], SpawnScriptRowData['slots']>; readonly species: v.GenericSchema<SpawnScriptRowDataInput['species'], SpawnScriptRowData['species']>; readonly sites: v.GenericSchema<SpawnScriptRowDataInput['sites'], SpawnScriptRowData['sites']>; readonly spawns: v.GenericSchema<SpawnScriptRowDataInput['spawns'], SpawnScriptRowData['spawns']>; readonly fields: v.GenericSchema<SpawnScriptRowDataInput['fields'], SpawnScriptRowData['fields']>; readonly flags: v.GenericSchema<SpawnScriptRowDataInput['flags'], SpawnScriptRowData['flags']>; readonly cues: v.GenericSchema<SpawnScriptRowDataInput['cues'], SpawnScriptRowData['cues']>; readonly channels: v.GenericSchema<SpawnScriptRowDataInput['channels'], SpawnScriptRowData['channels']>; readonly strikes: v.ExactOptionalSchema<v.GenericSchema<Exclude<SpawnScriptRowDataInput['strikes'], undefined>, Exclude<SpawnScriptRowData['strikes'], undefined>>, undefined>; readonly moves: v.GenericSchema<SpawnScriptRowDataInput['moves'], SpawnScriptRowData['moves']>; readonly legacy: v.ExactOptionalSchema<v.GenericSchema<Exclude<SpawnScriptRowDataInput['legacy'], undefined>, Exclude<SpawnScriptRowData['legacy'], undefined>>, undefined>; }, undefined> = v.strictObject({
+  v2: v.exactOptional(SpawnScriptV2Schema),
+  step: key, roster: key, seed: v.pipe(finite, v.integer(), v.minValue(0), v.maxValue(0xffffffff)), script: v.unknown(), bytes: v.string(), controlState: key, maximum: handle,
+  slots: v.pipe(v.array(v.strictObject({ id: key, handle, authority: v.exactOptional(v.literal('observe')),release: v.exactOptional(v.picklist(['retain', 'detach'])) })), v.minLength(1), v.maxLength(8)),
+  species: v.pipe(v.array(v.strictObject({ id: key, kind: key, variant: key })), v.minLength(1), v.maxLength(64)),
+  sites: v.pipe(v.array(v.strictObject({ id: key, slot: key,
+    point: v.exactOptional(v.tuple([finite, finite])), face: v.union([v.literal('player'), v.tuple([finite, finite])]),
+  })), v.minLength(1), v.maxLength(64)),
+  spawns: v.pipe(v.array(v.strictObject({ id: key, species: key, site: key })), v.minLength(1), v.maxLength(64)),
+  fields: v.pipe(v.array(v.strictObject({ id: key, source: v.picklist(['x', 'z', 'scripted', 'lookWeight', 'night', 'limit', 'force', 'value', 'observed', 'channel', 'lookHeight', 'hidden', 'seed', 'lastHit', 'strikeTime']), channel: v.exactOptional(key), fallback: v.exactOptional(finite) })), v.maxLength(32)),
+  flags: v.pipe(v.array(key), v.maxLength(64)), cues: v.pipe(v.array(key), v.maxLength(32)),
+  channels: v.pipe(v.array(key), v.maxLength(16)), strikes: v.exactOptional(SpawnCombatSchema), moves: v.unknown(),
+  // Historical wire names and state-slot mappings are content, not hard-coded save-slot names in a host.
+  legacy: v.exactOptional(v.strictObject({ spec: v.string(), acc: key, rng: key, countChannel: key,
+    groups: v.pipe(v.array(v.strictObject({ key, active: key, slots: v.array(key), values: v.array(key), value: key,
+      type: v.picklist(['f64', 'bool']) })), v.maxLength(8)),
+  })),
+});
+export type SpawnScriptRows = Omit<v.InferOutput<typeof SpawnScriptRowSchema>, 'script' | 'moves'> & {
+  script: DecisionScriptRow; moves: ReturnType<typeof parseActorMoves>;
+};
+/** An independent bounded actor-slot catalogue, using the same v1 admission and generated bindings as other guests. */
+export function spawnScriptRegistries(data: Pick<SpawnScriptRows, 'slots' | 'spawns' | 'fields' | 'flags' | 'cues' | 'channels' | 'moves' | 'strikes'> & { readonly script?: DecisionScriptRow }): DecisionRegistries {
+  const ids = (names: readonly string[]): ReadonlyMap<string, number> => {
+    if (new Set(names).size !== names.length) throw new Error('Duplicate spawn script identity');
+    return new Map(names.map((name, index) => [name, index + 1]));
+  };
+  return { actors: new Map(data.slots.map(row => [row.id, row.handle])), spawns: ids([...data.spawns.map(row => row.id), ...(data.script !== undefined && 'spawnGroup' in data.script.binding ? [data.script.binding.spawnGroup] : [])]),
+    fields: ids(data.fields.map(row => row.id)), flags: ids(data.flags), cues: ids(data.cues), channels: ids(data.channels),
+    moves: ids(data.moves.map(row => row.id)), strikes: ids((data.strikes ?? []).map(row => row.row.id)) };
+}
+/** Validate recipes and every cross-reference before a script or body can be installed. */
+export function parseSpawnScript(input: unknown): SpawnScriptRows {
+  if (!isJsonData(input)) throw new Error('Spawn script requires plain JSON');
+  const data = v.parse(SpawnScriptRowSchema, input), script = parseDecisionScripts([data.script])[0];
+  if (script?.side !== 'sim' || !('shard' in script.binding || 'spawnGroup' in script.binding)) throw new Error('Spawn script requires a simulation shard binding');
+  const result = { ...data, script, moves: parseActorMoves(data.moves) };
+  const registry = spawnScriptRegistries(result);
+  if (data.v2 !== undefined) {
+    const row = data.v2, capacities = new Map(row.capacities.map(item => [item.kind,item.capacity]));
+    const layout = layoutV2(row.io,row.artifact.pages,capacities);
+    const bindings = actorDecisionRows(script).length;
+    const needed = new Map([[1,bindings],[2,bindings*script.state.length],[3,bindings*script.state.length],[4,bindings*Object.keys(script.params).length],[5,bindings],[6,bindings*data.fields.length],[7,1],[9,16],[21,bindings],[22,bindings]]);
+    if ([...needed].some(([kind,count]) => (capacities.get(kind) ?? 0) < count)) throw new Error('Incomplete spawn v2 input layout');
+    if (capacities.size !== row.capacities.length || layout.bytes !== row.artifact.ioBytes) throw new Error('Invalid spawn v2 layout');
+    if (row.queries !== undefined) {
+      const query = row.queries;
+      if (new Set(query.operations.map(operation => operation.op)).size !== query.operations.length
+        || (capacities.get(11) ?? 0) < query.pending || (capacities.get(12) ?? 0) < query.pending
+        || query.operations.some(operation => operation.scalars > (capacities.get(13) ?? 0) || operation.op === 8 && operation.scalars < 4)) throw new Error('Invalid spawn v2 query rights or capacity');
+    }
+    if (row.effects !== undefined) {
+      const world = row.effects.world;
+      if (world === undefined && row.effects.elites !== true) throw new Error('Empty v2 effect capabilities');
+      if (row.effects.elites === true && data.slots.some(slot => slot.authority !== 'observe')) throw new Error('Page effect slots must observe original bodies');
+      if (world !== undefined && (new Set(world.targets.map(target => target.handle)).size !== world.targets.length
+        || new Set(world.targets.map(target => target.identity)).size !== world.targets.length
+        || new Set(world.operations).size !== world.operations.length)) throw new Error('Duplicate v2 effect capability');
+    }
+    if (row.self !== undefined && 'spawnGroup' in script.binding) throw new Error('V2 spawn groups use their own self slots');
+    if (row.self !== undefined && !registry.actors?.has(row.self)) throw new Error('Unknown v2 self slot');
+    for (const column of row.columns) if (data.fields[column.id-1]?.id !== column.name || data.fields[column.id-1]?.source !== 'observed') throw new Error('V2 column requires matching observed field');
+  }
+  if (new Set(data.slots.map(row => row.handle)).size !== data.slots.length || new Set(data.slots.map(row => row.id)).size !== data.slots.length) throw new Error('Duplicate spawn slot handle');
+  for (const name of ['species', 'sites', 'spawns'] as const)
+    if (new Set(data[name].map(row => row.id)).size !== data[name].length) throw new Error('Duplicate spawn recipe');
+  if (data.slots.some(row => row.authority === 'observe') && data.v2 === undefined) throw new Error('Observation-only slots require v2');
+  if (data.sites.some(row => !registry.actors?.has(row.slot)) || data.spawns.some(row =>
+    !data.sites.some(site => site.id === row.site) || !data.species.some(species => species.id === row.species))) throw new Error('Missing spawn recipe reference');
+  if (Object.values(script.spawns).some(id => {
+    if ('spawnGroup' in script.binding && id === script.binding.spawnGroup) return false;
+    const spawn = data.spawns.find(row => row.id === id), site = data.sites.find(row => row.id === spawn?.site);
+    return site === undefined || !Object.values(script.actors).includes(site.slot);
+  })) throw new Error('Spawn recipe requires an owned actor slot');
+  const commands = new Set(['spawn', 'despawn', 'field', 'flag', 'move', 'stop', 'cue', 'channel', 'strike']);
+  const reads = new Set(['x', 'y', 'z', 'yaw', 'hpShare', 'alive', 'field', 'distance', 'nearestPlayer', 'flag', 'groundHeight', 'moving', 'radial', 'random', 'strikeState', 'spawnGroupAlive']);
+  if (script.commands.some(command => !commands.has(command)) || script.reads.some(read => !reads.has(read))) throw new Error('Unsupported spawn script capability');
+  if (data.fields.some(row => row.source === 'channel' && (row.channel === undefined || !data.channels.includes(row.channel)))) throw new Error('Missing field channel');
+  if ((data.strikes ?? []).some(row => [row.startCue, row.activeCue, row.doneCue].some(cue => cue !== undefined && !data.cues.includes(cue)))) throw new Error('Missing strike cue');
+  for (const move of result.moves) if (move.kind === 'steer' && Object.values(move.fields).some(id => data.fields.find(row => row.id === id)?.source !== 'value')) throw new Error('Owned steering requires writable value fields');
+  if (actorMoveRules(result.moves, { spots: new Set(), fields: new Set(data.fields.map(row => row.id)), strikes: new Set((data.strikes ?? []).map(row => row.row.id)) }).length > 0) throw new Error('Missing owned movement reference');
+  return result;
+}
+
+/** Owned spawn directors are admitted separately from automatically installed actor decisions. */
+export const SpawnScriptsSchema: v.GenericSchema<unknown[], SpawnScriptRows[]> = v.pipe(v.array(v.unknown()), v.maxLength(16), v.transform(input => input.map(parseSpawnScript)),
+  v.check(input => input.every(row => row.bytes === '' && (row.v2 === undefined || row.v2.bytes === '')) && new Set(input.map(row => row.step)).size === input.length, 'Catalogue modules must use admitted product bytes and unique step ids'));
+
+/** Admitted data contracts, independent of validator implementation metadata. */
+interface SpawnScriptRowDataInputFields {
+    v2?: v.InferInput<typeof SpawnScriptV2Schema>;
+    step: string;
+    roster: string;
+    seed: number;
+    script: unknown;
+    bytes: string;
+    controlState: string;
+    maximum: number;
+    slots: ({
+        id: string;
+        handle: number;
+        authority?: 'observe';
+        release?: 'retain' | 'detach';
+    })[];
+    species: ({
+        id: string;
+        kind: string;
+        variant: string;
+    })[];
+    sites: ({
+        id: string;
+        slot: string;
+        point?: [
+            number,
+            number
+        ];
+        face: ('player') | ([
+            number,
+            number
+        ]);
+    })[];
+    spawns: ({
+        id: string;
+        species: string;
+        site: string;
+    })[];
+    fields: ({
+        id: string;
+        source: 'x' | 'z' | 'scripted' | 'lookWeight' | 'night' | 'limit' | 'force' | 'value' | 'observed' | 'channel' | 'lookHeight' | 'hidden' | 'seed' | 'lastHit' | 'strikeTime';
+        channel?: string;
+        fallback?: number;
+    })[];
+    flags: (string)[];
+    cues: (string)[];
+    channels: (string)[];
+    strikes?: v.InferInput<typeof SpawnCombatSchema>;
+    moves: unknown;
+    legacy?: {
+        spec: string;
+        acc: string;
+        rng: string;
+        countChannel: string;
+        groups: ({
+            key: string;
+            active: string;
+            slots: (string)[];
+            values: (string)[];
+            value: string;
+            type: 'f64' | 'bool';
+        })[];
+    };
+}
+export type SpawnScriptRowDataInput = { [Key in keyof SpawnScriptRowDataInputFields]: SpawnScriptRowDataInputFields[Key] };
+interface SpawnScriptRowDataFields {
+    v2?: v.InferOutput<typeof SpawnScriptV2Schema>;
+    step: string;
+    roster: string;
+    seed: number;
+    script: unknown;
+    bytes: string;
+    controlState: string;
+    maximum: number;
+    slots: ({
+        id: string;
+        handle: number;
+        authority?: 'observe';
+        release?: 'retain' | 'detach';
+    })[];
+    species: ({
+        id: string;
+        kind: string;
+        variant: string;
+    })[];
+    sites: ({
+        id: string;
+        slot: string;
+        point?: [
+            number,
+            number
+        ];
+        face: ('player') | ([
+            number,
+            number
+        ]);
+    })[];
+    spawns: ({
+        id: string;
+        species: string;
+        site: string;
+    })[];
+    fields: ({
+        id: string;
+        source: 'x' | 'z' | 'scripted' | 'lookWeight' | 'night' | 'limit' | 'force' | 'value' | 'observed' | 'channel' | 'lookHeight' | 'hidden' | 'seed' | 'lastHit' | 'strikeTime';
+        channel?: string;
+        fallback?: number;
+    })[];
+    flags: (string)[];
+    cues: (string)[];
+    channels: (string)[];
+    strikes?: v.InferOutput<typeof SpawnCombatSchema>;
+    moves: unknown;
+    legacy?: {
+        spec: string;
+        acc: string;
+        rng: string;
+        countChannel: string;
+        groups: ({
+            key: string;
+            active: string;
+            slots: (string)[];
+            values: (string)[];
+            value: string;
+            type: 'f64' | 'bool';
+        })[];
+    };
+}
+export type SpawnScriptRowData = { [Key in keyof SpawnScriptRowDataFields]: SpawnScriptRowDataFields[Key] };

package/src/format/spawnTables.ts

@@ -0,0 +1,46 @@
+import * as v from 'valibot';
+import { isJsonData } from './json.ts';
+
+const id = v.pipe(v.string(), v.regex(/^[a-z][a-zA-Z0-9.:-]*$/u), v.maxLength(128));
+const number = v.pipe(v.number(), v.finite(), v.minValue(0), v.maxValue(10000000));
+const count = v.pipe(number, v.integer(), v.maxValue(1024));
+const gate = v.strictObject({ kind: v.exactOptional(id), tags: v.exactOptional(v.pipe(v.array(id), v.maxLength(32))) });
+const row = v.strictObject({ item: v.strictObject({ kind: id, variant: v.exactOptional(id) }), weight: number,
+  count: v.exactOptional(v.union([count, v.pipe(v.tuple([count, count]), v.check(([low, high]) => low <= high, 'ordered count'))])),
+  when: v.exactOptional(gate) });
+/** Ordered each/weighted tables with conjunctive kind/tag gates; all draws stay in WeightedTable. */
+export const SpawnTablesSchema: v.GenericSchema<SpawnTablesInput, SpawnTables> = v.pipe(v.unknown(), v.check(isJsonData, 'Spawn tables must be plain JSON'),
+  v.array(v.strictObject({ id, table: v.strictObject({ mode: v.picklist(['each', 'weighted']), rows: v.pipe(v.array(row), v.maxLength(256)) }),
+    respawn: v.exactOptional(v.strictObject({ delay: number, away: number })) })), v.maxLength(256),
+  v.check(rows => new Set(rows.map(value => value.id)).size === rows.length, 'unique spawn table ids'));
+
+/** Admit the complete table set before registering a live spawner. */
+export function readSpawnTables(input: unknown): SpawnTables { return v.parse(SpawnTablesSchema, input); }
+
+/** Admitted data contracts, independent of validator implementation metadata. */
+export type SpawnTablesInput = unknown;
+export type SpawnTables = ({
+    id: string;
+    table: {
+        mode: 'each' | 'weighted';
+        rows: ({
+            item: {
+                kind: string;
+                variant?: string;
+            };
+            weight: number;
+            count?: (number) | ([
+                number,
+                number
+            ]);
+            when?: {
+                kind?: string;
+                tags?: (string)[];
+            };
+        })[];
+    };
+    respawn?: {
+        delay: number;
+        away: number;
+    };
+})[];

package/src/format/spawnView.ts

@@ -0,0 +1,26 @@
+/** DL21: the scene tiles the spawn-view fence attaches before control, as the build sees them. The fence (game
+ * `controlRefinement.ts`, `SPAWN_VIEW_M`) awaits every spatial job within this 3-D radius of the spawn, in every direction
+ * (DL17, G1000), so a tiled scene library's file with any chunk in reach is control IO, even when the library is `late`. */
+export const SPAWN_VIEW_REACH_M = 221;
+const object = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null && !Array.isArray(value);
+const point = (value: unknown): value is number[] => Array.isArray(value) && value.length >= 3 && value.every(n => typeof n === 'number' && Number.isFinite(n));
+/** The files of `world/scenes` library tiles with a chunk sphere within `reach` of `world/spawn`'s point (none without a
+ *  spawn). A sphere is `[x, y, z, radius]`; a chunk counts when its nearest surface point is in reach. */
+export function spawnViewSceneFiles(sections: ReadonlyMap<string, unknown>, reach: number = SPAWN_VIEW_REACH_M): ReadonlySet<string> {
+  const spawnSection = sections.get('world/spawn'), spawn = object(spawnSection) ? spawnSection['spawn'] : undefined;
+  if (!object(spawn) || typeof spawn['x'] !== 'number' || typeof spawn['z'] !== 'number') return new Set();
+  const at = [spawn['x'], typeof spawn['y'] === 'number' ? spawn['y'] : 0, spawn['z']], files = new Set<string>();
+  const scenes = sections.get('world/scenes'), libraries = object(scenes) && Array.isArray(scenes['libraries']) ? scenes['libraries'] : [];
+  for (const library of libraries) {
+    const tiles = object(library) && Array.isArray(library['tiles']) ? library['tiles'] : [];
+    for (const tile of tiles) for (const file of object(tile) && Array.isArray(tile['files']) ? tile['files'] : []) {
+      if (!object(file) || typeof file['file'] !== 'string' || !Array.isArray(file['chunks'])) continue;
+      const near = file['chunks'].some(chunk => {
+        const sphere = object(chunk) ? chunk['sphere'] : undefined;
+        return point(sphere) && Math.hypot((sphere[0] ?? 0) - (at[0] ?? 0), (sphere[1] ?? 0) - (at[1] ?? 0), (sphere[2] ?? 0) - (at[2] ?? 0)) - (sphere[3] ?? 0) <= reach;
+      });
+      if (near) files.add(file['file']);
+    }
+  }
+  return files;
+}

package/src/format/speciesActorsFile.ts

@@ -0,0 +1,86 @@
+import * as v from 'valibot';
+import {isJsonData} from './json.ts';
+import {FixedDrawRowsSchema} from './fixedDraws.ts';
+import {NumericPoseSchema,type NumericPoseRows} from './clientChannels.ts';
+import {CreatureGuestSchema,SpeciesPresentationSchema,type CreatureGuestRows,type SpeciesPresentationRows} from './speciesBookRows.ts';
+import {CompactSpeciesBodiesSchema,type CompactSpeciesBodiesRows} from './speciesLooks.ts';
+import {type CrowdPresentationSchema,CrowdGuardSchema} from './crowdPresentation.ts';
+import {FlockSchema} from './crowds.ts';
+import {ReturnProgramWireDocumentSchema,type ReturnProgramDocumentInput} from './returnProgramDocument.ts';
+import {ReturnProgramSchema} from './namedJsonContracts.ts';
+
+const completeReturn:v.GenericSchema<v.InferInput<typeof ReturnProgramSchema>,v.InferOutput<typeof ReturnProgramSchema>&ReturnProgramDocumentInput>=v.intersect([ReturnProgramSchema,ReturnProgramWireDocumentSchema]);
+
+const n=v.pipe(v.number(),v.finite()),text=v.pipe(v.string(),v.minLength(1),v.maxLength(4096));
+const triple=v.tuple([n,n,n]);
+function keysOnly(input:unknown,keys:readonly string[]):boolean {return typeof input==='object'&&input!==null&&!Array.isArray(input)&&Object.keys(input).every(key=>keys.includes(key));}
+// Preserve every caller-owned field before the older non-strict child parsers
+// can project it away. This is local admission, never an authored callback API.
+function retainsKeys(input:unknown,output:unknown):boolean {
+ if(typeof input!=='object'||input===null)return true;
+ if(typeof output!=='object'||output===null||Array.isArray(input)!==Array.isArray(output))return false;
+ const before=Object.keys(input),after=Object.keys(output);
+ return before.length===after.length&&before.every(key=>Object.hasOwn(output,key)&&retainsKeys(Reflect.get(input,key),Reflect.get(output,key)));
+}
+function retainedBy(schema:v.GenericSchema,input:unknown):boolean {
+ const result=v.safeParse(schema,input);return result.success&&retainsKeys(input,result.output);
+}
+
+export interface SpeciesSkeletonRows {
+ bones:{name:string;parent:string|null;pos:[number,number,number]}[];
+ dims:{bodyY:number;bodyHalfLen:number;bodyRadius:number;headRadius:number;legLen:number;feet:[number,number][];halfWidth:number;
+  capsuleAxis?:'z'|'y';headAt?:[number,number,number];bodyAt?:[number,number,number];bodyPitch?:number;
+  fore?:{bone:string;at:[number,number,number];halfLen:number;radius:number}};
+}
+type BodyRows=Omit<CompactSpeciesBodiesRows,'skeletons'>&{skeletons:SpeciesSkeletonRows[]};
+const skeleton:v.GenericSchema<unknown,SpeciesSkeletonRows>=v.strictObject({
+ bones:v.pipe(v.array(v.strictObject({name:text,parent:v.nullable(text),pos:triple})),v.minLength(1),v.maxLength(32)),
+ dims:v.strictObject({bodyY:n,bodyHalfLen:n,bodyRadius:n,headRadius:n,legLen:n,feet:v.pipe(v.array(v.tuple([n,n])),v.maxLength(32)),halfWidth:n,
+  capsuleAxis:v.exactOptional(v.picklist(['z','y'])),headAt:v.exactOptional(triple),bodyAt:v.exactOptional(triple),bodyPitch:v.exactOptional(n),
+  fore:v.exactOptional(v.strictObject({bone:text,at:triple,halfLen:n,radius:n}))}),
+});
+const bodies:v.GenericSchema<unknown,BodyRows>=v.pipe(v.unknown(),v.check(input=>keysOnly(input,['file','bytes','attrs','skeletons','rows'])&&retainedBy(CompactSpeciesBodiesSchema,input)),v.intersect([CompactSpeciesBodiesSchema,
+ v.looseObject({skeletons:v.pipe(v.array(skeleton),v.maxLength(4096))})]));
+export interface SpeciesPoseRows {
+ prefix:string;group:string;scalars:NumericPoseRows['scalars'];states:NumericPoseRows['states'];
+ look?:NonNullable<NumericPoseRows['look']>;alive?:boolean;
+}
+const pose:v.GenericSchema<unknown,SpeciesPoseRows>=v.strictObject({prefix:v.string(),group:NumericPoseSchema.entries.group,
+ scalars:NumericPoseSchema.entries.scalars,states:NumericPoseSchema.entries.states,look:NumericPoseSchema.entries.look,alive:NumericPoseSchema.entries.alive});
+type GuestRows=Omit<CreatureGuestRows,'program'>&{program:v.InferOutput<typeof completeReturn>};
+const guest:v.GenericSchema<unknown,GuestRows>=v.pipe(v.unknown(),v.check(input=>keysOnly(input,['program','clock','playerKeys','memory','writes','states','sounds','attack','strike','strikeSound','length','piercing'])&&retainedBy(CreatureGuestSchema,input)),v.intersect([CreatureGuestSchema,v.looseObject({program:completeReturn})]));
+type LookBookRows=Omit<SpeciesPresentationRows['lookBook'],'program'>&{program:v.InferOutput<typeof completeReturn>};
+const lookBook:v.GenericSchema<unknown,LookBookRows>=v.pipe(v.unknown(),v.check(input=>keysOnly(input,['slug','rows','program'])&&retainedBy(SpeciesPresentationSchema.entries.lookBook,input)),v.intersect([SpeciesPresentationSchema.entries.lookBook,
+ v.looseObject({program:completeReturn})]));
+export interface CrowdFileViewRows extends v.InferOutput<typeof CrowdPresentationSchema> {channels?:[[string,string,string,string]]}
+const view:v.GenericSchema<unknown,CrowdFileViewRows>=v.strictObject({name:v.pipe(v.string(),v.minLength(1),v.maxLength(96)),
+ attributes:v.tuple([v.pipe(v.string(),v.regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/u))]),
+ channels:v.exactOptional(v.tuple([v.tuple([text,text,text,text])])),
+ wool:v.pipe(v.array(triple),v.minLength(1),v.maxLength(32)),hits:v.pipe(v.array(triple),v.minLength(1),v.maxLength(16)),
+ preyY:n,feetY:n,cullRadius:v.pipe(n,v.minValue(0)),
+ motion:v.strictObject({walk:v.tuple([n,v.pipe(n,v.minValue(0))]),
+  joints:v.pipe(v.array(v.tuple([n,n,n,n,n,n,n])),v.minLength(1),v.maxLength(64)),
+  movingBob:v.tuple([n,v.pipe(n,v.minValue(0)),n]),idleBob:v.tuple([n,n]),movingAt:v.pipe(n,v.minValue(0)),
+  deathPivot:triple,deathAngle:n,tint:v.tuple([n,n])}),
+});
+export interface CrowdFilePageRows {
+ slug:string;hull:string|null;guard?:v.InferOutput<typeof CrowdGuardSchema>;bounds:[number,number,number,number];
+ rows:v.InferOutput<typeof FlockSchema>[];view:CrowdFileViewRows;material:{rim:number;bands:number};
+}
+const page:v.GenericSchema<unknown,CrowdFilePageRows>=v.strictObject({slug:v.string(),hull:v.nullable(v.string()),guard:v.exactOptional(CrowdGuardSchema),
+ bounds:v.tuple([n,n,n,n]),rows:v.pipe(v.array(FlockSchema),v.maxLength(4096)),view,material:v.strictObject({rim:n,bands:n})});
+export interface SpeciesActorsFileRows {
+ species:{poses:Record<string,SpeciesPoseRows>;packedBodies:BodyRows;guest:GuestRows;lookBook:LookBookRows};
+ page:{world:CrowdFilePageRows;specimen:CrowdFilePageRows};draws:v.InferOutput<typeof FixedDrawRowsSchema>;
+ pivots:[number,number,number][];parts:string[];radius:number;
+}
+/** G1004: complete crowd pages, pose metadata, typed native guest and shared
+ * body skeletons, not an opaque page or a shared NumericPose child. Original
+ * species/module/fixed-draw/native body owners retain their independent checks. */
+const fileShape=v.strictObject({
+ species:v.strictObject({poses:v.pipe(v.record(text,pose),v.maxEntries(256)),packedBodies:bodies,guest,lookBook}),
+ page:v.strictObject({world:page,specimen:page}),draws:v.pipe(FixedDrawRowsSchema,v.length(1)),
+ pivots:v.pipe(v.array(triple),v.maxLength(32)),parts:v.pipe(v.array(v.string()),v.maxLength(32)),radius:n,
+});
+export const SpeciesActorsFileSchema:v.GenericSchema<unknown,SpeciesActorsFileRows>=v.pipe(v.unknown(),v.check(isJsonData),
+ v.check(input=>isJsonData(input)&&retainedBy(fileShape,input),'Complete file field retention'),fileShape);

package/src/format/speciesBookRows.ts

@@ -0,0 +1,84 @@
+import * as v from 'valibot';
+import { isJsonData } from './json.ts';
+import { ActorProjectionV2Schema } from './actorProjectionV2.ts';
+import { SpeciesSchema } from './speciesPrograms.ts';
+import { FixedDrawRowsSchema } from './fixedDraws.ts';
+import { RidingPresentationSchema } from './riding.ts';
+import { CreatureStrikeSchema } from './creatures.ts';
+import { SkinClipNameSchema } from './skinData.ts';
+import { SpeciesGroupSchema, DirectedSpeciesSchema, CompactSpeciesBodiesSchema } from './speciesLooks.ts';
+
+const guestNumber=v.pipe(v.number(),v.finite()),key=v.pipe(v.string(),v.minLength(1),v.maxLength(96),v.check(value=>!['__proto__','prototype','constructor'].includes(value)));
+/** The admitted guest owns every decision. Rows specify observation defaults,
+ * retained outputs and native contact/presentation resources. */
+export const CreatureGuestSchema: v.GenericSchema<CreatureGuestRowsInput, CreatureGuestRows> =v.pipe(v.unknown(),v.check(isJsonData),v.object({
+  program:v.unknown(),clock:key,playerKeys:v.tuple([key,key]),
+  memory:v.pipe(v.record(key,v.object({value:guestNumber,source:v.optional(v.picklist(['x','z','yaw'])),
+    when:v.optional(v.object({field:key,equal:guestNumber,value:guestNumber}))})),v.maxEntries(64)),
+  writes:v.pipe(v.array(key),v.maxLength(64)),states:v.pipe(v.array(key),v.maxLength(32)),sounds:v.pipe(v.array(v.string()),v.maxLength(32)),
+  attack:v.pipe(guestNumber,v.minValue(0)),strike:CreatureStrikeSchema,strikeSound:v.string(),length:v.tuple([guestNumber,v.pipe(guestNumber,v.minValue(.000001)),guestNumber]),
+  piercing:v.object({legacy:key,tags:v.pipe(v.array(key),v.maxLength(16)),equipment:v.pipe(v.array(key),v.maxLength(16))}),
+}));
+
+
+const text=v.pipe(v.string(),v.minLength(1),v.maxLength(4096)),number=v.pipe(v.number(),v.finite()),rgb=v.tuple([number,number,number]);
+/** A species borrows its existing arena-room brain; initialization is finite
+ * ordered data, before the same original think/act/damage slots. */
+export const ArenaRoomSpeciesControlSchema: v.GenericSchema<ArenaRoomSpeciesControlRowsInput, ArenaRoomSpeciesControlRows> =v.strictObject({kind:v.literal('arena-room'),
+  initialize:v.strictObject({flag:key,defaults:v.pipe(v.array(v.variant('source',[
+    v.strictObject({field:key,source:v.literal('value'),value:number}),
+    v.strictObject({field:key,source:v.literal('height')}),
+  ])),v.maxLength(64))}),
+});
+
+/** Build-only species catalogue admission. Native consumers import row types. */
+/** Packed body keys, rig contracts and painterly material measurements. */
+const book=v.object({slug:text,body:v.unknown(),poses:v.optional(v.record(text,v.unknown())),program:v.optional(v.unknown()),
+  rows:v.pipe(v.array(v.object({metadata:SpeciesSchema,id:text,family:text,
+    rigContract:v.object({skeleton:text,clips:v.array(SkinClipNameSchema),sockets:v.array(text)}),
+    rig:v.optional(v.picklist(['quadruped','custom'])),pose:v.optional(v.object({grazeNeck:number,gallopTail:number})),gait:v.optional(v.object({trot:number,gallop:number})),
+    eyeGlow:v.optional(rgb),eyeGlowIntensity:v.optional(number),
+    variants:v.record(text,v.object({body:text,tint:v.optional(v.record(text,rgb)),traits:v.optional(v.record(text,v.union([number,v.boolean()]))) })),
+    projection:v.exactOptional(ActorProjectionV2Schema),control:v.exactOptional(ArenaRoomSpeciesControlSchema),
+    group: v.optional(SpeciesGroupSchema), directed: v.optional(DirectedSpeciesSchema), guard: v.optional(v.literal(true)),
+    /** a named elite: its think / act / damage are the elite page's (game/quest/elitePage) */
+    elite: v.optional(v.literal(true)),
+    postPose: v.optional(v.strictObject({ alive: text, dead: v.exactOptional(text), envelopes: v.exactOptional(RidingPresentationSchema) })),
+    material:v.object({rim:number,bands:number}),
+  })),v.maxLength(256)),
+});
+
+export const SpeciesLookBookSchema: v.GenericSchema<SpeciesLookBookRowsInput, SpeciesLookBookRows> =v.pipe(v.unknown(),v.check(isJsonData),book);
+/** Complete packed metadata is checked before the native geometry owner allocates. */
+export const NativeSpeciesLookBookSchema: v.GenericSchema<NativeSpeciesLookBookRowsInput, NativeSpeciesLookBookRows> =v.pipe(v.unknown(),v.check(isJsonData),v.object({...book.entries,body:CompactSpeciesBodiesSchema}));
+
+const poseConfig=v.object({prefix:v.string(),group:v.string(),scalars:v.array(v.unknown()),look:v.exactOptional(v.unknown()),alive:v.exactOptional(v.boolean())});
+/** The existing named actors file retains its exact body and pose payload. */
+export const SpeciesPresentationSchema: v.ObjectSchema<{
+  readonly poses: v.GenericSchema<SpeciesPresentationRowsInput['poses'], SpeciesPresentationRows['poses']>;
+  readonly packedBodies: typeof CompactSpeciesBodiesSchema;
+  readonly guest: typeof CreatureGuestSchema;
+  readonly lookBook: v.GenericSchema<SpeciesPresentationRowsInput['lookBook'], SpeciesPresentationRows['lookBook']>;
+}, undefined> =v.object({poses:v.record(v.string(),poseConfig),packedBodies:CompactSpeciesBodiesSchema,guest:CreatureGuestSchema,lookBook:v.pick(book,['slug','rows','program'])});
+export const SpeciesActorsFileSchema: v.GenericSchema<SpeciesActorsFileRowsInput, SpeciesActorsFileRows> =v.strictObject({species:SpeciesPresentationSchema,
+  page:v.strictObject({world:v.unknown(),specimen:v.unknown()}),
+  draws:v.pipe(FixedDrawRowsSchema,v.length(1)),
+  pivots:v.pipe(v.array(v.tuple([number,number,number])),v.maxLength(32)),
+  parts:v.pipe(v.array(v.string()),v.maxLength(32)),radius:number,
+});
+
+
+
+/** Admitted species data, independent of validator implementation metadata. */
+export type CreatureGuestRowsInput = unknown;
+export interface CreatureGuestRows { program: unknown; clock: string; playerKeys: [string, string]; memory: Record<string, { value: number; source?: 'x' | 'z' | 'yaw' | undefined; when?: { field: string; equal: number; value: number; } | undefined; }>; writes: (string)[]; states: (string)[]; sounds: (string)[]; attack: number; strike: v.InferOutput<typeof CreatureStrikeSchema>; strikeSound: string; length: [number, number, number]; piercing: { legacy: string; tags: (string)[]; equipment: (string)[]; }; }
+export type ArenaRoomSpeciesControlRowsInput = ArenaRoomSpeciesControlRows;
+export interface ArenaRoomSpeciesControlRows { kind: 'arena-room'; initialize: { flag: string; defaults: (({ field: string; source: 'value'; value: number; }) | ({ field: string; source: 'height'; }))[]; }; }
+export type SpeciesLookBookRowsInput = unknown;
+export interface SpeciesLookBookRows { slug: string; body: unknown; poses?: Record<string, unknown> | undefined; program?: unknown; rows: ({ metadata: v.InferOutput<typeof SpeciesSchema>; id: string; family: string; rigContract: { skeleton: string; clips: (v.InferOutput<typeof SkinClipNameSchema>)[]; sockets: (string)[]; }; rig?: 'quadruped' | 'custom' | undefined; pose?: { grazeNeck: number; gallopTail: number; } | undefined; gait?: { trot: number; gallop: number; } | undefined; eyeGlow?: [number, number, number] | undefined; eyeGlowIntensity?: number | undefined; variants: Record<string, { body: string; tint?: Record<string, [number, number, number]> | undefined; traits?: Record<string, (number) | (boolean)> | undefined; }>; projection?: v.InferOutput<typeof ActorProjectionV2Schema>; control?: ArenaRoomSpeciesControlRows; group?: v.InferOutput<typeof SpeciesGroupSchema> | undefined; directed?: v.InferOutput<typeof DirectedSpeciesSchema> | undefined; guard?: true | undefined; elite?: true | undefined; postPose?: { alive: string; dead?: string; envelopes?: v.InferOutput<typeof RidingPresentationSchema>; } | undefined; material: { rim: number; bands: number; }; })[]; }
+export type NativeSpeciesLookBookRowsInput = unknown;
+export type NativeSpeciesLookBookRows = { body: v.InferOutput<typeof CompactSpeciesBodiesSchema>; } & { slug: string; body: unknown; poses?: Record<string, unknown> | undefined; program?: unknown; rows: ({ metadata: v.InferOutput<typeof SpeciesSchema>; id: string; family: string; rigContract: { skeleton: string; clips: (v.InferOutput<typeof SkinClipNameSchema>)[]; sockets: (string)[]; }; rig?: 'quadruped' | 'custom' | undefined; pose?: { grazeNeck: number; gallopTail: number; } | undefined; gait?: { trot: number; gallop: number; } | undefined; eyeGlow?: [number, number, number] | undefined; eyeGlowIntensity?: number | undefined; variants: Record<string, { body: string; tint?: Record<string, [number, number, number]> | undefined; traits?: Record<string, (number) | (boolean)> | undefined; }>; projection?: v.InferOutput<typeof ActorProjectionV2Schema>; control?: ArenaRoomSpeciesControlRows; group?: v.InferOutput<typeof SpeciesGroupSchema> | undefined; directed?: v.InferOutput<typeof DirectedSpeciesSchema> | undefined; guard?: true | undefined; elite?: true | undefined; postPose?: { alive: string; dead?: string; envelopes?: v.InferOutput<typeof RidingPresentationSchema>; } | undefined; material: { rim: number; bands: number; }; })[]; };
+export interface SpeciesPresentationRowsInput { poses: Record<string, { prefix: string; group: string; scalars: (unknown)[]; look?: unknown; alive?: boolean; }>; packedBodies: v.InferInput<typeof CompactSpeciesBodiesSchema>; guest: CreatureGuestRowsInput; lookBook: Pick<{ slug: string; body: unknown; poses?: Record<string, unknown> | undefined; program?: unknown; rows: ({ metadata: v.InferInput<typeof SpeciesSchema>; id: string; family: string; rigContract: { skeleton: string; clips: (v.InferInput<typeof SkinClipNameSchema>)[]; sockets: (string)[]; }; rig?: 'quadruped' | 'custom' | undefined; pose?: { grazeNeck: number; gallopTail: number; } | undefined; gait?: { trot: number; gallop: number; } | undefined; eyeGlow?: [number, number, number] | undefined; eyeGlowIntensity?: number | undefined; variants: Record<string, { body: string; tint?: Record<string, [number, number, number]> | undefined; traits?: Record<string, (number) | (boolean)> | undefined; }>; projection?: v.InferInput<typeof ActorProjectionV2Schema>; control?: ArenaRoomSpeciesControlRowsInput; group?: v.InferInput<typeof SpeciesGroupSchema> | undefined; directed?: v.InferInput<typeof DirectedSpeciesSchema> | undefined; guard?: true | undefined; elite?: true | undefined; postPose?: { alive: string; dead?: string; envelopes?: v.InferInput<typeof RidingPresentationSchema>; } | undefined; material: { rim: number; bands: number; }; })[]; }, 'slug' | 'rows' | 'program'>; }
+export interface SpeciesPresentationRows { poses: Record<string, { prefix: string; group: string; scalars: (unknown)[]; look?: unknown; alive?: boolean; }>; packedBodies: v.InferOutput<typeof CompactSpeciesBodiesSchema>; guest: CreatureGuestRows; lookBook: Pick<{ slug: string; body: unknown; poses?: Record<string, unknown> | undefined; program?: unknown; rows: ({ metadata: v.InferOutput<typeof SpeciesSchema>; id: string; family: string; rigContract: { skeleton: string; clips: (v.InferOutput<typeof SkinClipNameSchema>)[]; sockets: (string)[]; }; rig?: 'quadruped' | 'custom' | undefined; pose?: { grazeNeck: number; gallopTail: number; } | undefined; gait?: { trot: number; gallop: number; } | undefined; eyeGlow?: [number, number, number] | undefined; eyeGlowIntensity?: number | undefined; variants: Record<string, { body: string; tint?: Record<string, [number, number, number]> | undefined; traits?: Record<string, (number) | (boolean)> | undefined; }>; projection?: v.InferOutput<typeof ActorProjectionV2Schema>; control?: ArenaRoomSpeciesControlRows; group?: v.InferOutput<typeof SpeciesGroupSchema> | undefined; directed?: v.InferOutput<typeof DirectedSpeciesSchema> | undefined; guard?: true | undefined; elite?: true | undefined; postPose?: { alive: string; dead?: string; envelopes?: v.InferOutput<typeof RidingPresentationSchema>; } | undefined; material: { rim: number; bands: number; }; })[]; }, 'slug' | 'rows' | 'program'>; }
+export interface SpeciesActorsFileRowsInput { species: SpeciesPresentationRowsInput; page: { world: unknown; specimen: unknown; }; draws: v.InferInput<typeof FixedDrawRowsSchema>; pivots: ([number, number, number])[]; parts: (string)[]; radius: number; }
+export interface SpeciesActorsFileRows { species: SpeciesPresentationRows; page: { world: unknown; specimen: unknown; }; draws: v.InferOutput<typeof FixedDrawRowsSchema>; pivots: ([number, number, number])[]; parts: (string)[]; radius: number; }