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

package/native/deterministic_math.hpp

@@ -0,0 +1,21 @@
+// Deterministic-f64 math for the component runtime: C++ transliteration of the
+// fdlibm-style JS shim (kinetix-deterministic-math.mjs). Every function must be
+// bit-identical to the JS implementation for all finite inputs — verified by the
+// parity battery (deterministic-f64-battery.mjs vs
+// deterministic-math-battery-main.cpp).
+//
+// Compile with FMA contraction disabled (-ffp-contract=off): the algorithms
+// depend on exact IEEE double rounding of each written operation.
+#pragma once
+
+namespace rundot::detmath {
+
+double det_sin(double x);
+double det_cos(double x);
+double det_atan(double x);
+double det_atan2(double y, double x);
+double det_exp(double x);
+double det_log(double x);
+double det_hypot2(double x, double y);
+
+}  // namespace rundot::detmath

package/native/kinetix-f64-native-profile.cpp

@@ -0,0 +1,406 @@
+// Headless native proof executable for the deterministic-f64 component
+// runtime (pack v2). Loads a component pack plus a replay, runs the fixed-tick
+// simulation, and writes per-tick canonical hashes and metrics. Usage:
+//   component-runtime-f64-main <component-pack.json> <replay.json> <outDir> [hashEveryTick 0|1] [--render-frames]
+//
+// With --render-frames it additionally renders after each tick with
+// tick % 2 == 1 (matching render-frames-node.mjs), writing
+// outDir/frame-%03d.rgb raw RGB24 frames plus outDir/frame-hashes.json.
+
+#include <bit>
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "kinetix-installed-f64-renderer.hpp"
+#include "kinetix-installed-f64-runtime.hpp"
+#include "kinetix-f64-native-profile.hpp"
+
+namespace {
+
+// Minimal recursive-descent JSON parser: exactly what the fixed pack/replay
+// schemas need (objects, arrays, strings, numbers, bools, null).
+struct JsonValue {
+  enum class Kind { Object, Array, String, Number, Bool, Null } kind = Kind::Null;
+  std::map<std::string, std::shared_ptr<JsonValue>> object;
+  std::vector<std::shared_ptr<JsonValue>> array;
+  std::string string;
+  double number = 0;
+  bool boolean = false;
+};
+
+using JsonPtr = std::shared_ptr<JsonValue>;
+
+struct JsonParser {
+  const std::string& text;
+  std::size_t cursor = 0;
+
+  explicit JsonParser(const std::string& source) : text(source) {}
+
+  [[noreturn]] void fail(const std::string& message) {
+    std::cerr << "JSON parse error at offset " << cursor << ": " << message << "\n";
+    std::exit(2);
+  }
+
+  void skipWhitespace() {
+    while (cursor < text.size() && (text[cursor] == ' ' || text[cursor] == '\n' || text[cursor] == '\t' || text[cursor] == '\r')) {
+      ++cursor;
+    }
+  }
+
+  char peek() {
+    if (cursor >= text.size()) fail("unexpected end of input");
+    return text[cursor];
+  }
+
+  void expect(char expected) {
+    if (peek() != expected) fail(std::string("expected '") + expected + "'");
+    ++cursor;
+  }
+
+  JsonPtr parseValue() {
+    skipWhitespace();
+    const char head = peek();
+    if (head == '{') return parseObject();
+    if (head == '[') return parseArray();
+    if (head == '"') return parseString();
+    if (head == 't' || head == 'f') return parseBool();
+    if (head == 'n') return parseNull();
+    return parseNumber();
+  }
+
+  JsonPtr parseObject() {
+    auto value = std::make_shared<JsonValue>();
+    value->kind = JsonValue::Kind::Object;
+    expect('{');
+    skipWhitespace();
+    if (peek() == '}') { ++cursor; return value; }
+    while (true) {
+      skipWhitespace();
+      JsonPtr key = parseString();
+      skipWhitespace();
+      expect(':');
+      value->object[key->string] = parseValue();
+      skipWhitespace();
+      if (peek() == ',') { ++cursor; continue; }
+      expect('}');
+      return value;
+    }
+  }
+
+  JsonPtr parseArray() {
+    auto value = std::make_shared<JsonValue>();
+    value->kind = JsonValue::Kind::Array;
+    expect('[');
+    skipWhitespace();
+    if (peek() == ']') { ++cursor; return value; }
+    while (true) {
+      value->array.push_back(parseValue());
+      skipWhitespace();
+      if (peek() == ',') { ++cursor; continue; }
+      expect(']');
+      return value;
+    }
+  }
+
+  JsonPtr parseString() {
+    auto value = std::make_shared<JsonValue>();
+    value->kind = JsonValue::Kind::String;
+    expect('"');
+    std::string out;
+    while (true) {
+      if (cursor >= text.size()) fail("unterminated string");
+      const char ch = text[cursor++];
+      if (ch == '"') break;
+      if (ch == '\\') {
+        if (cursor >= text.size()) fail("unterminated escape");
+        const char escape = text[cursor++];
+        switch (escape) {
+          case '"': out.push_back('"'); break;
+          case '\\': out.push_back('\\'); break;
+          case '/': out.push_back('/'); break;
+          case 'b': out.push_back('\b'); break;
+          case 'f': out.push_back('\f'); break;
+          case 'n': out.push_back('\n'); break;
+          case 'r': out.push_back('\r'); break;
+          case 't': out.push_back('\t'); break;
+          case 'u': {
+            if (cursor + 4 > text.size()) fail("bad unicode escape");
+            const std::string hex = text.substr(cursor, 4);
+            cursor += 4;
+            const unsigned code = static_cast<unsigned>(std::strtoul(hex.c_str(), nullptr, 16));
+            if (code < 0x80) {
+              out.push_back(static_cast<char>(code));
+            } else if (code < 0x800) {
+              out.push_back(static_cast<char>(0xc0 | (code >> 6)));
+              out.push_back(static_cast<char>(0x80 | (code & 0x3f)));
+            } else {
+              out.push_back(static_cast<char>(0xe0 | (code >> 12)));
+              out.push_back(static_cast<char>(0x80 | ((code >> 6) & 0x3f)));
+              out.push_back(static_cast<char>(0x80 | (code & 0x3f)));
+            }
+            break;
+          }
+          default: fail("unsupported escape");
+        }
+        continue;
+      }
+      out.push_back(ch);
+    }
+    value->string = out;
+    return value;
+  }
+
+  JsonPtr parseBool() {
+    auto value = std::make_shared<JsonValue>();
+    value->kind = JsonValue::Kind::Bool;
+    if (text.compare(cursor, 4, "true") == 0) { value->boolean = true; cursor += 4; return value; }
+    if (text.compare(cursor, 5, "false") == 0) { value->boolean = false; cursor += 5; return value; }
+    fail("invalid literal");
+  }
+
+  JsonPtr parseNull() {
+    auto value = std::make_shared<JsonValue>();
+    if (text.compare(cursor, 4, "null") == 0) { cursor += 4; return value; }
+    fail("invalid literal");
+  }
+
+  JsonPtr parseNumber() {
+    auto value = std::make_shared<JsonValue>();
+    value->kind = JsonValue::Kind::Number;
+    const std::size_t start = cursor;
+    if (peek() == '-') ++cursor;
+    while (cursor < text.size() && ((text[cursor] >= '0' && text[cursor] <= '9') || text[cursor] == '.' || text[cursor] == 'e' || text[cursor] == 'E' || text[cursor] == '+' || text[cursor] == '-')) {
+      ++cursor;
+    }
+    value->number = std::strtod(text.substr(start, cursor - start).c_str(), nullptr);
+    return value;
+  }
+};
+
+[[noreturn]] void fatal(const std::string& message) {
+  std::cerr << message << "\n";
+  std::exit(2);
+}
+
+std::string readFile(const std::string& path) {
+  std::ifstream stream(path, std::ios::binary);
+  if (!stream) fatal("cannot open " + path);
+  std::ostringstream out;
+  out << stream.rdbuf();
+  return out.str();
+}
+
+const JsonPtr& objectField(const JsonPtr& value, const std::string& key) {
+  const auto found = value->object.find(key);
+  if (found == value->object.end()) fatal("missing field " + key);
+  return found->second;
+}
+
+bool isF64Hex(const std::string& value) {
+  if (value.size() != 18 || value[0] != '0' || value[1] != 'x') return false;
+  for (std::size_t index = 2; index < value.size(); ++index) {
+    const char ch = value[index];
+    if (!((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f'))) return false;
+  }
+  return true;
+}
+
+double f64FromHex(const std::string& hex) {
+  if (!isF64Hex(hex)) fatal("invalid f64 hex scalar " + hex);
+  const std::uint64_t bits = std::strtoull(hex.c_str() + 2, nullptr, 16);
+  return std::bit_cast<double>(bits);
+}
+
+rundot::f64rt::Vec2 parseVec2Hex(const JsonPtr& value) {
+  if (value->kind != JsonValue::Kind::Array || value->array.size() != 2) fatal("expected [x, y] f64 hex pair");
+  return {f64FromHex(value->array[0]->string), f64FromHex(value->array[1]->string)};
+}
+
+rundot::f64rt::PropertyValue toProperty(const JsonPtr& value) {
+  rundot::f64rt::PropertyValue property;
+  switch (value->kind) {
+    case JsonValue::Kind::String:
+      if (isF64Hex(value->string)) {
+        property.kind = rundot::f64rt::PropertyValue::Kind::F64;
+        property.f64 = f64FromHex(value->string);
+      } else {
+        property.kind = rundot::f64rt::PropertyValue::Kind::String;
+        property.str = value->string;
+      }
+      return property;
+    case JsonValue::Kind::Array:
+      property.kind = rundot::f64rt::PropertyValue::Kind::Vec2;
+      property.vec2 = parseVec2Hex(value);
+      return property;
+    case JsonValue::Kind::Number:
+      property.kind = rundot::f64rt::PropertyValue::Kind::Int;
+      property.i64 = static_cast<std::int64_t>(value->number);
+      return property;
+    case JsonValue::Kind::Bool:
+      property.kind = rundot::f64rt::PropertyValue::Kind::Bool;
+      property.boolean = value->boolean;
+      return property;
+    default:
+      fatal("unsupported property value kind");
+  }
+}
+
+std::vector<rundot::f64rt::ComponentDef> parseComponents(const JsonPtr& componentsJson) {
+  std::vector<rundot::f64rt::ComponentDef> components;
+  for (const JsonPtr& componentJson : componentsJson->array) {
+    rundot::f64rt::ComponentDef component;
+    component.type = objectField(componentJson, "type")->string;
+    for (const auto& [name, propertyJson] : objectField(componentJson, "properties")->object) {
+      component.properties[name] = toProperty(propertyJson);
+    }
+    components.push_back(std::move(component));
+  }
+  return components;
+}
+
+rundot::f64rt::PackDef parsePack(const JsonPtr& packJson) {
+  rundot::f64rt::PackDef pack;
+  pack.inputSlots = static_cast<std::int64_t>(objectField(packJson, "inputSlots")->number);
+  pack.maxSpawnsPerTick = static_cast<std::int64_t>(objectField(objectField(packJson, "budgets"), "maxSpawnsPerTick")->number);
+  for (const JsonPtr& streamJson : objectField(packJson, "rngStreams")->array) {
+    rundot::f64rt::RngStreamDef stream;
+    stream.id = objectField(streamJson, "id")->string;
+    stream.seed = static_cast<std::uint32_t>(objectField(streamJson, "seed")->number);
+    pack.rngStreams.push_back(std::move(stream));
+  }
+  for (const JsonPtr& ruleJson : objectField(packJson, "collisionRules")->array) {
+    rundot::f64rt::CollisionRuleDef rule;
+    rule.layerA = objectField(ruleJson, "layerA")->string;
+    rule.layerB = objectField(ruleJson, "layerB")->string;
+    rule.action = objectField(ruleJson, "action")->string;
+    pack.collisionRules.push_back(std::move(rule));
+  }
+  for (const JsonPtr& templateJson : objectField(packJson, "templates")->array) {
+    rundot::f64rt::TemplateDef templateDef;
+    templateDef.id = objectField(templateJson, "id")->string;
+    templateDef.pool = static_cast<std::int64_t>(objectField(templateJson, "pool")->number);
+    templateDef.components = parseComponents(objectField(templateJson, "components"));
+    pack.templates.push_back(std::move(templateDef));
+  }
+  for (const JsonPtr& entityJson : objectField(packJson, "entities")->array) {
+    rundot::f64rt::EntityDef entity;
+    entity.id = objectField(entityJson, "id")->string;
+    entity.components = parseComponents(objectField(entityJson, "components"));
+    pack.entities.push_back(std::move(entity));
+  }
+  return pack;
+}
+
+rundot::f64rt::ReplayDef parseReplay(const JsonPtr& replayJson) {
+  rundot::f64rt::ReplayDef replay;
+  replay.tickCount = static_cast<std::int64_t>(objectField(replayJson, "tickCount")->number);
+  for (const JsonPtr& frameJson : objectField(replayJson, "inputFrames")->array) {
+    rundot::f64rt::InputFrameDef frame;
+    frame.tick = static_cast<std::int64_t>(objectField(frameJson, "tick")->number);
+    for (const JsonPtr& slotJson : objectField(frameJson, "slots")->array) {
+      rundot::f64rt::SlotInputDef slot;
+      slot.movement = parseVec2Hex(objectField(slotJson, "movement"));
+      slot.aim = parseVec2Hex(objectField(slotJson, "aim"));
+      slot.fire = objectField(slotJson, "fire")->kind == JsonValue::Kind::Bool && objectField(slotJson, "fire")->boolean;
+      frame.slots.push_back(slot);
+    }
+    replay.inputFrames.push_back(std::move(frame));
+  }
+  return replay;
+}
+
+}  // namespace
+
+int rundot::kinetix::RunF64Profile(int argc, char** argv) {
+  if (argc < 4) {
+    std::cerr << "usage: component-runtime-f64-main <component-pack.json> <replay.json> <outDir> [hashEveryTick 0|1] [--render-frames]\n";
+    return 2;
+  }
+  const std::string packPath = argv[1];
+  const std::string replayPath = argv[2];
+  const std::string outDir = argv[3];
+  const bool hashEveryTick = argc < 5 || std::string(argv[4]) != "0";
+  const bool renderFrames = argc >= 6 && std::string(argv[5]) == "--render-frames";
+
+  const std::string packText = readFile(packPath);
+  const std::string replayText = readFile(replayPath);
+  JsonParser packParser(packText);
+  JsonParser replayParser(replayText);
+  const JsonPtr packJson = packParser.parseValue();
+  const JsonPtr replayJson = replayParser.parseValue();
+
+  const rundot::f64rt::PackDef pack = parsePack(packJson);
+  const rundot::f64rt::ReplayDef replay = parseReplay(replayJson);
+
+  rundot::f64rt::F64RunResult result;
+  std::vector<std::string> frameHashes;
+  const auto startedAt = std::chrono::steady_clock::now();
+  try {
+    if (renderFrames) {
+      rundot::f64rt::F64FrameDumpResult dump = rundot::f64rt::runReplayF64WithFrames(pack, replay, hashEveryTick, outDir);
+      result = std::move(dump.run);
+      frameHashes = std::move(dump.frameHashes);
+    } else {
+      result = rundot::f64rt::runReplayF64(pack, replay, hashEveryTick);
+    }
+  } catch (const std::exception& error) {
+    fatal(error.what());
+  }
+  const auto finishedAt = std::chrono::steady_clock::now();
+  const double elapsedMs = std::chrono::duration<double, std::milli>(finishedAt - startedAt).count();
+
+  std::ofstream hashStream(outDir + "/tick-hashes.txt", std::ios::binary);
+  if (!hashStream) fatal("cannot write tick hashes in " + outDir);
+  for (const std::string& tickHash : result.tickHashes) {
+    hashStream << tickHash << "\n";
+  }
+  hashStream.close();
+
+  const std::int64_t ticksPerSecond = elapsedMs > 0
+      ? static_cast<std::int64_t>(std::llround(static_cast<double>(result.completedTicks) / elapsedMs * 1000.0))
+      : 0;
+  std::ostringstream metrics;
+  metrics << "{";
+  metrics << "\"runtime\":\"portable-cpp-f64\",";
+  metrics << "\"tickCount\":" << result.completedTicks << ",";
+  metrics << "\"elapsedMs\":" << elapsedMs << ",";
+  metrics << "\"ticksPerSecond\":" << ticksPerSecond << ",";
+  metrics << "\"liveEntitiesAtEnd\":" << result.liveEntitiesAtEnd << ",";
+  metrics << "\"finalScore\":\"" << result.finalScore << "\",";
+  metrics << "\"shipDeaths\":\"" << result.shipDeaths << "\",";
+  metrics << "\"finalDigest\":\"" << result.finalDigest << "\"";
+  metrics << "}\n";
+  std::ofstream metricsStream(outDir + "/metrics.json", std::ios::binary);
+  if (!metricsStream) fatal("cannot write metrics in " + outDir);
+  metricsStream << metrics.str();
+  metricsStream.close();
+
+  if (renderFrames) {
+    std::ostringstream framesJson;
+    framesJson << "{\"width\":" << rundot::f64rt::kFrameWidth;
+    framesJson << ",\"height\":" << rundot::f64rt::kFrameHeight;
+    framesJson << ",\"frames\":" << frameHashes.size();
+    framesJson << ",\"hashes\":[";
+    for (std::size_t index = 0; index < frameHashes.size(); ++index) {
+      if (index > 0) framesJson << ",";
+      framesJson << "\"" << frameHashes[index] << "\"";
+    }
+    framesJson << "]}\n";
+    std::ofstream framesStream(outDir + "/frame-hashes.json", std::ios::binary);
+    if (!framesStream) fatal("cannot write frame hashes in " + outDir);
+    framesStream << framesJson.str();
+    framesStream.close();
+  }
+
+  std::cout << metrics.str();
+  return 0;
+}

package/native/kinetix-f64-native-profile.hpp

@@ -0,0 +1,5 @@
+#pragma once
+
+namespace rundot::kinetix {
+int RunF64Profile(int argc, char** argv);
+}