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

package/README.md

@@ -0,0 +1,77 @@
+# @series-inc/rundot-kinetix
+
+Kinetix owns RUN.game's deterministic simulation supply chain and runtime. It
+compiles data-only project declarations into exact products, derives runtime
+identity from those products, and exposes the only simulation lifecycle used by
+Syncplay.
+
+## Ownership boundary
+
+| Concern | Owner |
+|---|---|
+| Committed source capture, upload authority, build lifecycle | Pack API + CLI |
+| Compilation, exact product schema, runtime identity | Kinetix compiler/baker |
+| Artifact immutability, signing, key trust, catalog eligibility | Pack service + KMS/GCS/Firestore |
+| Deterministic state, RNG streams, step, checkpoint bytes, canonical checksum | Kinetix runtime |
+| Inputs, prediction, confirmation, rollback policy, replay log, late join, secrets, transport | Syncplay |
+| Rendering/interpolation/effects | Presentation adapters outside authoritative state |
+
+Kinetix never imports Syncplay. Syncplay runtime code may import exactly the
+browser-safe `/runtime` subpath; its build tooling may additionally import
+`/authoring`. A dependency-direction test enforces this and rejects any restored
+composition package.
+
+## Authoring
+
+```ts
+import { defineKinetixProject } from '@series-inc/rundot-kinetix/authoring';
+
+export const project = defineKinetixProject({
+  id: 'arena',
+  installedProfile: 'fixed-1000-3d',
+  tickRate: 30,
+  inputSchema: { id: 'arena-input/v1' },
+  sessionConfigSchema: {
+    id: 'arena-session/v1',
+    version: 1,
+    maxBytes: 65536,
+    fields: { playerCount: { type: 'integer', min: 1, max: 8 } },
+  },
+  mechanics: [],
+  components: [],
+  systems: [],
+  presentationBindings: [],
+});
+```
+
+Declarations are canonical data only. Functions, classes, and creator-authored
+step callbacks are rejected. Match initialization is encoded separately as
+bounded canonical session-config bytes; changing it changes the config digest,
+not the signed mechanics product or runtime identity.
+
+## Runtime ABI
+
+The ESM-only `/runtime` entrypoint is browser-safe and exposes immutable runtime
+identity, ordered atomic batch advance, opaque checkpoint capture/restore,
+inspection, explicit serialization/hydration, checksums, and release. The
+reference world backend uses deep-copy checkpoints today. Installed f64 and
+fixed-1000 products have direct adapters to the same ABI.
+
+The ABI is batched so a future WASM/native backend crosses the boundary once per
+run rather than once per entity. Acceleration is a measured decision: simulation
+must account for at least 30% of end-to-end frame cost, and a prototype must beat
+optimized JS by at least 20% including checkpoint and boundary overhead while
+remaining bit-identical in Chromium and WebKit.
+
+## Build and test
+
+```bash
+npm install
+npm run build:native
+npm test
+```
+
+The suite covers the runtime ABI, browser-safe graph, world rollback/hydration,
+installed adapters, data-only authoring, canonical session config, compiler-
+derived identity, source guards, dependency direction, and JS/C++ per-tick hash
+parity.

package/authoring.d.ts

@@ -0,0 +1,30 @@
+export type KinetixInstalledProfileName = 'deterministic-f64' | 'fixed-1000-3d';
+
+export type KinetixSessionField =
+  | { type: 'string'; maxBytes: number; required?: boolean }
+  | { type: 'integer'; min: number; max: number; required?: boolean }
+  | { type: 'boolean'; required?: boolean }
+  | { type: 'enum'; values: readonly string[]; required?: boolean };
+
+export interface KinetixSessionConfigSchema {
+  id: string;
+  version: number;
+  maxBytes: number;
+  fields: Readonly<Record<string, KinetixSessionField>>;
+}
+
+export interface KinetixProjectDeclaration {
+  id: string;
+  installedProfile: KinetixInstalledProfileName;
+  tickRate: 10 | 20 | 30 | 60;
+  inputSchema: Readonly<Record<string, unknown>>;
+  sessionConfigSchema: KinetixSessionConfigSchema;
+  mechanics: readonly Readonly<Record<string, unknown>>[];
+  components: readonly Readonly<Record<string, unknown>>[];
+  systems: readonly Readonly<Record<string, unknown>>[];
+  presentationBindings: readonly Readonly<Record<string, unknown>>[];
+}
+
+export function defineKinetixProject<const Project extends KinetixProjectDeclaration>(
+  project: Project,
+): Readonly<Project>;

package/index.d.ts

@@ -0,0 +1,221 @@
+// Hand-authored public surface. The runtime is ESM JavaScript (.mjs) moved
+// verbatim out of the console lab; these declarations give consumers types
+// without touching a byte of runtime behavior.
+
+export {
+  assertKinetixRuntime,
+  assertKinetixRuntimeIdentity,
+  kinetixRuntimeAbiVersion,
+} from './runtime';
+export type {
+  KinetixAdvanceRequest,
+  KinetixAdvanceResult,
+  KinetixRuntime,
+  KinetixRuntimeIdentity,
+} from './runtime';
+export { createInstalledSurvivalRuntime } from './runtime';
+export { defineKinetixProject } from './authoring';
+export type { KinetixProjectDeclaration, KinetixSessionConfigSchema } from './authoring';
+
+export type KinetixTargetProfile = 'deterministic-f64' | 'fixed-1000-3d';
+
+export interface KinetixCompileInput {
+  projectRoot: string;
+  expectedCommit: string;
+  targetProfile: KinetixTargetProfile;
+}
+
+export interface KinetixDiagnostic {
+  code: string;
+  message: string;
+}
+
+export interface KinetixEnvelope {
+  profiles: { id: string }[];
+  entities: {
+    id: string;
+    components: { id: string; type: string; properties: Record<string, unknown> }[];
+  }[];
+}
+
+export interface KinetixCompiled {
+  envelope: KinetixEnvelope | null;
+  diagnostics: KinetixDiagnostic[];
+  sourceSnapshot: unknown;
+  semanticCoverage: unknown;
+  unmatchedBehaviors: unknown[];
+  runtimeContract: KinetixRuntimeContract | null;
+}
+
+export interface KinetixRuntimeContract {
+  readonly tickRate: 10 | 20 | 30 | 60;
+  readonly targetProfile: KinetixTargetProfile;
+  readonly numericProfile: string;
+  readonly deterministicAbi: string;
+  readonly deterministicVersion: string;
+  readonly inputSchema: Readonly<Record<string, unknown>>;
+  readonly stateSchema: Readonly<Record<string, unknown>>;
+}
+
+export interface KinetixSystem {
+  id: string;
+  phase: string;
+  phaseIndex: number;
+  order: number;
+}
+
+export interface KinetixProducts {
+  sourceDigest: string;
+  manifest: {
+    runtime: KinetixRuntimeContract;
+    systems: KinetixSystem[];
+    payloads: { name: string; digest: string; byteLength: number }[];
+  };
+  simulation: unknown;
+  presentation: unknown;
+  binding: unknown;
+}
+
+export interface KinetixCompilation {
+  compiled: KinetixCompiled;
+  products: KinetixProducts;
+  runtimeIdentity: import('./runtime').KinetixRuntimeIdentity;
+}
+
+export interface KinetixInstalledProfile {
+  readonly abi: string;
+  readonly runtimeContract: KinetixRuntimeContract;
+}
+
+export interface KinetixWorldHandle {
+  readonly id: string;
+}
+
+export interface KinetixWorld {
+  step(input: unknown): number;
+  snapshot(): unknown;
+  restore(snapshot: unknown): void;
+  canonicalStateBytes(): Uint8Array;
+  read(handle: KinetixWorldHandle): {
+    components: { type: string; properties: Record<string, unknown> }[];
+  };
+  directHandle(entityId: string): KinetixWorldHandle;
+}
+
+export interface KinetixRenderRecord {
+  kind: string;
+  source: string;
+  component: string;
+  transform: unknown;
+  bindingDigest: string;
+  worldTick: number;
+}
+
+export interface KinetixRenderProjection {
+  project(): KinetixRenderRecord[];
+}
+
+export interface KinetixBakeResult {
+  valid: boolean;
+  products: KinetixProducts | null;
+  runtimeIdentity: import('./runtime').KinetixRuntimeIdentity | null;
+  diagnostics: KinetixDiagnostic[];
+}
+
+export function compileKinetixProject(input: KinetixCompileInput): KinetixCompiled;
+export function compileTrustedKinetixSource(input: {
+  sourceRoot: string;
+  expectedCommit: string;
+  targetProfile: KinetixTargetProfile;
+  classifyInstalledBranches?: boolean;
+}): KinetixCompiled;
+export function kinetixCanonicalSourceDigest(sourceRoot: string): string;
+
+export function bakeKinetixEnvelope(
+  envelope: KinetixEnvelope,
+  installedProfiles: Map<string, KinetixInstalledProfile>,
+): KinetixBakeResult;
+export function bakeKinetixProjectDefinition(project: import('./authoring').KinetixProjectDeclaration): {
+  products: KinetixProducts;
+  runtimeIdentity: import('./runtime').KinetixRuntimeIdentity;
+  contentDigest: string;
+};
+
+export function encodeKinetixSessionConfig(
+  schema: import('./authoring').KinetixSessionConfigSchema,
+  value: Readonly<Record<string, unknown>>,
+): Uint8Array;
+export function decodeKinetixSessionConfig(
+  schema: import('./authoring').KinetixSessionConfigSchema,
+  bytes: Uint8Array,
+): Record<string, unknown>;
+export function kinetixSessionConfigDigest(bytes: Uint8Array): string;
+export function createInstalledF64Runtime(options: Record<string, unknown>): import('./runtime').KinetixRuntime<unknown, unknown>;
+export function createFixed1000Runtime(options: Record<string, unknown>): import('./runtime').KinetixRuntime<unknown, unknown>;
+
+export function stableKinetixProductBytes(products: KinetixProducts): Buffer;
+export function stableKinetixSourceBytes(envelope: KinetixEnvelope): Buffer;
+export function scanKinetixPayloadTree(value: unknown): void;
+export function validateInstalledKinetixProfile(profileId: string, profile: KinetixInstalledProfile): void;
+export function assertKinetixProductContract(products: KinetixProducts): KinetixProducts;
+export function assertKinetixRuntimeContract(contract: KinetixRuntimeContract): KinetixRuntimeContract;
+export function deriveKinetixRuntimeIdentity(
+  products: KinetixProducts,
+  runtimeContract?: KinetixRuntimeContract,
+): import('./runtime').KinetixRuntimeIdentity;
+export function assertKinetixRuntimeIdentityMatchesProducts(
+  products: KinetixProducts,
+  identity: import('./runtime').KinetixRuntimeIdentity,
+): import('./runtime').KinetixRuntimeIdentity;
+export const kinetixBakerVersion: string;
+export const kinetixPhases: readonly string[];
+
+export function createInstalledKinetixProfile(
+  targetProfile: KinetixTargetProfile,
+  options?: { fixedPhysics?: unknown },
+): KinetixInstalledProfile;
+export function kinetixRuntimeContractForProfile(
+  targetProfile: KinetixTargetProfile,
+): KinetixRuntimeContract;
+
+export function createKinetixWorld(options: {
+  worldId: string;
+  products: KinetixProducts;
+  installedProfiles: Map<string, KinetixInstalledProfile>;
+  initialization?: Record<string, unknown>;
+}): KinetixWorld;
+
+export function createKinetixWorldRuntime(options: {
+  world: KinetixWorld;
+  identity: import('./runtime').KinetixRuntimeIdentity;
+  sessionConfigBytes?: Uint8Array;
+}): import('./runtime').KinetixRuntime<unknown, unknown>;
+
+export function createKinetixRenderProjection(options: {
+  world: KinetixWorld;
+  products: KinetixProducts;
+}): KinetixRenderProjection;
+
+/** Compiles twice and byte-compares, so a nondeterministic product fails loudly. */
+export function compileStableKinetixProducts(input: KinetixCompileInput): KinetixCompilation;
+export function compileStableKinetixProductsFromTrustedSource(input: {
+  sourceRoot: string;
+  expectedCommit: string;
+  targetProfile: KinetixTargetProfile;
+}): KinetixCompilation;
+export function nativeFixed1000ProductBytes(products: KinetixProducts, pack: unknown): Buffer;
+
+export function createFixedRuntime(pack: unknown, physics: unknown): unknown;
+export function tickFixedRuntime(runtime: unknown, slots: unknown): void;
+export function canonicalFixedStateBytes(runtime: unknown): Uint8Array;
+export function canonicalFixedTickHash(runtime: unknown): string;
+
+export function runF64Replay(
+  pack: unknown,
+  replay: unknown,
+  options?: { hashEveryTick?: boolean },
+): { tickHashes: string[]; finalDigest: string; metrics: unknown };
+export function canonicalF64TickHash(runtime: unknown): string;
+
+/** Builds the portable C++ core and returns the binary path. */
+export function buildNative(): string;

package/native/component_runtime.cpp

@@ -0,0 +1,341 @@
+#include "component_runtime.hpp"
+
+#include <array>
+#include <cstring>
+
+namespace rundot {
+
+namespace {
+
+// Minimal SHA-256 (FIPS 180-4), streaming, no dependencies.
+struct Sha256 {
+  std::uint32_t state[8];
+  std::uint64_t bitLength = 0;
+  std::uint8_t buffer[64];
+  std::size_t bufferLength = 0;
+
+  Sha256() { reset(); }
+
+  void reset() {
+    static constexpr std::uint32_t kInit[8] = {
+        0x6a09e667u, 0xbb67ae85u, 0x3c6ef372u, 0xa54ff53au,
+        0x510e527fu, 0x9b05688cu, 0x1f83d9abu, 0x5be0cd19u,
+    };
+    std::memcpy(state, kInit, sizeof(kInit));
+    bitLength = 0;
+    bufferLength = 0;
+  }
+
+  static std::uint32_t rotr(std::uint32_t value, std::uint32_t bits) {
+    return (value >> bits) | (value << (32 - bits));
+  }
+
+  void transform(const std::uint8_t* chunk) {
+    static constexpr std::uint32_t kRound[64] = {
+        0x428a2f98u, 0x71374491u, 0xb5c0fbcfu, 0xe9b5dba5u, 0x3956c25bu, 0x59f111f1u, 0x923f82a4u, 0xab1c5ed5u,
+        0xd807aa98u, 0x12835b01u, 0x243185beu, 0x550c7dc3u, 0x72be5d74u, 0x80deb1feu, 0x9bdc06a7u, 0xc19bf174u,
+        0xe49b69c1u, 0xefbe4786u, 0x0fc19dc6u, 0x240ca1ccu, 0x2de92c6fu, 0x4a7484aau, 0x5cb0a9dcu, 0x76f988dau,
+        0x983e5152u, 0xa831c66du, 0xb00327c8u, 0xbf597fc7u, 0xc6e00bf3u, 0xd5a79147u, 0x06ca6351u, 0x14292967u,
+        0x27b70a85u, 0x2e1b2138u, 0x4d2c6dfcu, 0x53380d13u, 0x650a7354u, 0x766a0abbu, 0x81c2c92eu, 0x92722c85u,
+        0xa2bfe8a1u, 0xa81a664bu, 0xc24b8b70u, 0xc76c51a3u, 0xd192e819u, 0xd6990624u, 0xf40e3585u, 0x106aa070u,
+        0x19a4c116u, 0x1e376c08u, 0x2748774cu, 0x34b0bcb5u, 0x391c0cb3u, 0x4ed8aa4au, 0x5b9cca4fu, 0x682e6ff3u,
+        0x748f82eeu, 0x78a5636fu, 0x84c87814u, 0x8cc70208u, 0x90befffau, 0xa4506cebu, 0xbef9a3f7u, 0xc67178f2u,
+    };
+    std::uint32_t schedule[64];
+    for (int i = 0; i < 16; ++i) {
+      schedule[i] = (static_cast<std::uint32_t>(chunk[i * 4]) << 24) |
+                    (static_cast<std::uint32_t>(chunk[i * 4 + 1]) << 16) |
+                    (static_cast<std::uint32_t>(chunk[i * 4 + 2]) << 8) |
+                    static_cast<std::uint32_t>(chunk[i * 4 + 3]);
+    }
+    for (int i = 16; i < 64; ++i) {
+      const std::uint32_t s0 = rotr(schedule[i - 15], 7) ^ rotr(schedule[i - 15], 18) ^ (schedule[i - 15] >> 3);
+      const std::uint32_t s1 = rotr(schedule[i - 2], 17) ^ rotr(schedule[i - 2], 19) ^ (schedule[i - 2] >> 10);
+      schedule[i] = schedule[i - 16] + s0 + schedule[i - 7] + s1;
+    }
+    std::uint32_t a = state[0], b = state[1], c = state[2], d = state[3];
+    std::uint32_t e = state[4], f = state[5], g = state[6], h = state[7];
+    for (int i = 0; i < 64; ++i) {
+      const std::uint32_t s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const std::uint32_t ch = (e & f) ^ (~e & g);
+      const std::uint32_t temp1 = h + s1 + ch + kRound[i] + schedule[i];
+      const std::uint32_t s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const std::uint32_t maj = (a & b) ^ (a & c) ^ (b & c);
+      const std::uint32_t temp2 = s0 + maj;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2;
+    }
+    state[0] += a; state[1] += b; state[2] += c; state[3] += d;
+    state[4] += e; state[5] += f; state[6] += g; state[7] += h;
+  }
+
+  void update(const std::uint8_t* data, std::size_t size) {
+    bitLength += static_cast<std::uint64_t>(size) * 8u;
+    while (size > 0) {
+      const std::size_t take = std::min<std::size_t>(64 - bufferLength, size);
+      std::memcpy(buffer + bufferLength, data, take);
+      bufferLength += take;
+      data += take;
+      size -= take;
+      if (bufferLength == 64) {
+        transform(buffer);
+        bufferLength = 0;
+      }
+    }
+  }
+
+  std::array<std::uint8_t, 32> digest() {
+    std::array<std::uint8_t, 32> out{};
+    const std::uint64_t finalBitLength = bitLength;
+    buffer[bufferLength++] = 0x80;
+    if (bufferLength > 56) {
+      while (bufferLength < 64) buffer[bufferLength++] = 0x00;
+      transform(buffer);
+      bufferLength = 0;
+    }
+    while (bufferLength < 56) buffer[bufferLength++] = 0x00;
+    for (int i = 0; i < 8; ++i) {
+      buffer[56 + i] = static_cast<std::uint8_t>((finalBitLength >> (56 - i * 8)) & 0xffu);
+    }
+    transform(buffer);
+    for (int i = 0; i < 8; ++i) {
+      out[i * 4] = static_cast<std::uint8_t>((state[i] >> 24) & 0xffu);
+      out[i * 4 + 1] = static_cast<std::uint8_t>((state[i] >> 16) & 0xffu);
+      out[i * 4 + 2] = static_cast<std::uint8_t>((state[i] >> 8) & 0xffu);
+      out[i * 4 + 3] = static_cast<std::uint8_t>(state[i] & 0xffu);
+    }
+    return out;
+  }
+};
+
+std::string toHex(const std::array<std::uint8_t, 32>& digest) {
+  static constexpr char kHex[] = "0123456789abcdef";
+  std::string out;
+  out.resize(64);
+  for (std::size_t i = 0; i < digest.size(); ++i) {
+    out[i * 2] = kHex[(digest[i] >> 4) & 0x0f];
+    out[i * 2 + 1] = kHex[digest[i] & 0x0f];
+  }
+  return out;
+}
+
+void appendU32(std::vector<std::uint8_t>& buffer, std::uint32_t value) {
+  buffer.push_back(static_cast<std::uint8_t>(value & 0xffu));
+  buffer.push_back(static_cast<std::uint8_t>((value >> 8) & 0xffu));
+  buffer.push_back(static_cast<std::uint8_t>((value >> 16) & 0xffu));
+  buffer.push_back(static_cast<std::uint8_t>((value >> 24) & 0xffu));
+}
+
+void appendU64(std::vector<std::uint8_t>& buffer, std::uint64_t value) {
+  for (int i = 0; i < 8; ++i) {
+    buffer.push_back(static_cast<std::uint8_t>((value >> (i * 8)) & 0xffu));
+  }
+}
+
+void appendI64(std::vector<std::uint8_t>& buffer, std::int64_t value) {
+  appendU64(buffer, static_cast<std::uint64_t>(value));
+}
+
+void appendString(std::vector<std::uint8_t>& buffer, const std::string& value) {
+  appendU32(buffer, static_cast<std::uint32_t>(value.size()));
+  buffer.insert(buffer.end(), value.begin(), value.end());
+}
+
+void appendTickState(std::vector<std::uint8_t>& buffer, const std::vector<EntityState>& entities, std::int64_t tick) {
+  appendU64(buffer, static_cast<std::uint64_t>(tick));
+  for (const EntityState& entity : entities) {
+    appendString(buffer, entity.id);
+    for (const ComponentRecord& record : entity.components) {
+      switch (record.type) {
+        case ComponentType::Transform: {
+          appendString(buffer, "Transform");
+          const TransformState& transform = entity.transform;
+          appendI64(buffer, transform.position.x);
+          appendI64(buffer, transform.position.y);
+          appendI64(buffer, transform.position.z);
+          appendI64(buffer, transform.rotation.x);
+          appendI64(buffer, transform.rotation.y);
+          appendI64(buffer, transform.rotation.z);
+          appendI64(buffer, transform.scale.x);
+          appendI64(buffer, transform.scale.y);
+          appendI64(buffer, transform.scale.z);
+          break;
+        }
+        case ComponentType::FixedTickMover: {
+          appendString(buffer, "FixedTickMover");
+          const MoverState& mover = entity.movers[record.index];
+          appendI64(buffer, mover.velocityPerTick.x);
+          appendI64(buffer, mover.velocityPerTick.y);
+          appendI64(buffer, mover.velocityPerTick.z);
+          break;
+        }
+        case ComponentType::InputActionState: {
+          appendString(buffer, "InputActionState");
+          const InputState& input = entity.inputs[record.index];
+          appendString(buffer, input.actionId);
+          appendString(buffer, input.outputField);
+          buffer.push_back(input.pressed ? 1 : 0);
+          appendI64(buffer, input.lastEdgeTick);
+          break;
+        }
+        case ComponentType::ReplicatedState: {
+          appendString(buffer, "ReplicatedState");
+          appendString(buffer, entity.replicated.authority);
+          appendU32(buffer, static_cast<std::uint32_t>(entity.replicated.fields.size()));
+          for (const std::string& field : entity.replicated.fields) {
+            appendString(buffer, field);
+          }
+          break;
+        }
+      }
+    }
+  }
+}
+
+bool checkedAdd(std::int64_t left, std::int64_t right, std::int64_t& out) {
+  return !__builtin_add_overflow(left, right, &out);
+}
+
+}  // namespace
+
+std::string sha256Hex(const std::uint8_t* data, std::size_t size) {
+  Sha256 hasher;
+  hasher.update(data, size);
+  return toHex(hasher.digest());
+}
+
+RunResult runReplay(std::vector<EntityState>& entities, const Replay& replay, bool hashEveryTick) {
+  RunResult result;
+  Sha256 streamHash;
+  std::vector<std::uint8_t> tickBuffer;
+  tickBuffer.reserve(4096 + entities.size() * 256);
+  if (hashEveryTick) {
+    result.tickHashes.reserve(static_cast<std::size_t>(replay.tickCount));
+  }
+
+  std::size_t actionCursor = 0;
+  std::size_t correctionCursor = 0;
+
+  for (std::int64_t tick = 0; tick < replay.tickCount; ++tick) {
+    while (correctionCursor < replay.corrections.size() && replay.corrections[correctionCursor].tick == tick) {
+      const ReplayCorrection& correction = replay.corrections[correctionCursor];
+      ++correctionCursor;
+      EntityState* target = nullptr;
+      for (EntityState& entity : entities) {
+        if (entity.id == correction.entityId) {
+          target = &entity;
+          break;
+        }
+      }
+      if (target == nullptr) {
+        result.faulted = true;
+        result.fault = {"COMPONENT_RUNTIME_CORRECTION_UNKNOWN_ENTITY", tick, correction.entityId};
+        return result;
+      }
+      if (!target->hasReplicated) {
+        result.faulted = true;
+        result.fault = {"COMPONENT_RUNTIME_CORRECTION_NOT_REPLICATED", tick, correction.entityId};
+        return result;
+      }
+      for (const CorrectionField& field : correction.fields) {
+        bool allowed = false;
+        for (const std::string& allowedField : target->replicated.fields) {
+          if (allowedField == field.field) {
+            allowed = true;
+            break;
+          }
+        }
+        if (!allowed) {
+          result.faulted = true;
+          result.fault = {"COMPONENT_RUNTIME_CORRECTION_FIELD_NOT_ALLOWED", tick, correction.entityId};
+          return result;
+        }
+        if (field.field == "position" || field.field == "rotation" || field.field == "scale") {
+          if (!target->hasTransform) {
+            result.faulted = true;
+            result.fault = {"COMPONENT_RUNTIME_CORRECTION_NO_TRANSFORM", tick, correction.entityId};
+            return result;
+          }
+          if (field.field == "position") target->transform.position = field.vec;
+          else if (field.field == "rotation") target->transform.rotation = field.vec;
+          else target->transform.scale = field.vec;
+          continue;
+        }
+        bool matched = false;
+        for (InputState& input : target->inputs) {
+          if (input.outputField == field.field) {
+            matched = true;
+            if (input.pressed != field.boolValue) {
+              input.pressed = field.boolValue;
+              input.lastEdgeTick = tick;
+            }
+          }
+        }
+        if (!matched) {
+          result.faulted = true;
+          result.fault = {"COMPONENT_RUNTIME_CORRECTION_FIELD_UNKNOWN", tick, correction.entityId};
+          return result;
+        }
+      }
+    }
+
+    while (actionCursor < replay.actions.size() && replay.actions[actionCursor].tick == tick) {
+      const ReplayAction& action = replay.actions[actionCursor];
+      ++actionCursor;
+      for (EntityState& entity : entities) {
+        for (InputState& input : entity.inputs) {
+          if (input.actionId != action.actionId) continue;
+          if (input.pressed != action.pressed) {
+            input.pressed = action.pressed;
+            input.lastEdgeTick = tick;
+          }
+        }
+      }
+    }
+
+    for (EntityState& entity : entities) {
+      for (const MoverState& mover : entity.movers) {
+        if (!entity.hasTransform) {
+          result.faulted = true;
+          result.fault = {"COMPONENT_RUNTIME_MOVER_NO_TRANSFORM", tick, entity.id};
+          return result;
+        }
+        std::int64_t x = 0;
+        std::int64_t y = 0;
+        std::int64_t z = 0;
+        if (!checkedAdd(entity.transform.position.x, mover.velocityPerTick.x, x) ||
+            !checkedAdd(entity.transform.position.y, mover.velocityPerTick.y, y) ||
+            !checkedAdd(entity.transform.position.z, mover.velocityPerTick.z, z)) {
+          result.faulted = true;
+          result.fault = {"COMPONENT_RUNTIME_OVERFLOW", tick, entity.id};
+          return result;
+        }
+        entity.transform.position = {x, y, z};
+      }
+    }
+
+    if (hashEveryTick || tick == replay.tickCount - 1) {
+      tickBuffer.clear();
+      appendTickState(tickBuffer, entities, tick);
+      const std::string tickHash = sha256Hex(tickBuffer.data(), tickBuffer.size());
+      if (hashEveryTick) {
+        result.tickHashes.push_back(tickHash);
+      } else {
+        result.tickHashes.assign(1, tickHash);
+      }
+      streamHash.update(reinterpret_cast<const std::uint8_t*>(tickHash.data()), tickHash.size());
+    }
+    result.completedTicks += 1;
+  }
+
+  result.finalDigest = toHex(streamHash.digest());
+  return result;
+}
+
+}  // namespace rundot