@series-inc/rundot-syncplay 5.26.0-beta.6 → 5.26.0-beta.7

package/README.md

@@ -7,6 +7,123 @@ streams, stepping, opaque checkpoints, serialization, hydration, and checksums.
 Syncplay owns inputs, prediction, confirmation, rollback policy, replay logs,
 late join, secrets, and transport.
 
+## Game module entrypoints
+
+Generic game-layer modules use explicit `./modules/*` package subpaths. The
+module tree is code-only: binary art, audio, meshes, and other game content
+belong in complete examples, not this published package. Each entrypoint
+exports and documents its own `stable` or `provisional` API status.
+
+Every new module subpath must be present in the export-surface golden and the
+module bundle-budget golden. The guards derive their entry set from
+`package.json#exports`, so an unclassified export or a module without a budget
+fails CI.
+
+The first real entrypoint is
+`@series-inc/rundot-syncplay/modules/component-model`. It defines pure
+`step(slice, input, context)` modules, canonical state-slice validation,
+rollback-safe one-shot presentation, a KayKit-backed character clip vocabulary,
+and one third-person KCC3D reference component. V1 module context has no random
+generator: random and secret outcomes arrive as explicit input or authority
+commands so adding or reordering components cannot change a shared RNG stream.
+V1 is function-only; Kinetix descriptor adapters remain outside this arc. The
+component-model API is stable.
+
+`@series-inc/rundot-syncplay/modules/character-3d` composes the existing
+deterministic KCC3D and top-down mover into kinematic and top-down controllers,
+with crouch, slide, mantle, dash, wall-run, canonical animation parameters, and
+first-person, orbit, or top-down camera projections. Collision and traversal
+facts are explicit context input; render libraries, assets, and module-owned
+randomness remain outside the module. Its API is stable.
+
+`@series-inc/rundot-syncplay/modules/combat` composes deterministic combatant
+health/resistance/i-frame/hitstop resolution, active-frame melee arcs,
+travelling projectiles through the existing 3D shape-cast path, and hitscan
+authority through the existing lag-compensation validator. Hits, hurtboxes,
+body ownership, targets, occluders, and server timing are explicit input or
+context; the module owns no random stream, renderer, or physics engine. Its API
+is stable.
+
+`@series-inc/rundot-syncplay/modules/firearm` owns canonical semi-automatic or
+automatic cadence, magazine, reload, recoil, spread-sequence, and trigger-edge
+state. Its inventory helper consumes only the authored ammo item atomically.
+Aim, hits, damage, switching, attachments, and presentation remain caller-owned.
+Its API is provisional because the FPS is its only production example consumer.
+
+`@series-inc/rundot-syncplay/modules/gameplay-effects` emits ordered typed
+damage, healing, resource, status, and interrupt commands from immediate or
+periodic definitions. The composition helper applies combat and stats changes
+atomically in target/command order. Targeting, balance, crits, randomness, and
+presentation remain caller-owned. Its API is stable.
+
+`@series-inc/rundot-syncplay/modules/actors-ai` adds deterministic authored
+encounters, wave spawning, threat-based aggro, squad target sharing, and crowd
+movement over the existing bot and cooked-navmesh primitives. It accepts
+defeats and threat changes as explicit input, emits rollback-safe semantic
+events, and keeps render, combat, loot, and random encounter generation outside
+the module. Its API is provisional until the promotion gate.
+
+`@series-inc/rundot-syncplay/modules/stats-abilities` adds deterministic stat
+blocks, source-replaced modifiers, cast/channel/cooldown ability state, stacked
+statuses, experience levels, and ticket-resolved loot. Random authority remains
+outside the module: loot consumes an explicit integer ticket carried in synced
+input. Equipment integrates through source IDs such as
+`equipment:<ownerId>:<slotId>` and atomic modifier replacement. Its API is
+provisional until the promotion gate.
+
+`@series-inc/rundot-syncplay/modules/inventory-equipment` owns deterministic
+inventory slots, stacks, loot containers, pickups, drops, and equipment
+references. Equipped items remain in canonical inventory slots, and successful
+equipment transitions become complete source-replacement input for the real
+stats/abilities step. It owns no loot randomness, persistence, trading,
+rendering, or binary content. Its API is stable.
+
+`@series-inc/rundot-syncplay/modules/spatial-interaction` owns deterministic
+range/cone selection, focus, hold progress, cancellation, and one-shot
+completion. The caller owns the completed action and presentation. Its API is
+stable.
+
+`@series-inc/rundot-syncplay/modules/platformer-2d` composes the deterministic
+2D KCC with manual and autonomous movement, pause/resume/reverse control,
+edge/wall reversal latches, rising-edge jump input, one-way drop priority, and
+canonical render bindings. Level geometry and environmental facts remain
+explicit game-owned context. Its API is provisional until the promotion gate.
+
+`@series-inc/rundot-syncplay/modules/rts` declares the provisional deterministic
+RTS state, command, configuration, event, and projection boundary. The module
+delegates unit movement to the existing public deterministic navmesh step;
+rendering, content, health resolution, room lifecycle, and win rules remain
+game-owned. Its exact-shape implementation includes bounded selection/orders,
+formations, live-hostile target validation, explicit attack-move acquisition
+provenance, fog, economy, placement, production, and stable attack requests;
+certification remains a required provisional-module gate. Hydrated and issued
+authored `attack-target` orders must name a live opposing unit or building;
+self, friendly, queued, retired, and missing targets fail closed.
+
+The normal runner emits side effects only from authority-confirmed frames.
+Predicted/canceled lifecycle callbacks are available to lower-level speculative
+presentations that feed their `createDeterministicEventTimeline` records into
+the module presentation adapter; prediction state never enters deterministic
+module context.
+
+`./tools` is a supported public Node/build-tooling surface and is governed by
+the export golden. The import-safe `./core/build-native` and
+`./core/build-wasm-physics` callables are governed as well. Only
+`./core/preflight` is excluded from public-symbol comparison because it exports
+nothing and is a command that executes on import.
+
+`certifyModule(component, fixture)` on `./tools` is the provisional conformance
+gate for `./modules/*`. It delegates straight, rollback, replay, and hydration
+equivalence to `runSyncplaySynctest`, then adds module-only source rules,
+permutation equivalence, p99 step time, and retained heap per step. Run it under
+Node with `--expose-gc`; missing GC support fails closed instead of reporting a
+zero allocation.
+
+The published JavaScript graph has a committed exhaustive side-effect audit.
+`core/scripts/preflight.mjs` and
+`core/scripts/emit-product-digests.mjs` are the only import-time command
+effects and are preserved through the package's precise `sideEffects` allowlist.
+
 > **Upgrading an existing game?** See
 > [MIGRATING-SESSION-PRIMITIVES.md](./MIGRATING-SESSION-PRIMITIVES.md). Two
 > changes are not additive: the runner now rejects an unsafe input codec at
@@ -44,14 +161,8 @@ There is one session factory:
 
 ```ts
 import { createSyncplaySession } from '@series-inc/rundot-syncplay/browser';
-import { createInstalledPlatformer2dRuntime } from '@series-inc/rundot-syncplay/core/runtime';
 
-const runtime = createInstalledPlatformer2dRuntime({
-  pack,
-  levelBytes,
-  identity,
-  sessionConfigBytes,
-});
+const runtime = runtimeFactory(runtimeIdentity, sessionConfigBytes);
 
 const session = createSyncplaySession(runtime, {
   playerCount: 4,
@@ -64,8 +175,8 @@ const session = createSyncplaySession(runtime, {
 
 The runtime must implement `@series-inc/rundot-syncplay/core/runtime`. Syncplay never
 accepts an initial state, reducer, or creator-authored step callback. There is no
-compatibility mode for the removed reducer API. A non-platformer game supplies
-the same ABI through `createInstalledRuntimeAdapter` and binds its source with
+compatibility mode for the removed reducer API. A game supplies the ABI through
+`createInstalledRuntimeAdapter` and binds its source with
 `deriveCustomRuntimeIdentity` plus `kinetixRuntimeModuleManifest`.
 
 ## Runtime and snapshot contract
@@ -78,7 +189,8 @@ destination validates all of those values before mutating its live session.
 
 The networked client receives the authority's exact runtime identity and
 session-config bytes, asks the game for a matching runtime through its runtime
-factory, and rejects a locally loaded pack mismatch before frame 0. Replays use
+factory, and rejects a local runtime or content identity mismatch before frame 0.
+Replays use
 the same identity/config/factory path.
 
 ### Capability requirements
@@ -235,29 +347,9 @@ async preparation, then replays every buffered message once.
 
 The descriptor is exactly `{ slot, playerCount, seed, tickRateHz,
 hardToleranceTicks, role, runtimeIdentity, sessionConfigBytes,
-sessionConfigDigest }`. It does **not** carry `levelEntryId`, a level digest, or a
-level length — those are game-specific fields inside `sessionConfigBytes`, and you
-decode them with your own session-config schema:
-
-```ts
-import { decodeKinetixSessionConfig } from '@series-inc/rundot-syncplay/core/runtime';
-import { kinetixPlatformer2dSessionConfigSchema } from '@series-inc/rundot-syncplay/core/runtime';
-
-const prepareNetworkRuntime = async (descriptor, signal) => {
-  const session = decodeKinetixSessionConfig(
-    kinetixPlatformer2dSessionConfigSchema,
-    descriptor.sessionConfigBytes,
-  );
-  // session.levelEntryId / session.levelDigest / session.levelByteLength
-  const levelBytes = await preparePlatformerLevel(api.ugc, {
-    levelEntryId: session.levelEntryId,
-    levelDigest: session.levelDigest,
-    levelByteLength: session.levelByteLength,
-    encodeLevel: (level) => encodeKinetixPlatformer2dLevel(level, { maxBytes: 102_400 }),
-  });
-  registerPreparedLevel(descriptor.sessionConfigDigest, levelBytes);
-};
-```
+sessionConfigDigest }`. Game-specific asset declarations belong inside canonical
+`sessionConfigBytes`; resolve and verify those assets before constructing the
+network runtime.
 
 ## Safe input codecs
 
@@ -274,17 +366,6 @@ For an existing hand-written codec, `validateSyncplayInputCodec({ encodeInput,
 decodeInput, samples })` probes round-trip stability, `null → neutral`, and a
 battery of hostile payloads, failing with `SYNCPLAY_INPUT_CODEC_UNSAFE`.
 
-## Version-safe content references
-
-`publishPlatformerLevel(api, level, options)` always calls `ugc.create` — never
-`ugc.update` on a referenced entry, which would make every live room pinned to it
-permanently unjoinable. `preparePlatformerLevel(api, declaration)` resolves a pin
-and raises the typed `SYNCPLAY_LEVEL_CONTENT_CHANGED` (naming the entry id and the
-edit-vs-pin cause) rather than an opaque `KINETIX_AUX_ASSET_MISMATCH` deep inside
-runtime construction. `declaration.encodeLevel` is an **injected callback**, not a
-static core import, so Syncplay's compiled output never hard-binds a specific
-core build.
-
 **Capacity and late-join budgets.** Snapshot transfer defaults are **256 KiB**
 chunks and a **4 MiB** total ceiling; the immutable level payload is fetched and
 verified separately and never rides a snapshot. `maxPredictionTicks` is a

package/core/index.d.ts

@@ -23,61 +23,7 @@ export type {
   KinetixRuntimeIdentity,
   KinetixSessionConfigEnvelope,
 } from './runtime';
-export {
-  KINETIX_PLATFORMER2D_LEVEL_FORMAT,
-  KINETIX_PLATFORMER2D_PACK_FORMAT,
-  KINETIX_PLATFORMER2D_PACK_FORMAT_V1,
-  KINETIX_PLATFORMER2D_LEVEL_FORMAT_V1,
-  KINETIX_PLATFORMER2D_SPENT_TILE_ID,
-  KinetixPlatformerLevelError,
-  KinetixPlatformerRegistryError,
-  MAX_KINETIX_PLATFORMER2D_LEVEL_BYTES,
-  applyKinetixPlatformer2dTileOverrides,
-  createInstalledPlatformer2dRuntime,
-  createKinetixPlatformer2dRegistry,
-  createKinetixPlatformer2dSession,
-  decodeKinetixPlatformer2dLevel,
-  defineKinetixPlatformer2dPack,
-  deriveKinetixPlatformer2dRuntimeIdentity,
-  describeKinetixPlatformer2dLevel,
-  encodeKinetixPlatformer2dLevel,
-  kinetixPlatformer2dBuiltInEntityTypes,
-  kinetixPlatformer2dDeterministicAbi,
-  kinetixPlatformer2dLevelBonusBlocks,
-  kinetixPlatformer2dLevelBreakableTileIds,
-  kinetixPlatformer2dLevelOpenBounds,
-  kinetixPlatformer2dLevelSlopeTiles,
-  kinetixPlatformer2dSessionConfigSchema,
-  kinetixPlatformer2dSourceManifest,
-  migrateKinetixPlatformer2dLevel,
-  migrateKinetixPlatformer2dPack,
-  nextRngUint32,
-  rngInt,
-  seedRng,
-} from './runtime';
 export type {
-  KinetixPlatformer2dAbilities,
-  KinetixPlatformer2dBonusBlock,
-  KinetixPlatformer2dBonusContents,
-  KinetixPlatformer2dEntityDescriptor,
-  KinetixPlatformer2dPackV1,
-  KinetixPlatformer2dEntityValidationContext,
-  KinetixPlatformer2dIdentityOptions,
-  KinetixPlatformer2dEvent,
-  KinetixPlatformer2dGoalMode,
-  KinetixPlatformer2dInput,
-  KinetixPlatformer2dLevel,
-  KinetixPlatformer2dLevelEntity,
-  KinetixPlatformer2dPack,
-  KinetixPlatformer2dPhase,
-  KinetixPlatformer2dPlayerProjection,
-  KinetixPlatformer2dPowerUpKind,
-  KinetixPlatformer2dProjection,
-  KinetixPlatformer2dRegistry,
-  KinetixPlatformer2dSessionSetup,
-  KinetixPlatformer2dSlopeTile,
-  KinetixPlatformer2dTickRate,
-  KinetixPlatformerLevelErrorCode,
   KinetixRuntimeModuleManifestEntry,
 } from './runtime';
 export type { KinetixSessionConfigSchema } from './authoring';

package/core/native/fixed_math.cpp

@@ -24,6 +24,13 @@ double jsRound(double x) {
 // Number.isInteger: finite and integral. Non-integers make the reference throw.
 bool isFixed(double v) { return std::isfinite(v) && std::floor(v) == v; }
 
+// The reference restricts the domain so the over-2^53 divergence window is
+// empty rather than merely unlikely (src/math.ts). An interpolant outside
+// [0, fixedScale] is the one intermediate that restriction does not cover.
+bool isInterpolant(const Config& c, double v) {
+  return isFixed(v) && v >= 0.0 && v <= c.fixedScale;
+}
+
 bool isSafeInteger(double v) { return isFixed(v) && std::fabs(v) <= 9007199254740991.0; }
 
 // NOT std::fmin/std::fmax: those IGNORE a NaN operand and return the other one,
@@ -249,7 +256,7 @@ double maxFixed(const Config& c, double a, double b, bool& ok) {
 }
 
 double lerp(const Config& c, double a, double b, double t, bool& ok) {
-  if (!isFixed(a) || !isFixed(b) || !isFixed(t)) {
+  if (!isFixed(a) || !isFixed(b) || !isInterpolant(c, t)) {
     ok = false;
     return 0.0;
   }
@@ -594,7 +601,7 @@ Vec2 vec2FromAngleTurns(const Config& c, double turns, double length, bool& ok)
 double vec2AngleTurns(const Config& c, Vec2 v, bool& ok) { return atan2Turns(c, v.y, v.x, ok); }
 
 Vec2 vec2Lerp(const Config& c, Vec2 a, Vec2 b, double t, bool& ok) {
-  if (!isFixed(t)) {
+  if (!isInterpolant(c, t)) {
     ok = false;
     return Vec2{0, 0};
   }
@@ -686,7 +693,7 @@ Vec3 vec3Normalize(const Config& c, Vec3 v, bool& ok) {
 }
 
 Vec3 vec3Lerp(const Config& c, Vec3 a, Vec3 b, double t, bool& ok) {
-  if (!isFixed(t)) {
+  if (!isInterpolant(c, t)) {
     ok = false;
     return Vec3{0, 0, 0};
   }
@@ -718,7 +725,7 @@ Quat quatFromYawTurns(const Config& c, double turns, bool& ok) {
 }
 
 Quat quatLerp(const Config& c, Quat a, Quat b, double t, bool& ok) {
-  if (!isFixed(t)) {
+  if (!isInterpolant(c, t)) {
     ok = false;
     return Quat{0, 0, 0, 0};
   }

package/core/runtime.d.ts

@@ -161,311 +161,7 @@ export function createKinetixSessionConfig(
   value: Readonly<Record<string, unknown>>,
 ): KinetixSessionConfigEnvelope;
 
-export type KinetixPlatformer2dTickRate = 10 | 20 | 30 | 60;
-export type KinetixPlatformer2dGoalMode = 'any-player' | 'all-players';
-
-export interface KinetixPlatformer2dAbilities {
-  readonly crouch: boolean;
-  readonly groundPound: boolean;
-  readonly wallJump: boolean;
-  readonly climb: boolean;
-  readonly swim: boolean;
-  readonly carry: boolean;
-}
-
-export interface KinetixPlatformer2dPack {
-  readonly format: 'rundot.kinetix-platformer2d-pack.v2';
-  readonly tickRate: KinetixPlatformer2dTickRate;
-  readonly player: { readonly halfWidth: number; readonly halfHeight: number; readonly maxHealth: number };
-  readonly movement: {
-    readonly gravity: number; readonly maxFallSpeed: number;
-    readonly runAcceleration: number; readonly runDeceleration: number; readonly maxRunSpeed: number;
-    readonly jumpSpeed: number; readonly jumpCutGravityMultiplier: number;
-    readonly coyoteFrames: number; readonly jumpBufferFrames: number; readonly dropThroughFrames: number;
-    readonly crouchHalfHeight: number; readonly climbSpeed: number;
-    readonly swimGravity: number; readonly swimStrokeSpeed: number; readonly maxSwimFallSpeed: number;
-    readonly wallSlideSpeed: number; readonly wallJumpSpeedX: number; readonly wallJumpSpeedY: number;
-    readonly groundPoundSpeed: number; readonly throwSpeedX: number; readonly throwSpeedY: number;
-  };
-  readonly damage: {
-    readonly invulnerabilityFrames: number; readonly respawnFrames: number;
-    readonly stompBounceSpeed: number; readonly respawnGraceFrames: number;
-  };
-  readonly match: { readonly countdownFrames: number; readonly resultsFrames: number; readonly goalMode: KinetixPlatformer2dGoalMode };
-  readonly abilities: KinetixPlatformer2dAbilities;
-}
-
-/** A v1 pack, accepted by `defineKinetixPlatformer2dPack` and migrated with every v2 ability off. */
-export interface KinetixPlatformer2dPackV1 {
-  readonly format: 'rundot.kinetix-platformer2d-pack.v1';
-  readonly tickRate: KinetixPlatformer2dTickRate;
-  readonly player: KinetixPlatformer2dPack['player'];
-  readonly movement: Omit<KinetixPlatformer2dPack['movement'],
-    'crouchHalfHeight' | 'climbSpeed' | 'swimGravity' | 'swimStrokeSpeed' | 'maxSwimFallSpeed'
-    | 'wallSlideSpeed' | 'wallJumpSpeedX' | 'wallJumpSpeedY' | 'groundPoundSpeed' | 'throwSpeedX' | 'throwSpeedY'>;
-  readonly damage: Omit<KinetixPlatformer2dPack['damage'], 'respawnGraceFrames'>;
-  readonly match: KinetixPlatformer2dPack['match'];
-}
-
-export const KINETIX_PLATFORMER2D_PACK_FORMAT: 'rundot.kinetix-platformer2d-pack.v2';
-export const KINETIX_PLATFORMER2D_PACK_FORMAT_V1: 'rundot.kinetix-platformer2d-pack.v1';
-
-export function migrateKinetixPlatformer2dPack(
-  value: KinetixPlatformer2dPack | KinetixPlatformer2dPackV1,
-): KinetixPlatformer2dPack;
-
-export interface KinetixPlatformer2dInput {
-  readonly moveX: -1 | 0 | 1;
-  readonly moveY: -1 | 0 | 1;
-  readonly jumpPressed: boolean;
-  readonly jumpHeld: boolean;
-  readonly dropPressed: boolean;
-  readonly actionPressed: boolean;
-  readonly crouchHeld: boolean;
-}
-
-/** Folds a running session's `tileOverrides` back into a publishable level object. */
-export function applyKinetixPlatformer2dTileOverrides(
-  level: KinetixPlatformer2dLevel,
-  state: { readonly tileOverrides: readonly (readonly [number, number])[] },
-): KinetixPlatformer2dLevel;
-
-interface KinetixPlatformer2dBox {
-  readonly x: number; readonly y: number;
-  readonly halfWidth: number; readonly halfHeight: number;
-}
-interface KinetixPlatformer2dPath {
-  readonly halfWidth: number; readonly halfHeight: number;
-  readonly framesPerLeg: number;
-  readonly waypoints: readonly { readonly x: number; readonly y: number }[];
-}
-
-export type KinetixPlatformer2dLevelEntity =
-  | { readonly id: string; readonly type: 'spawn'; readonly slot: number; readonly x: number; readonly y: number }
-  | ({ readonly id: string; readonly type: 'oneWayPlatform' } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'movingPlatform' } & KinetixPlatformer2dPath)
-  | ({ readonly id: string; readonly type: 'fallingPlatform'; readonly triggerDelayFrames: number; readonly resetFrames: number } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'hazard'; readonly damage: number } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'stompable'; readonly respawnFrames: number } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'goalTrigger' } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'patrolEnemy'; readonly speed: number; readonly turnAtLedge: boolean; readonly damage: number; readonly respawnFrames: number } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'waypointEnemy'; readonly damage: number; readonly respawnFrames: number } & KinetixPlatformer2dPath)
-  | ({ readonly id: string; readonly type: 'movingHazard'; readonly damage: number } & KinetixPlatformer2dPath)
-  | ({ readonly id: string; readonly type: 'spring'; readonly launchSpeed: number } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'conveyor'; readonly beltSpeed: number } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'checkpoint' } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'coin' } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'powerUp'; readonly kind: KinetixPlatformer2dPowerUpKind } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'carryItem'; readonly damage: number } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'warpPipe'; readonly targetId: string } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'climbRegion' } & KinetixPlatformer2dBox)
-  | ({ readonly id: string; readonly type: 'waterRegion' } & KinetixPlatformer2dBox)
-  | { readonly id: string; readonly type: string; readonly [key: string]: unknown };
-
-export type KinetixPlatformer2dPowerUpKind = 'heal' | 'maxHealthUp' | 'doubleJump';
-export type KinetixPlatformer2dBonusContents = 'coin' | 'random' | KinetixPlatformer2dPowerUpKind;
-
-export interface KinetixPlatformer2dSlopeTile {
-  readonly tileId: number;
-  readonly dir: 'up-right' | 'up-left';
-}
-export interface KinetixPlatformer2dBonusBlock {
-  readonly x: number; readonly y: number;
-  readonly contents: KinetixPlatformer2dBonusContents;
-  readonly count: number;
-}
-
-export interface KinetixPlatformer2dLevel extends Readonly<Record<string, unknown>> {
-  readonly format: 'rundot.kinetix-platformer2d-level.v2';
-  readonly playerCapacity: number;
-  readonly tileGrid: {
-    readonly width: number; readonly height: number; readonly tileSize: number;
-    readonly tilesBase64: string; readonly solidTileIds: readonly number[];
-  };
-  readonly entities: readonly KinetixPlatformer2dLevelEntity[];
-  /** Absent means `false`: implicit solid walls at the level's left and right edges. */
-  readonly openBounds?: boolean;
-  readonly slopeTiles?: readonly KinetixPlatformer2dSlopeTile[];
-  readonly breakableTileIds?: readonly number[];
-  readonly bonusBlocks?: readonly KinetixPlatformer2dBonusBlock[];
-}
-
-export type KinetixPlatformerLevelErrorCode =
-  | 'KINETIX_PLATFORMER_LEVEL_INVALID'
-  | 'KINETIX_PLATFORMER_LEVEL_NONCANONICAL'
-  | 'KINETIX_PLATFORMER_LEVEL_SIZE_LIMIT';
-
-export class KinetixPlatformerLevelError extends Error {
-  readonly code: KinetixPlatformerLevelErrorCode;
-  /** JSON-pointer-style path to the offending field, `''` for whole-level failures. */
-  readonly path: string;
-  readonly expected: string;
-  readonly actual: unknown;
-}
-
-export class KinetixPlatformerRegistryError extends Error {
-  readonly code:
-    | 'KINETIX_PLATFORMER_REGISTRY_INVALID'
-    | 'KINETIX_PLATFORMER_REGISTRY_UNBOUND'
-    | 'KINETIX_PLATFORMER_SOURCE_MANIFEST_INVALID';
-}
-
-export interface KinetixPlatformer2dEntityValidationContext {
-  /** Throws a structured error; `path` is relative to this entity (e.g. `'/pushX'`). */
-  readonly fail: (path: string, expected: string, actual: unknown) => never;
-  readonly level: KinetixPlatformer2dLevel;
-  readonly grid: KinetixPlatformer2dLevel['tileGrid'];
-}
-
-export interface KinetixPlatformer2dEntityDescriptor {
-  readonly type: string;
-  readonly keys: readonly string[];
-  readonly validate: (entity: never, ctx: KinetixPlatformer2dEntityValidationContext) => void;
-  readonly behavior: {
-    readonly init?: (entity: never, ctx: never) => unknown;
-    readonly step?: (entityState: never, ctx: never) => void;
-  };
-}
-
-export interface KinetixPlatformer2dRegistry {
-  readonly hasExtensions: boolean;
-  readonly extensionTypes: readonly string[];
-  readonly byType: ReadonlyMap<string, KinetixPlatformer2dEntityDescriptor>;
-  readonly descriptors: readonly KinetixPlatformer2dEntityDescriptor[];
-}
-
-export function createKinetixPlatformer2dRegistry(
-  extensions?: readonly KinetixPlatformer2dEntityDescriptor[],
-): KinetixPlatformer2dRegistry;
-export const kinetixPlatformer2dBuiltInEntityTypes: readonly string[];
-
-export const KINETIX_PLATFORMER2D_LEVEL_FORMAT: 'rundot.kinetix-platformer2d-level.v2';
-export const KINETIX_PLATFORMER2D_LEVEL_FORMAT_V1: 'rundot.kinetix-platformer2d-level.v1';
-export const KINETIX_PLATFORMER2D_SPENT_TILE_ID: 255;
-
-export function migrateKinetixPlatformer2dLevel(level: unknown): KinetixPlatformer2dLevel;
-export function kinetixPlatformer2dLevelOpenBounds(level: KinetixPlatformer2dLevel): boolean;
-export function kinetixPlatformer2dLevelSlopeTiles(
-  level: KinetixPlatformer2dLevel,
-): readonly KinetixPlatformer2dSlopeTile[];
-export function kinetixPlatformer2dLevelBreakableTileIds(
-  level: KinetixPlatformer2dLevel,
-): readonly number[];
-export function kinetixPlatformer2dLevelBonusBlocks(
-  level: KinetixPlatformer2dLevel,
-): readonly KinetixPlatformer2dBonusBlock[];
-
-export interface KinetixPlatformer2dSessionSetup {
-  readonly runtimeIdentity: KinetixRuntimeIdentity;
-  readonly sessionConfigBytes: Uint8Array;
-  readonly sessionConfigDigest: string;
-  readonly level: KinetixAuxiliaryAssetDeclaration;
-}
-
-export const kinetixPlatformer2dDeterministicAbi: 'rundot.kinetix-platformer2d-js.v2';
-export const MAX_KINETIX_PLATFORMER2D_LEVEL_BYTES: 102_400;
-export const kinetixPlatformer2dSessionConfigSchema: import('./authoring').KinetixSessionConfigSchema;
-
-export function defineKinetixPlatformer2dPack(
-  value: KinetixPlatformer2dPack | KinetixPlatformer2dPackV1,
-): Readonly<KinetixPlatformer2dPack>;
 export interface KinetixRuntimeModuleManifestEntry {
   readonly path: string;
-  /** Lowercase sha256 hex of the module's bytes. */
   readonly digest: string;
 }
-
-export interface KinetixPlatformer2dIdentityOptions {
-  readonly registry?: KinetixPlatformer2dRegistry;
-  /**
-   * Required when `registry` carries extensions — custom entity behavior must be
-   * folded into identity or peers running different code would silently diverge.
-   * Omitting it throws `KINETIX_PLATFORMER_REGISTRY_UNBOUND`.
-   */
-  readonly registryManifest?: readonly KinetixRuntimeModuleManifestEntry[];
-  readonly sourceManifest?: readonly KinetixRuntimeModuleManifestEntry[];
-}
-
-export const kinetixPlatformer2dSourceManifest: readonly KinetixRuntimeModuleManifestEntry[];
-
-/**
- * The reducer's xorshift32 stream, exported so presentation can re-derive sim
- * rolls (predicted particles, cosmetic effects) without forking constants.
- * Seeded and stepped exactly like syncplay's `DeterministicRandom`; the parity
- * vector is golden-pinned in tests. Wrap the seed as `{ rng: seedRng(seed) }` —
- * the steppers mutate `state.rng` in place.
- */
-export function seedRng(seed?: number): number;
-export function nextRngUint32(state: { rng: number }): number;
-export function rngInt(state: { rng: number }, minInclusive: number, maxInclusive: number): number;
-
-export function deriveKinetixPlatformer2dRuntimeIdentity(
-  pack: KinetixPlatformer2dPack,
-  options?: KinetixPlatformer2dIdentityOptions,
-): KinetixRuntimeIdentity;
-export function encodeKinetixPlatformer2dLevel(
-  level: unknown,
-  options: { readonly maxBytes: number; readonly registry?: KinetixPlatformer2dRegistry },
-): Uint8Array;
-export function decodeKinetixPlatformer2dLevel(
-  bytes: Uint8Array,
-  options?: { readonly registry?: KinetixPlatformer2dRegistry },
-): Readonly<KinetixPlatformer2dLevel>;
-export function describeKinetixPlatformer2dLevel(
-  bytes: Uint8Array,
-  options?: { readonly registry?: KinetixPlatformer2dRegistry },
-): Readonly<KinetixAuxiliaryAssetDeclaration>;
-export function createKinetixPlatformer2dSession(options: {
-  readonly pack: KinetixPlatformer2dPack;
-  readonly levelEntryId: string;
-  readonly levelBytes: Uint8Array;
-  readonly playerCount: number;
-  readonly seed: number;
-  readonly registry?: KinetixPlatformer2dRegistry;
-  readonly registryManifest?: readonly KinetixRuntimeModuleManifestEntry[];
-}): Readonly<KinetixPlatformer2dSessionSetup>;
-
-export type KinetixPlatformer2dPhase = 'countdown' | 'playing' | 'results';
-export interface KinetixPlatformer2dEvent {
-  readonly eventId: string; readonly frame: number; readonly sequence: number;
-  readonly payload: Readonly<Record<string, string | number | boolean>>;
-  readonly predictionState: 'synced'; readonly dedupeKey: string;
-  readonly notHashedKeys: readonly string[]; readonly deliveryScope: 'all';
-}
-export interface KinetixPlatformer2dPlayerProjection {
-  readonly slot: number; readonly x: number; readonly y: number;
-  readonly vx: number; readonly vy: number; readonly health: number;
-  readonly grounded: boolean; readonly groundId: string | null;
-  readonly dead: boolean; readonly finished: boolean;
-  readonly maxHealth: number; readonly score: number; readonly coins: number;
-  readonly facing: -1 | 1; readonly crouching: boolean; readonly climbing: boolean;
-  readonly swimming: boolean; readonly groundPounding: boolean;
-  readonly carryingId: string | null; readonly checkpointId: string | null;
-  readonly doubleJumpCharges: number;
-}
-export interface KinetixPlatformer2dProjection {
-  readonly frame: number; readonly phase: KinetixPlatformer2dPhase; readonly phaseFrame: number;
-  readonly players: readonly KinetixPlatformer2dPlayerProjection[];
-  readonly platforms: readonly Readonly<Record<string, unknown>>[];
-  readonly stompables: readonly Readonly<Record<string, unknown>>[];
-  readonly enemies: readonly Readonly<Record<string, unknown>>[];
-  readonly hazards: readonly Readonly<Record<string, unknown>>[];
-  readonly pickups: readonly Readonly<Record<string, unknown>>[];
-  readonly spawnedPickups: readonly Readonly<Record<string, unknown>>[];
-  readonly carryItems: readonly Readonly<Record<string, unknown>>[];
-  /** Per-extension-entity behavior state (`behavior.init` return values), sorted by entity id. */
-  readonly extensions: readonly { readonly id: string; readonly state: unknown }[];
-  /** Sparse `[tileIndex, tileId]` pairs; apply with `applyKinetixPlatformer2dTileOverrides`. */
-  readonly tileOverrides: readonly (readonly [number, number])[];
-  readonly events: readonly KinetixPlatformer2dEvent[];
-}
-export function createInstalledPlatformer2dRuntime(options: {
-  readonly pack: KinetixPlatformer2dPack;
-  readonly levelBytes: Uint8Array;
-  readonly identity: KinetixRuntimeIdentity;
-  readonly sessionConfigBytes: Uint8Array;
-  readonly registry?: KinetixPlatformer2dRegistry;
-  readonly registryManifest?: readonly KinetixRuntimeModuleManifestEntry[];
-  /** How often the full-state finiteness walk runs, in frames. Defaults to 60. */
-  readonly validateStateEveryFrames?: number;
-}): KinetixRuntime<Readonly<Record<string, unknown>>, KinetixPlatformer2dInput, unknown, KinetixPlatformer2dProjection>;

package/core/scripts/emit-product-digests.mjs

@@ -2,7 +2,6 @@
 import { spawnSync } from 'node:child_process';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { deriveKinetixPlatformer2dRuntimeIdentity } from '../src/kinetix-platformer2d-runtime.mjs';
 
 function option(name) {
   const index = process.argv.indexOf(`--${name}`);
@@ -32,18 +31,6 @@ function checkGeneratedProduct(root, game) {
   }
 }
 
-const platformerPack = {
-  format: 'rundot.kinetix-platformer2d-pack.v1',
-  tickRate: 60,
-  player: { halfWidth: 6, halfHeight: 12, maxHealth: 2 },
-  movement: {
-    gravity: 900, maxFallSpeed: 420, runAcceleration: 1200, runDeceleration: 1600,
-    maxRunSpeed: 150, jumpSpeed: 330, jumpCutGravityMultiplier: 2.5,
-    coyoteFrames: 6, jumpBufferFrames: 6, dropThroughFrames: 8,
-  },
-  damage: { invulnerabilityFrames: 45, respawnFrames: 60, stompBounceSpeed: 220 },
-  match: { countdownFrames: 60, resultsFrames: 180, goalMode: 'all-players' },
-};
 const racingRoot = resolve(option('racing-root'));
 const latticeRoot = resolve(option('lattice-root'));
 checkGeneratedProduct(racingRoot, 'racing');
@@ -51,7 +38,6 @@ checkGeneratedProduct(latticeRoot, 'lattice');
 const digests = {
   racing: runtimeIdentity(racingRoot, 'src/kinetix/racing.product.generated.json'),
   lattice: runtimeIdentity(latticeRoot, 'src/kinetix/lattice.product.generated.json'),
-  platformerEngineIdentity: deriveKinetixPlatformer2dRuntimeIdentity(platformerPack).engineIdentityHash,
 };
 
 writeFileSync(option('out'), `${JSON.stringify(digests, null, 2)}\n`);