@series-inc/rundot-kinetix 0.0.0-bootstrap.0

package/src/kinetix-installed-mechanics.mjs

@@ -0,0 +1,377 @@
+export const kinetixMechanicEventBits = Object.freeze({
+  phase: 1,
+  spawn: 2,
+  score: 4,
+  bomb: 8,
+  multiplier: 16,
+  boundary: 32,
+  stagedAxis: 64,
+  targetDrift: 128,
+  gravityWell: 256,
+  followChain: 512,
+  growth: 1024,
+  randomSteering: 2048,
+  projectile: 4096,
+  driveFire: 8192,
+  pickup: 16384,
+  death: 32768,
+  respawn: 65536,
+});
+
+export const kinetixRequiredMechanicEventMask = Object.values(kinetixMechanicEventBits)
+  .reduce((mask, bit) => mask | bit, 0);
+
+export const kinetixInstalledMechanicFamilyOrder = Object.freeze([
+  'phase-spawn-score-policy',
+  'consumable-charge-economy',
+  'score-multiplier-decay',
+  'boundary-crossing-oscillator',
+  'staged-axis-runner',
+  'target-seeking-drift',
+  'gravity-well-state-machine',
+  'segmented-follow-chain',
+  'spawn-pellet-growth',
+  'bounded-random-steering',
+  'projectile-lifecycle-collision',
+  'axis-drive-fire-control',
+  'pickup-drift-lifecycle',
+]);
+
+export function decodeInstalledMechanicConfig(config, decodeF64) {
+  const decode = (value) => {
+    if (typeof value === 'string') return decodeF64(value);
+    if (Array.isArray(value)) return value.map(decode);
+    if (typeof value === 'object' && value !== null) {
+      return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, decode(entry)]));
+    }
+    return value;
+  };
+  return decode(config);
+}
+
+export function createInstalledMechanicState(config) {
+  return {
+    tick: 0,
+    phase: 0,
+    phaseElapsed: 0,
+    deathElapsed: 0,
+    deathOccurred: false,
+    spawnCooldown: 0,
+    score: 0,
+    charges: config.charge.startCharges,
+    lives: config.charge.startLives,
+    chargesEarned: 0,
+    livesEarned: 0,
+    previousBomb: false,
+    multiplier: 1,
+    multiplierPeak: 1,
+    multiplierDecayFrom: 1,
+    multiplierDecayElapsed: 0,
+    multiplierDecaying: false,
+    oscillatorX: config.boundary.min,
+    oscillatorY: 0,
+    oscillatorDirection: 1,
+    stagedX: 0,
+    stagedY: 0,
+    stagedMode: 0,
+    targetX: config.target.startX,
+    targetY: config.target.startY,
+    targetAge: 0,
+    gravityRadius: 0,
+    gravityHp: config.gravity.hitPoints,
+    gravityIngested: 0,
+    gravityStage: 0,
+    chainHeadX: 0,
+    chainHeadY: 0,
+    chainTailX: -config.follow.spacing * config.follow.segments,
+    chainTailY: 0,
+    growthAge: 0,
+    growthRadius: config.growth.startRadius,
+    growthCycles: 0,
+    randomX: config.random.startX,
+    randomY: config.random.startY,
+    randomVx: config.random.speed,
+    randomVy: 0,
+    randomTimer: 0,
+    randomState: config.random.seed >>> 0,
+    projectileX: 0,
+    projectileY: 0,
+    projectileVx: 0,
+    projectileVy: 0,
+    projectileAge: 0,
+    projectileActive: false,
+    shipX: config.drive.startX,
+    shipY: config.drive.startY,
+    fireCooldown: 0,
+    shotsFired: 0,
+    pickupX: config.pickup.startX,
+    pickupY: config.pickup.startY,
+    pickupAge: 0,
+    pickupActive: true,
+    eventMask: 0,
+  };
+}
+
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+function normalized(vector) {
+  const magnitude = Math.hypot(vector.x, vector.y);
+  if (magnitude <= 0.0001) return { x: 0, y: 0 };
+  return { x: vector.x / magnitude, y: vector.y / magnitude };
+}
+
+function nextRandom(state) {
+  return (Math.imul(state, 1664525) + 1013904223) >>> 0;
+}
+
+export function stepInstalledMechanics(current, input, config, dt) {
+  const state = structuredClone(current);
+  state.tick += 1;
+  state.phaseElapsed += dt;
+
+  let scored = false;
+  if (state.phase === 0 && state.phaseElapsed >= config.phase.spawnDelay) {
+    state.phase = 1;
+    state.spawnCooldown = 0;
+    state.eventMask |= kinetixMechanicEventBits.phase;
+  }
+  if (state.phase === 1) {
+    state.spawnCooldown -= dt;
+    while (state.spawnCooldown <= 0) {
+      state.spawnCooldown += config.phase.spawnInterval;
+      state.score += config.phase.scorePerSpawn;
+      scored = true;
+      state.eventMask |= kinetixMechanicEventBits.spawn | kinetixMechanicEventBits.score;
+    }
+    if (!state.deathOccurred && state.phaseElapsed >= config.phase.deathAt) {
+      state.phase = 2;
+      state.deathElapsed = 0;
+      state.deathOccurred = true;
+      state.lives = Math.max(0, state.lives - 1);
+      state.multiplierDecaying = true;
+      state.multiplierDecayFrom = state.multiplier;
+      state.multiplierDecayElapsed = 0;
+      state.eventMask |= kinetixMechanicEventBits.death;
+    }
+  } else if (state.phase === 2) {
+    state.deathElapsed += dt;
+    if (state.deathElapsed >= config.phase.respawnDelay) {
+      state.phase = 1;
+      state.multiplierDecaying = false;
+      state.eventMask |= kinetixMechanicEventBits.respawn;
+    }
+  }
+
+  const chargeMilestones = Math.floor(state.score / config.charge.chargeEveryScore);
+  if (chargeMilestones > state.chargesEarned) {
+    state.charges = Math.min(
+      config.charge.maxCharges,
+      state.charges + chargeMilestones - state.chargesEarned,
+    );
+    state.chargesEarned = chargeMilestones;
+  }
+  const lifeMilestones = Math.floor(state.score / config.charge.lifeEveryScore);
+  if (lifeMilestones > state.livesEarned) {
+    state.lives += lifeMilestones - state.livesEarned;
+    state.livesEarned = lifeMilestones;
+  }
+  if (input.bomb && !state.previousBomb && state.charges > 0) {
+    state.charges -= 1;
+    state.eventMask |= kinetixMechanicEventBits.bomb;
+  }
+  state.previousBomb = input.bomb;
+
+  if (scored && !state.multiplierDecaying) {
+    state.multiplier = Math.min(config.multiplier.cap, state.multiplier + config.multiplier.increment);
+    state.multiplierPeak = Math.max(state.multiplierPeak, state.multiplier);
+    state.eventMask |= kinetixMechanicEventBits.multiplier;
+  }
+  if (state.multiplierDecaying) {
+    state.multiplierDecayElapsed += dt;
+    if (state.multiplierDecayElapsed >= config.multiplier.decayWindow) {
+      state.multiplier = 1;
+      state.multiplierDecaying = false;
+    } else {
+      const progress = state.multiplierDecayElapsed / config.multiplier.decayWindow;
+      state.multiplier = state.multiplierDecayFrom + (1 - state.multiplierDecayFrom) * progress;
+    }
+  }
+
+  state.oscillatorX += state.oscillatorDirection * config.boundary.speed * dt;
+  state.oscillatorY += state.oscillatorDirection * config.boundary.lateralSpeed * dt;
+  if (state.oscillatorX <= config.boundary.min || state.oscillatorX >= config.boundary.max) {
+    state.oscillatorX = clamp(state.oscillatorX, config.boundary.min, config.boundary.max);
+    state.oscillatorDirection *= -1;
+  }
+  state.eventMask |= kinetixMechanicEventBits.boundary;
+
+  if (state.stagedMode === 0) {
+    state.stagedX += config.staged.approachSpeed * dt;
+    if (state.stagedX >= config.staged.switchX) state.stagedMode = 1;
+  } else {
+    state.stagedY += (input.fire ? -1 : 1) * config.staged.dodgeSpeed * dt;
+  }
+  state.eventMask |= kinetixMechanicEventBits.stagedAxis;
+
+  state.targetAge += dt;
+  const targetProgress = clamp(
+    (state.targetAge - config.target.accelStart) / (config.target.accelEnd - config.target.accelStart),
+    0,
+    1,
+  );
+  const targetSpeed = config.target.baseSpeed
+    + (config.target.topSpeed - config.target.baseSpeed) * targetProgress;
+  const targetDirection = normalized({ x: state.shipX - state.targetX, y: state.shipY - state.targetY });
+  state.targetX += targetDirection.x * targetSpeed * dt;
+  state.targetY += targetDirection.y * targetSpeed * dt;
+  state.eventMask |= kinetixMechanicEventBits.targetDrift;
+
+  if (state.gravityStage === 0) {
+    state.gravityRadius = Math.min(
+      config.gravity.activeRadius,
+      state.gravityRadius + (config.gravity.activeRadius / config.gravity.growSeconds) * dt,
+    );
+    if (state.gravityRadius >= config.gravity.activeRadius) state.gravityStage = 1;
+  } else if (state.gravityStage === 1) {
+    if (scored) state.gravityIngested += 1;
+    if (input.fire && state.tick % 30 === 0) state.gravityHp -= 1;
+    if (state.gravityHp <= 0) state.gravityStage = 2;
+  }
+  state.eventMask |= kinetixMechanicEventBits.gravityWell;
+
+  const chainDirection = normalized({ x: state.shipX - state.chainHeadX, y: state.shipY - state.chainHeadY });
+  state.chainHeadX += chainDirection.x * config.follow.speed * dt;
+  state.chainHeadY += chainDirection.y * config.follow.speed * dt;
+  const followAlpha = Math.min(1, config.follow.followRate * dt);
+  const desiredTailX = state.chainHeadX - chainDirection.x * config.follow.spacing * config.follow.segments;
+  const desiredTailY = state.chainHeadY - chainDirection.y * config.follow.spacing * config.follow.segments;
+  state.chainTailX += (desiredTailX - state.chainTailX) * followAlpha;
+  state.chainTailY += (desiredTailY - state.chainTailY) * followAlpha;
+  state.eventMask |= kinetixMechanicEventBits.followChain;
+
+  state.growthAge += dt;
+  state.growthRadius = config.growth.startRadius + (
+    config.growth.endRadius - config.growth.startRadius
+  ) * Math.min(1, state.growthAge / config.growth.growSeconds);
+  if (state.growthAge >= config.growth.lifetime) {
+    state.growthAge -= config.growth.lifetime;
+    state.growthRadius = config.growth.startRadius;
+    state.growthCycles += 1;
+  }
+  state.eventMask |= kinetixMechanicEventBits.growth;
+
+  state.randomTimer -= dt;
+  if (state.randomTimer <= 0) {
+    state.randomTimer += config.random.rerollSeconds;
+    state.randomState = nextRandom(state.randomState);
+    state.randomVx = ((state.randomState / 4294967296) * 2 - 1) * config.random.speed;
+    state.randomState = nextRandom(state.randomState);
+    state.randomVy = ((state.randomState / 4294967296) * 2 - 1) * config.random.speed;
+  }
+  state.randomX += state.randomVx * dt;
+  state.randomY += state.randomVy * dt;
+  if (state.randomX <= config.random.minX || state.randomX >= config.random.maxX) {
+    state.randomX = clamp(state.randomX, config.random.minX, config.random.maxX);
+    state.randomVx *= -1;
+  }
+  if (state.randomY <= config.random.minY || state.randomY >= config.random.maxY) {
+    state.randomY = clamp(state.randomY, config.random.minY, config.random.maxY);
+    state.randomVy *= -1;
+  }
+  state.eventMask |= kinetixMechanicEventBits.randomSteering;
+
+  const movement = normalized(input.movement);
+  state.shipX = clamp(
+    state.shipX + movement.x * config.drive.maxSpeed * dt,
+    config.drive.minX,
+    config.drive.maxX,
+  );
+  state.shipY = clamp(
+    state.shipY + movement.y * config.drive.maxSpeed * dt,
+    config.drive.minY,
+    config.drive.maxY,
+  );
+  state.fireCooldown -= dt;
+  const aim = normalized(input.aim);
+  if (input.fire && (aim.x !== 0 || aim.y !== 0) && state.fireCooldown <= 0) {
+    state.fireCooldown += config.drive.fireInterval;
+    state.shotsFired += 1;
+    if (!state.projectileActive) {
+      state.projectileActive = true;
+      state.projectileX = state.shipX;
+      state.projectileY = state.shipY;
+      state.projectileVx = aim.x * config.projectile.speed;
+      state.projectileVy = aim.y * config.projectile.speed;
+      state.projectileAge = 0;
+    }
+  }
+  state.eventMask |= kinetixMechanicEventBits.driveFire;
+
+  if (state.projectileActive) {
+    const gravityDx = state.targetX - state.projectileX;
+    const gravityDy = state.targetY - state.projectileY;
+    const gravityDistanceSq = gravityDx * gravityDx + gravityDy * gravityDy;
+    const gravityDistance = Math.sqrt(gravityDistanceSq);
+    if (gravityDistance > 0 && gravityDistance <= state.gravityRadius) {
+      const force = config.gravity.pullStrength / Math.max(1, gravityDistanceSq);
+      state.projectileVx += (gravityDx / gravityDistance) * force * config.projectile.gravityScale * dt;
+      state.projectileVy += (gravityDy / gravityDistance) * force * config.projectile.gravityScale * dt;
+    }
+    state.projectileX += state.projectileVx * dt;
+    state.projectileY += state.projectileVy * dt;
+    state.projectileAge += dt;
+    if (state.projectileAge >= config.projectile.maxAge
+      || state.projectileX < config.projectile.minX
+      || state.projectileX > config.projectile.maxX
+      || state.projectileY < config.projectile.minY
+      || state.projectileY > config.projectile.maxY) {
+      state.projectileActive = false;
+    }
+  }
+  state.eventMask |= kinetixMechanicEventBits.projectile;
+
+  if (state.pickupActive) {
+    state.pickupAge += dt;
+    state.pickupX += config.pickup.driftSpeed * dt;
+    const pickupDistance = Math.hypot(state.pickupX - state.shipX, state.pickupY - state.shipY);
+    if (pickupDistance <= config.pickup.collectRadius || state.pickupAge >= config.pickup.lifetime) {
+      state.pickupActive = false;
+      state.eventMask |= kinetixMechanicEventBits.pickup;
+    }
+  }
+
+  return state;
+}
+
+export function canonicalInstalledMechanicState(state) {
+  return {
+    tick: state.tick,
+    eventMask: state.eventMask,
+    score: state.score,
+    charges: state.charges,
+    lives: state.lives,
+    shotsFired: state.shotsFired,
+    growthCycles: state.growthCycles,
+  };
+}
+
+export function installedMechanicReplayInput(tick) {
+  return {
+    movement: tick < 180 ? { x: 1, y: 0 } : { x: -1, y: 0.25 },
+    aim: { x: 1, y: tick % 120 < 60 ? 0.25 : -0.25 },
+    fire: tick % 3 !== 0,
+    bomb: tick === 45 || tick === 300,
+  };
+}
+
+export function runInstalledMechanicReplay(config, ticks = 600) {
+  let state = createInstalledMechanicState(config);
+  const states = [];
+  for (let tick = 0; tick < ticks; tick += 1) {
+    state = stepInstalledMechanics(state, installedMechanicReplayInput(tick), config, 1 / 60);
+    states.push(canonicalInstalledMechanicState(state));
+  }
+  return { state, bytes: Buffer.from(JSON.stringify(states)) };
+}

package/src/kinetix-installed-systems.mjs

@@ -0,0 +1,181 @@
+import {
+  createFixedRuntime,
+  executeFixedRuntimeSystem,
+} from './kinetix-fixed1000-runtime.mjs';
+
+function family({ id, phase, order, reads, writes, numericProfile, structuralCommands = [] }) {
+  return Object.freeze({
+    id,
+    phase,
+    order,
+    reads: Object.freeze(reads),
+    writes: Object.freeze(writes),
+    numericProfiles: Object.freeze([numericProfile]),
+    structuralCommands: Object.freeze(structuralCommands),
+  });
+}
+
+const fixed = 'fixed-1000-3d';
+const f64 = 'deterministic-f64';
+
+export const kinetixInstalledSystemFamilies = Object.freeze([
+  family({ id: 'slot-input-resolution', phase: 'fixed-simulation', order: 100, reads: ['InputFrame', 'SlotState'], writes: ['VehicleInput', 'SlotState'], numericProfile: fixed }),
+  family({ id: 'vehicle-drive-body-build', phase: 'fixed-simulation', order: 200, reads: ['VehicleInput', 'FixedTransform', 'ColliderRecipe'], writes: ['RigidBody3D'], numericProfile: fixed }),
+  family({ id: 'vehicle-physics-step', phase: 'fixed-simulation', order: 300, reads: ['RigidBody3D', 'ColliderRecipe'], writes: ['RigidBody3D', 'VehicleContactState', 'FixedTransform'], numericProfile: fixed }),
+  family({ id: 'vehicle-lap-finish', phase: 'fixed-simulation', order: 400, reads: ['FixedTransform', 'TrackCells', 'LapState'], writes: ['LapState', 'FinishState'], numericProfile: fixed }),
+  family({ id: 'match-phase-transition', phase: 'post-simulation', order: 500, reads: ['SlotState', 'FinishState', 'MatchPhase'], writes: ['MatchPhase'], numericProfile: fixed }),
+  family({ id: 'arena-input-mapping', phase: 'fixed-simulation', order: 100, reads: ['InputFrame'], writes: ['DriveIntent', 'FireIntent'], numericProfile: f64 }),
+  family({ id: 'arena-countdowns', phase: 'fixed-simulation', order: 200, reads: ['Countdown'], writes: ['Countdown'], numericProfile: f64 }),
+  family({ id: 'arena-axis-drive', phase: 'fixed-simulation', order: 300, reads: ['DriveIntent', 'Transform2D'], writes: ['Velocity2D'], numericProfile: f64 }),
+  family({ id: 'arena-autofire', phase: 'fixed-simulation', order: 400, reads: ['FireIntent', 'Transform2D', 'Countdown'], writes: ['Countdown'], numericProfile: f64, structuralCommands: ['spawnPrefab'] }),
+  family({ id: 'arena-linear-integration-bounds', phase: 'fixed-simulation', order: 500, reads: ['Transform2D', 'Velocity2D', 'ArenaBounds'], writes: ['Transform2D', 'Velocity2D'], numericProfile: f64 }),
+  family({ id: 'arena-collision-pre-ai', phase: 'fixed-simulation', order: 600, reads: ['Transform2D', 'CircleCollider', 'CollisionLayer'], writes: ['Health'], numericProfile: f64, structuralCommands: ['despawnPrefab'] }),
+  family({ id: 'arena-bounded-enemy-steering', phase: 'fixed-simulation', order: 700, reads: ['Transform2D', 'EnemySteering', 'ArenaBounds'], writes: ['Velocity2D'], numericProfile: f64 }),
+  family({ id: 'arena-collision-post-ai', phase: 'fixed-simulation', order: 800, reads: ['Transform2D', 'CircleCollider', 'CollisionLayer'], writes: ['Health'], numericProfile: f64, structuralCommands: ['despawnPrefab'] }),
+  family({ id: 'arena-lifetimes', phase: 'post-simulation', order: 900, reads: ['Lifetime'], writes: ['Lifetime'], numericProfile: f64, structuralCommands: ['despawnPrefab'] }),
+  family({ id: 'phase-spawn-score-policy', phase: 'post-simulation', order: 1000, reads: ['RunPhase', 'SpawnPolicy', 'ScoreState'], writes: ['RunPhase', 'SpawnPolicy', 'ScoreState'], numericProfile: f64, structuralCommands: ['spawnPrefab', 'despawnPrefab'] }),
+  family({ id: 'consumable-charge-economy', phase: 'post-simulation', order: 1100, reads: ['ScoreState', 'ChargeEconomy'], writes: ['ChargeEconomy'], numericProfile: f64 }),
+  family({ id: 'score-multiplier-decay', phase: 'post-simulation', order: 1200, reads: ['ScoreState', 'MultiplierState'], writes: ['MultiplierState'], numericProfile: f64 }),
+  family({ id: 'boundary-crossing-oscillator', phase: 'fixed-simulation', order: 710, reads: ['Transform2D', 'OscillatorState', 'ArenaBounds'], writes: ['Transform2D', 'OscillatorState'], numericProfile: f64 }),
+  family({ id: 'staged-axis-runner', phase: 'fixed-simulation', order: 720, reads: ['Transform2D', 'StageState', 'ProjectileField'], writes: ['Transform2D', 'StageState'], numericProfile: f64 }),
+  family({ id: 'target-seeking-drift', phase: 'fixed-simulation', order: 730, reads: ['Transform2D', 'TargetState'], writes: ['Transform2D'], numericProfile: f64 }),
+  family({ id: 'gravity-well-state-machine', phase: 'fixed-simulation', order: 740, reads: ['Transform2D', 'GravityWellState'], writes: ['Transform2D', 'GravityWellState'], numericProfile: f64, structuralCommands: ['spawnPrefab', 'despawnPrefab'] }),
+  family({ id: 'segmented-follow-chain', phase: 'fixed-simulation', order: 750, reads: ['Transform2D', 'FollowChainState'], writes: ['Transform2D', 'FollowChainState'], numericProfile: f64 }),
+  family({ id: 'spawn-pellet-growth', phase: 'fixed-simulation', order: 760, reads: ['Transform2D', 'GrowthState', 'Lifetime'], writes: ['Transform2D', 'GrowthState', 'Lifetime'], numericProfile: f64, structuralCommands: ['despawnPrefab'] }),
+  family({ id: 'bounded-random-steering', phase: 'fixed-simulation', order: 770, reads: ['Transform2D', 'RandomSteeringState', 'ArenaBounds'], writes: ['Transform2D', 'RandomSteeringState'], numericProfile: f64 }),
+  family({ id: 'projectile-lifecycle-collision', phase: 'fixed-simulation', order: 780, reads: ['Transform2D', 'ProjectileState', 'CollisionLayer'], writes: ['Transform2D', 'ProjectileState'], numericProfile: f64, structuralCommands: ['spawnPrefab', 'despawnPrefab'] }),
+  family({ id: 'axis-drive-fire-control', phase: 'fixed-simulation', order: 790, reads: ['DriveIntent', 'FireIntent', 'Transform2D'], writes: ['Transform2D', 'FireIntent'], numericProfile: f64 }),
+  family({ id: 'pickup-drift-lifecycle', phase: 'fixed-simulation', order: 795, reads: ['Transform2D', 'PickupState', 'Lifetime'], writes: ['Transform2D', 'PickupState', 'Lifetime'], numericProfile: f64, structuralCommands: ['despawnPrefab'] }),
+]);
+
+export const kinetixInstalledSourceSignatures = Object.freeze({
+  'slot-input-resolution': Object.freeze([{ call: 'resolveInputs' }, { call: 'push', receiver: 'cmds' }]),
+  'vehicle-drive-body-build': Object.freeze([{ call: 'driveVehicle' }, { call: 'stepVehicle' }]),
+  'vehicle-physics-step': Object.freeze([{ call: 'stepPhysicsWorld' }, { call: 'stepDeterministicPhysicsWorld3D' }]),
+  'vehicle-lap-finish': Object.freeze([{ call: 'stepLap' }]),
+  'match-phase-transition': Object.freeze([{ call: 'stepPhase' }, { call: 'snapToGrid' }]),
+  'arena-input-mapping': Object.freeze([{ call: 'readInputFrame' }, { call: 'normalizeInputs' }]),
+  'arena-countdowns': Object.freeze([{ call: 'advanceCountdown' }, { call: 'advanceSparkMagnetSurge' }]),
+  'arena-axis-drive': Object.freeze([{ call: 'applyAxisDrive' }, { call: 'update', receiver: 'ship' }]),
+  'arena-autofire': Object.freeze([{ call: 'autoFire' }]),
+  'arena-linear-integration-bounds': Object.freeze([{ call: 'integrateBounds' }, { call: 'update', receiver: 'bullets' }]),
+  'arena-collision-pre-ai': Object.freeze([{ call: 'collisionPass', argument: 'pre-ai' }, { call: 'processBulletCollisions', occurrence: 0 }]),
+  'arena-bounded-enemy-steering': Object.freeze([{ call: 'steerEnemies' }, { call: 'nearestLivingShipPosition' }]),
+  'arena-collision-post-ai': Object.freeze([{ call: 'collisionPass', argument: 'post-ai' }, { call: 'processBulletCollisions', occurrence: 1 }]),
+  'arena-lifetimes': Object.freeze([{ call: 'advanceLifetimes' }, { call: 'collectDead' }]),
+});
+
+export function installedSystemFamiliesForProfile(numericProfile) {
+  return kinetixInstalledSystemFamilies.filter((family) => family.numericProfiles.includes(numericProfile));
+}
+
+export function createInstalledKinetixProfile(numericProfile, options = {}) {
+  const families = installedSystemFamiliesForProfile(numericProfile);
+  if (families.length === 0) throw new Error('KINETIX_NUMERIC_PROFILE_UNSUPPORTED');
+  const abi = numericProfile === fixed ? 'fixed-1000-3d.v1' : 'deterministic-f64-2d.v1';
+  const runtimeContract = kinetixRuntimeContractForProfile(numericProfile);
+  let fixedRuntime = null;
+  return {
+    abi,
+    runtimeContract,
+    componentSchemas: new Map([
+      ['KinetixRuntimeState', { currentSchemaVersion: 1, domains: ['simulation'], validate: () => [] }],
+      ['KinetixRenderRecord', { currentSchemaVersion: 1, domains: ['presentation'], validate: () => [] }],
+      ['KinetixRenderBinding', { currentSchemaVersion: 1, domains: ['binding'], validate: () => [] }],
+    ]),
+    systems: families.map((installedFamily) => ({
+      id: installedFamily.id,
+      version: 1,
+      phase: installedFamily.phase,
+      order: installedFamily.order,
+      query: { all: [], none: [] },
+      reads: [],
+      writes: [],
+      structuralCommands: [...installedFamily.structuralCommands],
+    })),
+    bakeEntity: () => ({ simulation: [], presentation: [], binding: [] }),
+    bakePrefab: () => ({ simulation: [], presentation: [], binding: [] }),
+    executeSystem: numericProfile === fixed
+      ? ({ systemId, inputFrame, simulation, initialization }) => {
+          const properties = simulation.read('runtime-root', 'KinetixRuntimeState');
+          const pack = properties.installedProfileData;
+          if (fixedRuntime === null) {
+            const configuredPack = {
+              ...pack,
+              slotCount: initialization.slotCount ?? pack.slotCount,
+              humanCount: initialization.humanCount ?? pack.humanCount,
+              initialPhase: initialization.initialPhase ?? pack.initialPhase,
+            };
+            fixedRuntime = createFixedRuntime(configuredPack, options.fixedPhysics);
+          } else if (properties.authoritativeState !== undefined
+            && fixedRuntime.pendingInstalledTick === undefined) {
+            fixedRuntime.state = structuredClone(properties.authoritativeState);
+          }
+          executeFixedRuntimeSystem(fixedRuntime, systemId, inputFrame.slots);
+          if (fixedRuntime.pendingInstalledTick === undefined) {
+            simulation.write('runtime-root', 'KinetixRuntimeState', {
+              ...properties,
+              authoritativeState: structuredClone(fixedRuntime.state),
+            });
+          }
+        }
+      : undefined,
+  };
+}
+
+export function kinetixRuntimeContractForProfile(numericProfile) {
+  if (numericProfile === fixed) return fixedRuntimeContract('fixed-1000-3d.v1');
+  if (numericProfile === f64) return f64RuntimeContract('deterministic-f64-2d.v1');
+  throw new Error('KINETIX_NUMERIC_PROFILE_UNSUPPORTED');
+}
+
+function fixedRuntimeContract(abi) {
+  return Object.freeze({
+    tickRate: 30,
+    targetProfile: fixed,
+    numericProfile: 'fixed-1000',
+    deterministicAbi: abi,
+    deterministicVersion: 'rundot.kinetix.fixed-1000-runtime.v1',
+    inputSchema: Object.freeze({
+      version: 'rundot.kinetix-input-schema.v1',
+      slots: 'bounded-array',
+      fields: Object.freeze([
+        Object.freeze({ name: 'steerX', type: 'fixed-1000' }),
+        Object.freeze({ name: 'throttle', type: 'fixed-1000' }),
+        Object.freeze({ name: 'handbrake', type: 'boolean' }),
+      ]),
+    }),
+    stateSchema: Object.freeze({
+      version: 'rundot.kinetix-state-schema.v1',
+      checkpoint: 'opaque-canonical-bytes',
+      numericProfile: 'fixed-1000',
+      componentRoot: 'KinetixRuntimeState',
+    }),
+  });
+}
+
+function f64RuntimeContract(abi) {
+  return Object.freeze({
+    tickRate: 30,
+    targetProfile: f64,
+    numericProfile: f64,
+    deterministicAbi: abi,
+    deterministicVersion: 'rundot.kinetix.deterministic-f64-runtime.v1',
+    inputSchema: Object.freeze({
+      version: 'rundot.kinetix-input-schema.v1',
+      slots: 'bounded-array',
+      fields: Object.freeze([
+        Object.freeze({ name: 'movementVector', type: 'f64x2' }),
+        Object.freeze({ name: 'aimVector', type: 'f64x2' }),
+        Object.freeze({ name: 'fireDown', type: 'boolean' }),
+        Object.freeze({ name: 'bombPressed', type: 'boolean' }),
+      ]),
+    }),
+    stateSchema: Object.freeze({
+      version: 'rundot.kinetix-state-schema.v1',
+      checkpoint: 'opaque-canonical-bytes',
+      numericProfile: f64,
+      componentRoot: 'KinetixRuntimeState',
+    }),
+  });
+}

package/src/kinetix-native-product.mjs

@@ -0,0 +1,72 @@
+import {
+  bakeKinetixEnvelope,
+  scanKinetixPayloadTree,
+  stableKinetixProductBytes,
+} from './kinetix-baker.mjs';
+import { createInstalledKinetixProfile } from './kinetix-installed-systems.mjs';
+import { compileKinetixProject, compileTrustedKinetixSource } from './kinetix-project-compiler.mjs';
+
+function compileProducts(input, compile) {
+  const compiled = compile(input);
+  if (compiled.diagnostics.length > 0 || compiled.envelope === null) {
+    throw new Error(`KINETIX_PROJECT_INELIGIBLE ${JSON.stringify(compiled.diagnostics)}`);
+  }
+  const profileId = compiled.envelope.profiles[0].id;
+  const installedProfiles = new Map([[profileId, createInstalledKinetixProfile(input.targetProfile)]]);
+  const baked = bakeKinetixEnvelope(compiled.envelope, installedProfiles);
+  if (!baked.valid) throw new Error(`KINETIX_BAKE_FAILED ${JSON.stringify(baked.diagnostics)}`);
+  return { compiled, products: baked.products, runtimeIdentity: baked.runtimeIdentity };
+}
+
+export function compileStableKinetixProducts(input) {
+  return compileStableProducts(input, compileKinetixProject);
+}
+
+export function compileStableKinetixProductsFromTrustedSource(input) {
+  return compileStableProducts(input, compileTrustedKinetixSource);
+}
+
+function compileStableProducts(input, compile) {
+  const first = compileProducts(input, compile);
+  const second = compileProducts(input, compile);
+  if (!stableKinetixProductBytes(first.products).equals(stableKinetixProductBytes(second.products))) {
+    throw new Error('KINETIX_PRODUCT_NONDETERMINISTIC');
+  }
+  scanKinetixPayloadTree(first.products);
+  return first;
+}
+
+export function nativeFixed1000ProductBytes(products, pack) {
+  const chunks = [Buffer.from('KNATIVE1')];
+  const appendU32 = (value) => {
+    const bytes = Buffer.alloc(4);
+    bytes.writeUInt32LE(value);
+    chunks.push(bytes);
+  };
+  const appendI64 = (value) => {
+    const bytes = Buffer.alloc(8);
+    bytes.writeBigInt64LE(BigInt(value));
+    chunks.push(bytes);
+  };
+  const appendString = (value) => {
+    const bytes = Buffer.from(value);
+    appendU32(bytes.length);
+    chunks.push(bytes);
+  };
+  appendString(products.sourceDigest);
+  const simulation = products.manifest.payloads.find((payload) => payload.name === 'simulation');
+  if (!simulation) throw new Error('KINETIX_SIMULATION_PAYLOAD_MISSING');
+  appendString(simulation.digest);
+  appendU32(products.manifest.systems.length);
+  for (const system of products.manifest.systems) {
+    appendString(system.id);
+    appendString(system.phase);
+    appendI64(system.phaseIndex);
+    appendI64(system.order);
+  }
+  const profile = Buffer.from(pack.installedProfileBinary, 'base64');
+  appendString(pack.installedProfileBinarySha256);
+  appendU32(profile.length);
+  chunks.push(profile);
+  return Buffer.concat(chunks);
+}