@wildshard/shard-format 0.0.1 → 0.4.5

package/src/format/roamingBossProjection.ts

@@ -0,0 +1,178 @@
+import * as v from 'valibot';
+import { RoamingEncounterSchema } from './bossEncounter.ts';
+import { BossSocketRigSchema } from './bossSocketRig.ts';
+import { isJsonData } from './json.ts';
+
+const n = v.pipe(v.number(), v.finite()), id = v.pipe(v.string(), v.minLength(1), v.maxLength(256));
+const xyz = v.tuple([n, n, n]);
+/** Client-only roaming projection: native body/rig ids and declared channels. */
+export const RoamingBossProjectionSchema: v.GenericSchema<RoamingBossProjectionRowsInput, RoamingBossProjectionRows> = v.pipe(v.unknown(), v.check(isJsonData, 'Roaming projection requires JSON rows'), v.strictObject({
+  id, session: id, spawn: id, spawnStream: id, variant: id, socketRig: BossSocketRigSchema, encounter: RoamingEncounterSchema,
+  presentation: id, events: v.strictObject({ hit: id, open: id, shut: id, burst: id, land: id }), roar: id, landSound: id,
+  colours: v.strictObject({ tell: xyz, wave: xyz, puff: xyz }),
+  prewarm: v.pipe(v.array(v.strictObject({ kind: id, variant: id })), v.maxLength(8)),
+  fur: v.strictObject({ prewarm: n, parked: n }),
+  wall: v.strictObject({ look: id, alpha: id, colour: id, name: id, radius: n, bottom: n, height: n, segments: n, lift: n, order: n, seal: n, visible: n, colourGain: n }),
+  hazard: v.strictObject({ look: id, alpha: id, name: id, meshes: v.pipe(v.array(v.strictObject({ geometry: id, material: id })), v.maxLength(4)), scale: n, flameScale: xyz, order: n,
+    landingLift: n, arc: n, rotation: xyz, alphaBase: n, dark: n, radius: n, pulse: v.tuple([n, n, n]), width: n }),
+  light: v.strictObject({ colour: n, distance: n, decay: n, playerAbove: n, focusAbove: n, darkness: n,
+    playerColour: xyz, playerDistance: n, playerGain: n, focusColour: xyz, focusDistance: n, focusGain: n, focusOpen: v.tuple([n, n]) }),
+  room: v.strictObject({ density: v.tuple([n, n]), fog: v.tuple([n, n]), hemi: n, environment: n, dome: n, lights: n, domeUniforms: v.tuple([id, id]) }),
+  puffs: v.strictObject({ count: v.pipe(n, v.integer(), v.minValue(1), v.maxValue(16)), enter: v.tuple([n, n, n, n]), leave: v.tuple([n, n, n, n]), lift: n }),
+}), v.check(row => row.encounter.lanes.count <= 3 && row.socketRig.hazards.length <= 3, 'Existing client lane and hazard capacities'));
+
+
+/** Admitted data contracts, independent of validator implementation metadata. */
+export type RoamingBossProjectionRowsInput = unknown;
+interface RoamingBossProjectionRowsFields {
+    id: string;
+    session: string;
+    spawn: string;
+    spawnStream: string;
+    variant: string;
+    socketRig: v.InferOutput<typeof BossSocketRigSchema>;
+    encounter: v.InferOutput<typeof RoamingEncounterSchema>;
+    presentation: string;
+    events: {
+        hit: string;
+        open: string;
+        shut: string;
+        burst: string;
+        land: string;
+    };
+    roar: string;
+    landSound: string;
+    colours: {
+        tell: [
+            number,
+            number,
+            number
+        ];
+        wave: [
+            number,
+            number,
+            number
+        ];
+        puff: [
+            number,
+            number,
+            number
+        ];
+    };
+    prewarm: ({
+        kind: string;
+        variant: string;
+    })[];
+    fur: {
+        prewarm: number;
+        parked: number;
+    };
+    wall: {
+        look: string;
+        alpha: string;
+        colour: string;
+        name: string;
+        radius: number;
+        bottom: number;
+        height: number;
+        segments: number;
+        lift: number;
+        order: number;
+        seal: number;
+        visible: number;
+        colourGain: number;
+    };
+    hazard: {
+        look: string;
+        alpha: string;
+        name: string;
+        meshes: ({
+            geometry: string;
+            material: string;
+        })[];
+        scale: number;
+        flameScale: [
+            number,
+            number,
+            number
+        ];
+        order: number;
+        landingLift: number;
+        arc: number;
+        rotation: [
+            number,
+            number,
+            number
+        ];
+        alphaBase: number;
+        dark: number;
+        radius: number;
+        pulse: [
+            number,
+            number,
+            number
+        ];
+        width: number;
+    };
+    light: {
+        colour: number;
+        distance: number;
+        decay: number;
+        playerAbove: number;
+        focusAbove: number;
+        darkness: number;
+        playerColour: [
+            number,
+            number,
+            number
+        ];
+        playerDistance: number;
+        playerGain: number;
+        focusColour: [
+            number,
+            number,
+            number
+        ];
+        focusDistance: number;
+        focusGain: number;
+        focusOpen: [
+            number,
+            number
+        ];
+    };
+    room: {
+        density: [
+            number,
+            number
+        ];
+        fog: [
+            number,
+            number
+        ];
+        hemi: number;
+        environment: number;
+        dome: number;
+        lights: number;
+        domeUniforms: [
+            string,
+            string
+        ];
+    };
+    puffs: {
+        count: number;
+        enter: [
+            number,
+            number,
+            number,
+            number
+        ];
+        leave: [
+            number,
+            number,
+            number,
+            number
+        ];
+        lift: number;
+    };
+}
+export type RoamingBossProjectionRows = { [Key in keyof RoamingBossProjectionRowsFields]: RoamingBossProjectionRowsFields[Key] };

package/src/format/roamingCombat.ts

@@ -0,0 +1,22 @@
+import * as v from 'valibot';
+import { BossCombatSessionSchema, BossEncounterPresentationSchema } from './bossEncounter.ts';
+import { RoamingBossProjectionSchema } from './roamingBossProjection.ts';
+import { EliteEnteredPresentationSchema } from './eliteFeature.ts';
+import { isJsonData } from './json.ts';
+
+const n = v.pipe(v.number(), v.finite()), id = v.pipe(v.string(), v.minLength(1), v.maxLength(256));
+/** Client-only encounter session resolves its installed loadout and body ids. */
+export const RoamingCombatSchema: v.GenericSchema<RoamingCombatRowsInput, RoamingCombatRows> = v.pipe(v.unknown(), v.check(isJsonData, 'Combat composition requires JSON rows'), v.strictObject({
+  session: BossCombatSessionSchema, projection: RoamingBossProjectionSchema, presentation: BossEncounterPresentationSchema,
+  elitePresentation: EliteEnteredPresentationSchema,
+  loadout: id, elites: id, persistence: id, score: id, availability: n, dayScene: id, nightScene: id,
+  parked: v.strictObject({ name: id, y: n, finishes: v.pipe(v.array(id), v.maxLength(16)) }),
+  reward: v.strictObject({ finish: id, bowScale: n, bowPitch: n, trophy: id, count: n }),
+  tells: v.strictObject({ count: v.pipe(n, v.integer(), v.minValue(0), v.maxValue(3)), colour: v.tuple([n, n, n]), range: n, near: n, ahead: n,
+    width: n, scale: n, alpha: n, pulse: n, frequency: n }),
+  system: v.strictObject({ id, before: v.array(id) }), observers: v.strictObject({ elites: id, boss: id }),
+}));
+
+/** Admitted combat data, independent of validator implementation metadata. */
+export type RoamingCombatRowsInput = unknown;
+export interface RoamingCombatRows { session: v.InferOutput<typeof BossCombatSessionSchema>; projection: v.InferOutput<typeof RoamingBossProjectionSchema>; presentation: v.InferOutput<typeof BossEncounterPresentationSchema>; elitePresentation: v.InferOutput<typeof EliteEnteredPresentationSchema>; loadout: string; elites: string; persistence: string; score: string; availability: number; dayScene: string; nightScene: string; parked: { name: string; y: number; finishes: (string)[]; }; reward: { finish: string; bowScale: number; bowPitch: number; trophy: string; count: number; }; tells: { count: number; colour: [number, number, number]; range: number; near: number; ahead: number; width: number; scale: number; alpha: number; pulse: number; frequency: number; }; system: { id: string; before: (string)[]; }; observers: { elites: string; boss: string; }; }

package/src/format/ropeDeckSite.ts

@@ -0,0 +1,148 @@
+import * as v from 'valibot';
+import { SpecimenModelMetadataSchema } from './specimenCatalogue.ts';
+
+/** The defining rope-deck grammar, moved unchanged from the site host. */
+const id = v.pipe(v.string(), v.minLength(1), v.maxLength(128)), n = v.pipe(v.number(), v.finite());
+const xz = v.tuple([n, n]), point = v.object({ x: n, y: n, z: n });
+export const RopeDeckSpanSchema: v.GenericSchema<RopeDeckSpanInput, RopeDeckSpan> = v.strictObject({ a: xz, b: xz, sag: v.exactOptional(n), width: v.exactOptional(n) });
+/** a span's baked rest plan (its generator's row; fields the site does not read are ignored) */
+const rest: v.GenericSchema<RopeDeckRestInput, RopeDeckRest> = v.object({ key: id, ground: v.pipe(v.array(point), v.maxLength(256)), origin: point, width: n, len: n, direction: v.object({ x: n, z: n }),
+  segments: v.pipe(v.array(v.object({ x: n, y: n, z: n, hz: n, rot: v.object({ x: n, y: n, z: n, w: n }) })), v.maxLength(256)),
+  ownDescs: v.pipe(v.array(v.unknown()), v.maxLength(256)) });
+export const RopeDeckSiteSchema: v.GenericSchema<RopeDeckSiteRowsInput, RopeDeckSiteRows> = v.strictObject({
+  model: v.pick(SpecimenModelMetadataSchema, ['id', 'name', 'file', 'category', 'pipeline', 'surface']),
+  /** which baked span is the Explorer specimen's (flat ground), and the size of its loading stand-in */
+  specimen: v.pipe(v.number(), v.integer(), v.minValue(0)), loading: v.tuple([n, n, n]),
+  spans: v.pipe(v.array(rest), v.minLength(1), v.maxLength(8)),
+  /** the skinned deck's fixed draw slot for the specimen and for every other span */
+  draws: v.strictObject({ specimen: id, world: id }),
+  /** the deck's defaults (width, sag), segment half thickness and weight, bounds, hit owner and margin; its registry piece */
+  deck: v.strictObject({ width: n, sag: n, halfY: n, mass: n, maxSegments: v.pipe(v.number(), v.integer(), v.maxValue(256)),
+    maxColliders: v.pipe(v.number(), v.integer(), v.maxValue(256)), margin: n, owner: v.strictObject({ id, name: id }), piece: id }),
+});
+
+
+
+/** The original numeric bake-key tuple, shared with its runtime reader. */
+export const RopeDeckRestKeySchema: v.GenericSchema<RopeDeckRestKeyInput, RopeDeckRestKey> = v.tuple([xz, xz, n, n]);
+
+/** Admitted data contracts, independent of validator implementation metadata. */
+export type RopeDeckSpanInput = RopeDeckSpan;
+interface RopeDeckSpanFields {
+    a: [
+        number,
+        number
+    ];
+    b: [
+        number,
+        number
+    ];
+    sag?: number;
+    width?: number;
+}
+export type RopeDeckSpan = { [Key in keyof RopeDeckSpanFields]: RopeDeckSpanFields[Key] };
+export type RopeDeckRestInput = RopeDeckRest;
+interface RopeDeckRestFields {
+    key: string;
+    ground: ({
+        x: number;
+        y: number;
+        z: number;
+    })[];
+    origin: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    width: number;
+    len: number;
+    direction: {
+        x: number;
+        z: number;
+    };
+    segments: ({
+        x: number;
+        y: number;
+        z: number;
+        hz: number;
+        rot: {
+            x: number;
+            y: number;
+            z: number;
+            w: number;
+        };
+    })[];
+    ownDescs: (unknown)[];
+}
+export type RopeDeckRest = { [Key in keyof RopeDeckRestFields]: RopeDeckRestFields[Key] };
+interface RopeDeckSiteRowsInputFields {
+    model: Pick<v.InferInput<typeof SpecimenModelMetadataSchema>, 'id' | 'name' | 'file' | 'category' | 'pipeline' | 'surface'>;
+    specimen: number;
+    loading: [
+        number,
+        number,
+        number
+    ];
+    spans: (RopeDeckRestInput)[];
+    draws: {
+        specimen: string;
+        world: string;
+    };
+    deck: {
+        width: number;
+        sag: number;
+        halfY: number;
+        mass: number;
+        maxSegments: number;
+        maxColliders: number;
+        margin: number;
+        owner: {
+            id: string;
+            name: string;
+        };
+        piece: string;
+    };
+}
+export type RopeDeckSiteRowsInput = { [Key in keyof RopeDeckSiteRowsInputFields]: RopeDeckSiteRowsInputFields[Key] };
+interface RopeDeckSiteRowsFields {
+    model: Pick<v.InferOutput<typeof SpecimenModelMetadataSchema>, 'id' | 'name' | 'file' | 'category' | 'pipeline' | 'surface'>;
+    specimen: number;
+    loading: [
+        number,
+        number,
+        number
+    ];
+    spans: (RopeDeckRest)[];
+    draws: {
+        specimen: string;
+        world: string;
+    };
+    deck: {
+        width: number;
+        sag: number;
+        halfY: number;
+        mass: number;
+        maxSegments: number;
+        maxColliders: number;
+        margin: number;
+        owner: {
+            id: string;
+            name: string;
+        };
+        piece: string;
+    };
+}
+export type RopeDeckSiteRows = { [Key in keyof RopeDeckSiteRowsFields]: RopeDeckSiteRowsFields[Key] };
+export type RopeDeckRestKeyInput = RopeDeckRestKey;
+export type RopeDeckRestKey = [
+    [
+        number,
+        number
+    ],
+    [
+        number,
+        number
+    ],
+    number,
+    number
+];

package/src/format/rows.ts

@@ -0,0 +1,86 @@
+import { LootEconomySchema, BarterEconomySchema, lootEconomyRules } from './lootEconomy.ts';
+import * as v from 'valibot';
+import { isJsonData } from './json.ts';
+import { sketchReference } from './sketch.ts';
+import { JournalRowSchema, journalRowRules } from './compendiumRows.ts';
+
+const id = v.pipe(v.string(), v.regex(/^[a-z][a-zA-Z0-9.:-]*$/u), v.maxLength(128));
+const text = v.pipe(v.string(), v.maxLength(4096));
+const finite = v.pipe(v.number(), v.finite());
+const positive = v.pipe(finite, v.minValue(0.000001), v.maxValue(10000000));
+const nonnegative = v.pipe(finite, v.minValue(0), v.maxValue(10000000));
+const unit = v.pipe(finite, v.minValue(0), v.maxValue(1));
+const dimension = v.pipe(positive, v.maxValue(20));
+const duration = v.pipe(positive, v.maxValue(86400));
+const ordered = v.pipe(v.tuple([positive, positive]), v.check(([a, b]) => a <= b, 'ordered range'));
+const shape = v.variant('kind', [
+  v.strictObject({ kind: v.literal('point'), radius: dimension }), v.strictObject({ kind: v.literal('sphere'), radius: dimension }),
+  v.strictObject({ kind: v.literal('lane'), length: dimension, width: dimension }),
+  v.strictObject({ kind: v.literal('arc'), radius: dimension, halfAngle: v.pipe(positive, v.maxValue(Math.PI)) }),
+  v.strictObject({ kind: v.literal('wedge'), length: dimension, halfAngle: v.pipe(positive, v.maxValue(Math.PI)) }),
+  v.pipe(v.strictObject({ kind: v.literal('ring'), inner: nonnegative, outer: dimension }), v.check((r) => r.inner <= r.outer, 'ordered ring')),
+]);
+const strike: v.StrictObjectSchema<{ readonly id: v.GenericSchema<StrikeRowsInput['id'], StrikeRows['id']>; readonly shape: v.GenericSchema<StrikeRowsInput['shape'], StrikeRows['shape']>; readonly windup: v.GenericSchema<StrikeRowsInput['windup'], StrikeRows['windup']>; readonly active: v.GenericSchema<StrikeRowsInput['active'], StrikeRows['active']>; readonly recover: v.GenericSchema<StrikeRowsInput['recover'], StrikeRows['recover']>; readonly cooldown: v.GenericSchema<StrikeRowsInput['cooldown'], StrikeRows['cooldown']>; readonly range: v.GenericSchema<StrikeRowsInput['range'], StrikeRows['range']>; readonly damage: v.GenericSchema<StrikeRowsInput['damage'], StrikeRows['damage']>; readonly tags: v.SchemaWithPipe<readonly [v.ArraySchema<v.GenericSchema<`${string}.${string}`>, undefined>, v.MaxLengthAction<StrikeRows['tags'], 32, undefined>]>; readonly weight: v.GenericSchema<StrikeRowsInput['weight'], StrikeRows['weight']>; readonly speed: v.GenericSchema<StrikeRowsInput['speed'], StrikeRows['speed']>; }, undefined> = v.strictObject({ id, shape, windup: nonnegative, active: nonnegative, recover: nonnegative, cooldown: nonnegative, range: dimension, damage: nonnegative,
+  tags: v.pipe(v.array(v.custom<`${string}.${string}`>((value) => typeof value === 'string' && value.length <= 128 && /^[a-z][a-zA-Z0-9.-]*\.[a-zA-Z0-9.-]+$/u.test(value))), v.maxLength(32)), weight: nonnegative, speed: v.pipe(nonnegative, v.maxValue(15)) });
+const numbers = v.strictObject({ overcast: unit, rain: unit, wet: unit, wind: unit, fog: unit });
+const weather = v.strictObject({ id, states: v.pipe(v.array(v.strictObject({ id, next: id, length: ordered, numbers })), v.minLength(1), v.maxLength(64)), initial: numbers, soak: unit, dry: unit,
+  modes: v.pipe(v.array(v.strictObject({ id, hold: v.nullable(id), at: unit, dry: v.boolean() })), v.maxLength(64)) });
+const hour = v.pipe(finite, v.minValue(0), v.maxValue(24));
+const day = v.strictObject({ id, units: v.literal('hour'), start: hour,
+  schedule: v.pipe(v.array(v.strictObject({ phase: v.picklist(['dawn', 'day', 'golden', 'dusk', 'night']), from: hour, to: hour, minutes: duration })), v.minLength(1), v.maxLength(64)),
+  sun: v.strictObject({ maxElevation: v.pipe(finite, v.minValue(0), v.maxValue(90)), azimuthOffset: v.pipe(finite, v.minValue(-180), v.maxValue(180)) }),
+  fixed: v.strictObject({ midday: hour, golden: hour, sunset: hour, night: hour }), presets: v.strictObject({ dawn: hour, noon: hour, dusk: hour, night: hour }) });
+const mods = v.strictObject({ speed: positive, chargeDist: positive, damageTaken: positive, chargeDamage: nonnegative, relentless: v.boolean() });
+const dims = v.strictObject({ bodyY: dimension, bodyHalfLen: dimension, bodyRadius: dimension, headRadius: dimension, legLen: dimension,
+  feet: v.pipe(v.array(v.tuple([finite, finite])), v.maxLength(16)), halfWidth: dimension });
+const variant = v.strictObject({ id, label: text, rarity: v.picklist(['common', 'uncommon', 'rare', 'legendary']), weight: nonnegative, scale: ordered, hp: positive, mods });
+const flight = v.strictObject({ altitude: v.pipe(finite, v.minValue(-250), v.maxValue(250)),
+  above: v.exactOptional(v.picklist(['ground', 'world'])), climbRate: v.pipe(positive, v.maxValue(30)), diveRate: v.pipe(positive, v.maxValue(30)),
+  lockRange: v.exactOptional(v.pipe(positive, v.maxValue(600))), bank: v.exactOptional(v.pipe(finite, v.check(n => n > 0 && n < Math.PI / 2, 'flight bank between 0 and pi/2'))) });
+const species = v.strictObject({ id, kind: id, label: text, aggressive: v.boolean(), lockable: v.boolean(), dims, flight: v.exactOptional(flight),
+  variants: v.pipe(v.array(variant), v.minLength(1), v.maxLength(64)) });
+const parameter = v.union([finite, v.boolean(), text, v.pipe(v.array(finite), v.maxLength(16))]);
+const look = v.strictObject({ id, species: id, recipe: id, material: v.optional(v.nullable(id), null), parameters: v.record(id, parameter),
+  animation: v.strictObject({ recipe: id, parameters: v.record(id, parameter) }) });
+const basicCompendium = v.strictObject({ id, className: id, title: text, tabs: v.pipe(v.array(v.strictObject({ id, label: text })), v.maxLength(16)), stamp: text,
+  stats: v.pipe(v.array(v.strictObject({ label: text, value: text })), v.maxLength(8)),
+  entries: v.pipe(v.array(v.strictObject({ id, kind: v.literal('species'), tab: id, name: text, notes: text, sketch: v.pipe(text, v.check(sketchReference, 'bounded inert SVG data or admitted sketch hash')), species: id })), v.maxLength(256)) });
+const loot = v.union([
+  v.strictObject({ id, gear: v.literal('purse.coins'), finds: v.null(), marks: v.null(), charted: v.boolean(), chime: id, economy: v.exactOptional(LootEconomySchema) }),
+  v.strictObject({ id, economy: BarterEconomySchema }),
+]);
+const raw: v.StrictObjectSchema<{ readonly strikes: v.SchemaWithPipe<readonly [v.ArraySchema<typeof strike, undefined>, v.MaxLengthAction<ShardRows['strikes'], 256, undefined>]>; readonly weather: v.GenericSchema<ShardRowsInput['weather'], ShardRows['weather']>; readonly days: v.GenericSchema<ShardRowsInput['days'], ShardRows['days']>; readonly species: v.GenericSchema<ShardRowsInput['species'], ShardRows['species']>; readonly looks: v.GenericSchema<ShardRowsInput['looks'], ShardRows['looks']>; readonly compendiums: v.GenericSchema<ShardRowsInput['compendiums'], ShardRows['compendiums']>; readonly loot: v.GenericSchema<ShardRowsInput['loot'], ShardRows['loot']>; }, undefined> = v.strictObject({ strikes: v.pipe(v.array(strike), v.maxLength(256)), weather: v.pipe(v.array(weather), v.maxLength(16)), days: v.pipe(v.array(day), v.maxLength(16)),
+  species: v.pipe(v.array(species), v.maxLength(256)), looks: v.pipe(v.array(look), v.maxLength(256)), compendiums: v.pipe(v.array(v.union([basicCompendium, JournalRowSchema])), v.maxLength(16)), loot: v.pipe(v.array(loot), v.maxLength(16)) });
+/** Pure author rows: numeric weights, state output tables, clocks and registered view/presentation recipes. */
+
+/** Reference, uniqueness and complete clock/weather transition rules for data rows. */
+export function rowRules(rows: ShardRows): string[] {
+  const errors: string[] = [];
+  for (const list of Object.values(rows)) if (new Set(list.map((r) => r.id)).size !== list.length) errors.push('unique row ids');
+  for (const row of rows.loot) if (row.economy !== undefined && !('kind' in row.economy)) errors.push(...lootEconomyRules(row.economy));
+  for (const w of rows.weather) {
+    const states = new Set(w.states.map((s) => s.id));
+    if (states.size !== w.states.length || w.states.some((s) => !states.has(s.next)) || w.modes.some((m) => m.hold !== null && !states.has(m.hold)) || new Set(w.modes.map((m) => m.id)).size !== w.modes.length) errors.push('weather states and transitions');
+  }
+  for (const d of rows.days) if (d.schedule[0]?.from !== 0 || d.schedule.at(-1)?.to !== 24 || d.schedule.some((s, i) => s.from >= s.to || (i > 0 && d.schedule[i - 1]?.to !== s.from))) errors.push('complete ordered day schedule');
+  const speciesIds = new Set(rows.species.map((s) => s.id));
+  for (const s of rows.species) if (new Set(s.variants.map((r) => r.id)).size !== s.variants.length || s.variants.some((r) => r.scale[1] > 10)) errors.push('species variants');
+  for (const l of rows.looks) if (!speciesIds.has(l.species)) errors.push('look species');
+  for (const c of rows.compendiums) {
+    if ('kind' in c) { errors.push(...journalRowRules(c)); continue; }
+    const tabs = new Set(c.tabs.map((t) => t.id));
+    if (tabs.size !== c.tabs.length || new Set(c.entries.map((e) => e.id)).size !== c.entries.length || c.entries.some((e) => !tabs.has(e.tab) || !speciesIds.has(e.species))) errors.push('compendium references');
+  }
+  return errors;
+}
+/** The independent JSON check runs before strict row schemas; functions/accessors/cycles never become data. */
+export const RowsSchema: v.SchemaWithPipe<readonly [v.UnknownSchema, v.CheckAction<unknown, 'JSON-only rows'>, typeof raw, v.CheckAction<ShardRows, 'row reference rules'>]> = v.pipe(v.unknown(), v.check(isJsonData, 'JSON-only rows'), raw, v.check((rows) => rowRules(rows).length === 0, 'row reference rules'));
+/** Validate rows at the author boundary, before JSON serialization can erase closures. */
+export function parseRows(input: unknown): ShardRows { return v.parse(RowsSchema, input); }
+
+/** Admitted author data independent of validator implementation metadata. */
+export type StrikeRowsInput = StrikeRows;
+export interface StrikeRows { id: string; shape: ({ kind: 'point'; radius: number; }) | ({ kind: 'sphere'; radius: number; }) | ({ kind: 'lane'; length: number; width: number; }) | ({ kind: 'arc'; radius: number; halfAngle: number; }) | ({ kind: 'wedge'; length: number; halfAngle: number; }) | ({ kind: 'ring'; inner: number; outer: number; }); windup: number; active: number; recover: number; cooldown: number; range: number; damage: number; tags: (`${string}.${string}`)[]; weight: number; speed: number; }
+export interface ShardRowsInput { strikes: (StrikeRowsInput)[]; weather: ({ id: string; states: ({ id: string; next: string; length: [number, number]; numbers: { overcast: number; rain: number; wet: number; wind: number; fog: number; }; })[]; initial: { overcast: number; rain: number; wet: number; wind: number; fog: number; }; soak: number; dry: number; modes: ({ id: string; hold: (string) | null; at: number; dry: boolean; })[]; })[]; days: ({ id: string; units: 'hour'; start: number; schedule: ({ phase: 'dawn' | 'day' | 'golden' | 'dusk' | 'night'; from: number; to: number; minutes: number; })[]; sun: { maxElevation: number; azimuthOffset: number; }; fixed: { midday: number; golden: number; sunset: number; night: number; }; presets: { dawn: number; noon: number; dusk: number; night: number; }; })[]; species: ({ id: string; kind: string; label: string; aggressive: boolean; lockable: boolean; dims: { bodyY: number; bodyHalfLen: number; bodyRadius: number; headRadius: number; legLen: number; feet: ([number, number])[]; halfWidth: number; }; flight?: { altitude: number; above?: 'ground' | 'world'; climbRate: number; diveRate: number; lockRange?: number; bank?: number; }; variants: ({ id: string; label: string; rarity: 'common' | 'uncommon' | 'rare' | 'legendary'; weight: number; scale: [number, number]; hp: number; mods: { speed: number; chargeDist: number; damageTaken: number; chargeDamage: number; relentless: boolean; }; })[]; })[]; looks: ({ id: string; species: string; recipe: string; material?: (string) | null | undefined; parameters: Record<string, (number) | (boolean) | (string) | ((number)[])>; animation: { recipe: string; parameters: Record<string, (number) | (boolean) | (string) | ((number)[])>; }; })[]; compendiums: (({ id: string; className: string; title: string; tabs: ({ id: string; label: string; })[]; stamp: string; stats: ({ label: string; value: string; })[]; entries: ({ id: string; kind: 'species'; tab: string; name: string; notes: string; sketch: string; species: string; })[]; }) | (v.InferInput<typeof JournalRowSchema>))[]; loot: (({ id: string; gear: 'purse.coins'; finds: null; marks: null; charted: boolean; chime: string; economy?: v.InferInput<typeof LootEconomySchema>; }) | ({ id: string; economy: v.InferInput<typeof BarterEconomySchema>; }))[]; }
+// oxlint-disable-next-line typescript/consistent-type-definitions -- Object.values needs the original implicit dictionary contract for row validation.
+export type ShardRows = { strikes: (StrikeRows)[]; weather: ({ id: string; states: ({ id: string; next: string; length: [number, number]; numbers: { overcast: number; rain: number; wet: number; wind: number; fog: number; }; })[]; initial: { overcast: number; rain: number; wet: number; wind: number; fog: number; }; soak: number; dry: number; modes: ({ id: string; hold: (string) | null; at: number; dry: boolean; })[]; })[]; days: ({ id: string; units: 'hour'; start: number; schedule: ({ phase: 'dawn' | 'day' | 'golden' | 'dusk' | 'night'; from: number; to: number; minutes: number; })[]; sun: { maxElevation: number; azimuthOffset: number; }; fixed: { midday: number; golden: number; sunset: number; night: number; }; presets: { dawn: number; noon: number; dusk: number; night: number; }; })[]; species: ({ id: string; kind: string; label: string; aggressive: boolean; lockable: boolean; dims: { bodyY: number; bodyHalfLen: number; bodyRadius: number; headRadius: number; legLen: number; feet: ([number, number])[]; halfWidth: number; }; flight?: { altitude: number; above?: 'ground' | 'world'; climbRate: number; diveRate: number; lockRange?: number; bank?: number; }; variants: ({ id: string; label: string; rarity: 'common' | 'uncommon' | 'rare' | 'legendary'; weight: number; scale: [number, number]; hp: number; mods: { speed: number; chargeDist: number; damageTaken: number; chargeDamage: number; relentless: boolean; }; })[]; })[]; looks: ({ id: string; species: string; recipe: string; material: (string) | null; parameters: Record<string, (number) | (boolean) | (string) | ((number)[])>; animation: { recipe: string; parameters: Record<string, (number) | (boolean) | (string) | ((number)[])>; }; })[]; compendiums: (({ id: string; className: string; title: string; tabs: ({ id: string; label: string; })[]; stamp: string; stats: ({ label: string; value: string; })[]; entries: ({ id: string; kind: 'species'; tab: string; name: string; notes: string; sketch: string; species: string; })[]; }) | (v.InferOutput<typeof JournalRowSchema>))[]; loot: (({ id: string; gear: 'purse.coins'; finds: null; marks: null; charted: boolean; chime: string; economy?: v.InferOutput<typeof LootEconomySchema>; }) | ({ id: string; economy: v.InferOutput<typeof BarterEconomySchema>; }))[]; };

package/src/format/runtime.ts

@@ -0,0 +1,38 @@
+import * as v from 'valibot';
+import { RuntimeCostSchema, runtimeAccountedBytes } from './runtimeCost.ts';
+import { RuntimeBindsSchema } from './runtimeBinds.ts';
+import { RuntimeSpawnsSchema } from './runtimeSpawns.ts';
+
+const cost = v.pipe(RuntimeCostSchema, v.check((row) => {
+  try { runtimeAccountedBytes(row); return true; } catch { return false; }
+}, 'Runtime cost must contain a positive safe measured content bound'));
+
+/** A compiled client-plan owner keeps its actual binds, spawns and measured cost,
+ * without naming any TypeScript module or introducing another loader registry. */
+export const ClientPlanRuntimeSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{ readonly kind: v.GenericSchema<ClientPlanRuntimeRowsInput['kind'], ClientPlanRuntimeRows['kind']>; readonly cost: v.GenericSchema<ClientPlanRuntimeRowsInput['cost'], ClientPlanRuntimeRows['cost']>; readonly binds: v.GenericSchema<ClientPlanRuntimeRowsInput['binds'], ClientPlanRuntimeRows['binds']>; readonly spawns: v.OptionalSchema<v.GenericSchema<Exclude<ClientPlanRuntimeRowsInput['spawns'], undefined>, Exclude<ClientPlanRuntimeRows['spawns'], undefined>>, undefined>; }, undefined>, v.CheckAction<{ [K in keyof ClientPlanRuntimeRows]: ClientPlanRuntimeRows[K] }, 'runtime spawns are declared exactly when runtime.binds names spawns'>]> = v.pipe(v.strictObject({
+  kind: v.literal('client-plan'), cost, binds: RuntimeBindsSchema,
+  spawns: v.optional(RuntimeSpawnsSchema),
+}), v.check(row => (row.spawns !== undefined) === row.binds.includes('spawns'),
+  'runtime spawns are declared exactly when runtime.binds names spawns'));
+/** A shard's runtime declaration: only the compiled client plan (LD9 retired the copied-runtime `entry` arm). */
+export const RuntimeSchema: v.GenericSchema<RuntimeDeclarationInput, RuntimeDeclaration> = ClientPlanRuntimeSchema;
+/** Serializable runtime ownership, independent of its compiled or legacy constructor. */
+
+
+/** Admitted data contracts, independent of validator implementation metadata. */
+interface ClientPlanRuntimeRowsInputFields {
+    kind: 'client-plan';
+    cost: v.InferInput<typeof RuntimeCostSchema>;
+    binds: v.InferInput<typeof RuntimeBindsSchema>;
+    spawns?: v.InferInput<typeof RuntimeSpawnsSchema> | undefined;
+}
+export type ClientPlanRuntimeRowsInput = { [Key in keyof ClientPlanRuntimeRowsInputFields]: ClientPlanRuntimeRowsInputFields[Key] };
+interface ClientPlanRuntimeRowsFields {
+    kind: 'client-plan';
+    cost: v.InferOutput<typeof RuntimeCostSchema>;
+    binds: v.InferOutput<typeof RuntimeBindsSchema>;
+    spawns?: v.InferOutput<typeof RuntimeSpawnsSchema> | undefined;
+}
+export type ClientPlanRuntimeRows = { [Key in keyof ClientPlanRuntimeRowsFields]: ClientPlanRuntimeRowsFields[Key] };
+export type RuntimeDeclarationInput = ClientPlanRuntimeRowsInput;
+export type RuntimeDeclaration = ClientPlanRuntimeRows;

package/src/format/runtimeBinds.ts

@@ -0,0 +1,49 @@
+import type { Shardfile } from './shardSchema.ts';
+import * as v from 'valibot';
+
+/**
+ * The behaviour sections a trusted hybrid runtime may bind (SHARD-PLATFORM M3, the runtime-owner binding, E435). A hybrid
+ * shard's runtime owns its world and its play scope; a section named here stays declared data in the shardfile, validated
+ * like every row, and the platform installs it into that runtime's play scope through the same installers the template
+ * uses (`@wildshard/game/shardfile/hybridRows`). The data client never installs a bound section a second time, and a bound
+ * section's rows do not make a hybrid shardfile "non-empty": only an unbound behaviour row sends a hybrid shard down the
+ * full shardfile loader.
+ *
+ * - `quests`: quest graphs, flags and dialogue; the runtime supplies its flags and places world-piece markers.
+ * - `ledger`: fact → profile reward rules; the runtime emits declared facts, the platform grants once.
+ * - `items`: weapon / tool rows, input contexts and the loadout; the runtime may resolve a family of its own
+ *   (`<slug>.<name>`) beside the kit's, and the declared input contexts register through its entered-input path.
+ * - `spawns`: the runtime's creatures as declared rows (`runtime.spawns`, ./runtimeSpawns.ts): its homes and boss bodies,
+ *   each under a stable identity; the platform keeps the homes (respawn, retained identity), the runtime's species and
+ *   encounter scripts stay its own.
+ * - `state`: host-owned shared scalar fields (including bounded JSON strings), migrated once from legacy slots and
+ *   persisted by the platform under the stable instance id; player/public fields remain simulation-owned. Its numeric
+ *   host fields may drive `look.curves` (the runtime hands the data client their live values, G345).
+ * - `modes`: validated traversal parameters consumed by the native player owner at its existing update phase.
+ *   The data client never installs a second traversal owner.
+ * - `movers`: admitted fixed-step motion is installed once by the resident runtime.
+ *   Its Wasm roots remain verified product files and never create a data-client host.
+ * - `clientChannels`: copied clock/state observations and bounded straight-line numeric expressions; the runtime
+ *   binds private visual targets, never authoritative state or player objects.
+ * - `terrain`: a trusted runtime owns the terrain queries and draw construction. The data client omits those rows;
+ *   unbound drawn tiles use the page's shared tile streamer. Edge rows remain platform data.
+ * - `loot`: the trusted runtime consumes the original economy rows; only the secondary data client omits them.
+ * - `props` (G227): the compiled props section (tiles, library models, panels, far proxy), bound the same way; the
+ *   runtime keeps the behaviour of the pieces it dresses.
+ */
+export const RUNTIME_BOUND_SECTIONS = ['quests', 'ledger', 'items', 'spawns', 'state', 'terrain', 'props', 'modes', 'clientChannels', 'movers', 'loot'] as const;
+/** One section a trusted runtime binds rather than the data client. */
+export type RuntimeBoundSection = (typeof RUNTIME_BOUND_SECTIONS)[number];
+/** `runtime.binds`: the declared capability that replaces the implicit "empty apart from audio, edges and colliders" rule. */
+export const RuntimeBindsSchema: v.GenericSchema<RuntimeBindsRowsInput, RuntimeBindsRows> = v.pipe(v.array(v.picklist(RUNTIME_BOUND_SECTIONS)), v.maxLength(RUNTIME_BOUND_SECTIONS.length),
+  v.check((sections) => new Set(sections).size === sections.length, 'unique runtime-bound sections'));
+
+/** Typed page declarations select a data owner; disk admission must also prove
+ * that its complete compiled client plan and native program are present. */
+export function hasDeclaredClientPage(source: Partial<Pick<Shardfile, 'runtime' | 'questHost'>>): boolean {
+  return source.runtime === null && source.questHost?.page !== undefined && 'version' in source.questHost.page;
+}
+
+/** Admitted data contracts, independent of validator implementation metadata. */
+export type RuntimeBindsRowsInput = RuntimeBindsRows;
+export type RuntimeBindsRows = ((typeof RUNTIME_BOUND_SECTIONS)[number])[];

package/src/format/runtimeCost.ts

@@ -0,0 +1,80 @@
+import * as v from 'valibot';
+import { RUNTIME_RESIDENT_FACTOR } from './wireLimits.ts';
+
+const mb = v.pipe(v.number(), v.finite(), v.minValue(0));
+/** Reviewed trusted-runtime measurements, kept with their shard rather than presenting an empty data budget as its cost. */
+export const MemoryMeasurementSchema: v.StrictObjectSchema<{ readonly webContentMB: v.GenericSchema<MemoryMeasurementRowsInput['webContentMB'], MemoryMeasurementRows['webContentMB']>; readonly glMB: v.GenericSchema<MemoryMeasurementRowsInput['glMB'], MemoryMeasurementRows['glMB']>; readonly engineBaseMB: v.GenericSchema<MemoryMeasurementRowsInput['engineBaseMB'], MemoryMeasurementRows['engineBaseMB']>; readonly residentBaseMB: v.ExactOptionalSchema<v.GenericSchema<Exclude<MemoryMeasurementRowsInput['residentBaseMB'], undefined>, Exclude<MemoryMeasurementRows['residentBaseMB'], undefined>>, undefined>; readonly rev: v.GenericSchema<MemoryMeasurementRowsInput['rev'], MemoryMeasurementRows['rev']>; readonly device: v.GenericSchema<MemoryMeasurementRowsInput['device'], MemoryMeasurementRows['device']>; readonly evidence: v.GenericSchema<MemoryMeasurementRowsInput['evidence'], MemoryMeasurementRows['evidence']>; }, undefined> = v.strictObject({
+  webContentMB: mb, glMB: mb, engineBaseMB: mb,
+  /** Matched settled pre-entry resident set. When present, subtract it instead of the dated engine-only calibration. */
+  residentBaseMB: v.exactOptional(mb),
+  rev: v.pipe(v.string(), v.regex(/^[a-f0-9]{9,40}$/u)),
+  device: v.pipe(v.string(), v.minLength(1), v.maxLength(200)),
+  evidence: v.pipe(v.string(), v.regex(/^progress\/memory\/[a-zA-Z0-9/_-]+\.json$/u)),
+});
+/** The current runtime measurement may retain its separate images-first reading for cold phone texture selection. */
+export const RuntimeCostSchema: v.GenericSchema<RuntimeCostInput, RuntimeCost> = v.strictObject({ ...MemoryMeasurementSchema.entries, imagesFirst: v.optional(MemoryMeasurementSchema) });
+/** Decimal MB; GL bytes accompany WebContent, never the GPU process as a replacement. */
+
+
+/**
+ * SF22a / G144 / G258: remove the matched resident baseline (or legacy engine base) and undo the allocator's calibration exactly once. The allocator adds
+ * its current engine base and applies residentFactor when this home claim joins libraries, neighbours and the platform.
+ * Round upward to whole bytes; no computed cost is stored in the shardfile. Refuse measurements without content.
+ */
+export function runtimeAccountedBytes(input: unknown): number {
+  const row = v.parse(RuntimeCostSchema, input);
+  const baseline = row.residentBaseMB ?? row.engineBaseMB;
+  if (baseline < row.engineBaseMB) throw new RangeError('Runtime resident baseline must include its engine base');
+  const measured = (row.webContentMB + row.glMB - baseline) * 1_000_000;
+  if (measured <= 0) throw new RangeError('Runtime measurement must exceed its resident baseline');
+  const bytes = Math.ceil(measured / RUNTIME_RESIDENT_FACTOR);
+  if (!Number.isSafeInteger(bytes)) throw new RangeError('Runtime measurement exceeds safe resident accounting');
+  return bytes;
+}
+
+/**
+ * SF57: a reviewed reading of what one admitted regional shardfile sim really keeps resident (JS heap, its buffers and its
+ * share of Rapier's linear memory, the generated ground included; its checkpoint basis is charged separately as
+ * `sim-basis:`). The declared `budgets.sim.resident` stays the validated authoring ceiling (scripts at their growth limit);
+ * this row only replaces the ceiling in the allocator's charge, and never raises it.
+ */
+export const RegionalSimCostSchema: v.GenericSchema<RegionalSimCostInput, RegionalSimCost> = v.strictObject({
+  residentMB: v.pipe(mb, v.minValue(0.001)),
+  rev: v.pipe(v.string(), v.regex(/^[a-f0-9]{9,40}$/u)),
+  device: v.pipe(v.string(), v.minLength(1), v.maxLength(200)),
+  evidence: v.pipe(v.string(), v.regex(/^progress\/memory\/[a-zA-Z0-9/_-]+\.json$/u)),
+});
+/** Decimal MB, measured per admitted regional sim. */
+
+
+
+/** Admitted data contracts, independent of validator implementation metadata. */
+export type MemoryMeasurementRowsInput = MemoryMeasurementRows;
+interface MemoryMeasurementRowsFields {
+    webContentMB: number;
+    glMB: number;
+    engineBaseMB: number;
+    residentBaseMB?: number;
+    rev: string;
+    device: string;
+    evidence: string;
+}
+export type MemoryMeasurementRows = { [Key in keyof MemoryMeasurementRowsFields]: MemoryMeasurementRowsFields[Key] };
+export type RuntimeCostInput = Omit<MemoryMeasurementRowsInput, keyof ({
+    imagesFirst?: MemoryMeasurementRowsInput | undefined;
+})> & {
+    imagesFirst?: MemoryMeasurementRowsInput | undefined;
+};
+export type RuntimeCost = Omit<MemoryMeasurementRows, keyof ({
+    imagesFirst?: MemoryMeasurementRows | undefined;
+})> & {
+    imagesFirst?: MemoryMeasurementRows | undefined;
+};
+export type RegionalSimCostInput = RegionalSimCost;
+interface RegionalSimCostFields {
+    residentMB: number;
+    rev: string;
+    device: string;
+    evidence: string;
+}
+export type RegionalSimCost = { [Key in keyof RegionalSimCostFields]: RegionalSimCostFields[Key] };