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

package/native/kinetix-installed-f64-runtime.hpp

@@ -0,0 +1,141 @@
+// Portable C++20 deterministic-f64 component runtime (pack v2). Transliterates
+// component-reference-runtime-f64.mjs exactly: same phase order, same entity
+// iteration order, same floating-point expression shapes, same RNG consumption
+// order. Per-tick canonical hashes must be bit-identical to the TS reference.
+#pragma once
+
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace rundot::f64rt {
+
+struct Vec2 {
+  double x = 0.0;
+  double y = 0.0;
+};
+
+// Decoded pack property value. Main classifies JSON shapes: f64 bit-pattern
+// hex strings decode to F64, [hex, hex] pairs to Vec2, plain strings stay
+// String, JSON numbers become Int, booleans Bool.
+struct PropertyValue {
+  enum class Kind { F64, Vec2, String, Int, Bool };
+  Kind kind = Kind::Int;
+  double f64 = 0.0;
+  Vec2 vec2{};
+  std::string str;
+  std::int64_t i64 = 0;
+  bool boolean = false;
+};
+
+struct ComponentDef {
+  std::string type;
+  std::map<std::string, PropertyValue> properties;
+};
+
+struct EntityDef {
+  std::string id;
+  std::vector<ComponentDef> components;
+};
+
+struct TemplateDef {
+  std::string id;
+  std::int64_t pool = 0;
+  std::vector<ComponentDef> components;
+};
+
+struct RngStreamDef {
+  std::string id;
+  std::uint32_t seed = 0;
+};
+
+struct CollisionRuleDef {
+  std::string layerA;
+  std::string layerB;
+  std::string action;
+};
+
+struct PackDef {
+  std::int64_t inputSlots = 0;
+  std::int64_t maxSpawnsPerTick = 0;
+  std::vector<RngStreamDef> rngStreams;
+  std::vector<CollisionRuleDef> collisionRules;
+  std::vector<TemplateDef> templates;
+  std::vector<EntityDef> entities;
+};
+
+struct SlotInputDef {
+  Vec2 movement{};
+  Vec2 aim{};
+  bool fire = false;
+};
+
+struct InputFrameDef {
+  std::int64_t tick = 0;
+  std::vector<SlotInputDef> slots;
+};
+
+struct ReplayDef {
+  std::int64_t tickCount = 0;
+  std::vector<InputFrameDef> inputFrames;
+};
+
+struct F64RunResult {
+  std::vector<std::string> tickHashes;
+  std::string finalDigest;
+  std::int64_t completedTicks = 0;
+  std::int64_t liveEntitiesAtEnd = 0;
+  std::int64_t finalScore = 0;
+  std::int64_t shipDeaths = 0;
+};
+
+F64RunResult runReplayF64(const PackDef& pack, const ReplayDef& replay, bool hashEveryTick);
+
+// Render-facing event log entry for the current tick (mirrors the JS
+// runtime.frameEvents: 'spawned' pushed in spawnFromTemplate after setup,
+// 'enemy-killed'/'ship-death' pushed at the top of handleDeathEvents).
+// Not part of canonical state or hashing.
+struct FrameEventDef {
+  std::string type;
+  std::string ref;
+  double x = 0.0;
+  double y = 0.0;
+};
+
+// Snapshot of one live entity for render view building (JS liveEntities
+// order: all static entities in pack order, then alive pooled entities in
+// ascending spawnId).
+struct SimEntityView {
+  std::string ref;
+  std::uint64_t spawnId = 0;
+  bool hasTransform = false;
+  double x = 0.0;
+  double y = 0.0;
+  double vx = 0.0;
+  double vy = 0.0;
+  double heading = 0.0;
+  bool hasTelegraph = false;
+  double telegraphRemaining = 0.0;
+};
+
+// Tick-at-a-time driver over the same internal runtime that runReplayF64
+// uses. The pack must outlive the stepper.
+class F64SimStepper {
+ public:
+  explicit F64SimStepper(const PackDef& pack);
+  ~F64SimStepper();
+  F64SimStepper(const F64SimStepper&) = delete;
+  F64SimStepper& operator=(const F64SimStepper&) = delete;
+
+  void tick(const std::vector<SlotInputDef>& inputs);
+  void liveView(std::vector<SimEntityView>& out);
+  const std::vector<FrameEventDef>& frameEvents() const;
+
+ private:
+  struct Impl;
+  std::unique_ptr<Impl> impl_;
+};
+
+}  // namespace rundot::f64rt

package/native/kinetix-installed-fixed1000-data.hpp

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace rundot::kinetix::fixed1000_data {
+using I = std::int64_t;
+inline constexpr std::size_t kMaxSlots = 8;
+struct Cell { I gridX, gridZ, typeId, orientation; };
+
+inline std::string kTrack;
+inline I kScale = 0;
+inline I kSlotCount = 0;
+inline I kHumanCount = 0;
+inline I kInitialPhase = 0;
+inline std::vector<Cell> kCells;
+inline I kCellRaw = 0;
+inline I kGridScale = 0;
+inline I kFinishTypeId = 0;
+inline I kMaxSpeed = 0;
+inline I kAccelRate = 0;
+inline I kBrakeRate = 0;
+inline I kMaxReverse = 0;
+inline I kTurnPerTick = 0;
+inline I kGripMin = 0;
+inline I kSlipSpeed = 0;
+inline I kTractionSlow = 0;
+inline I kTractionFast = 0;
+inline I kDriftSteer = 0;
+inline I kStopDeadband = 0;
+inline I kWallHalfThick = 0;
+inline I kWallLateral = 0;
+inline I kWallY = 0;
+inline I kWallHalfHeightRaw = 0;
+inline I kHalfPiFixed = 0;
+inline I kTwoPiFixed = 0;
+inline I kOuterArcSegments = 0;
+inline I kInnerArcSegments = 0;
+inline I kColliderLayer = 0;
+inline I kColliderMask = 0;
+inline I kArenaHalfUnits = 0;
+inline I kArenaWallThick = 0;
+inline I kArenaWallHalfHeight = 0;
+inline I kArenaWallY = 0;
+inline I kArenaCenterX = 0;
+inline I kArenaCenterZ = 0;
+inline I kScatterCols = 0;
+inline I kScatterSpacing = 0;
+inline I kGridSpawnLateral = 0;
+inline I kGridSpawnRowBack = 0;
+inline I kGridSpawnMinSlots = 0;
+inline I kGridSpawnMaxSlots = 0;
+inline I kWaypointLookahead = 0;
+inline I kWaypointSteerGain = 0;
+inline I kWaypointSharpTurnThrottle = 0;
+inline I kTotalLaps = 0;
+inline I kMaxRaceFrames = 0;
+inline I kNoTeleport = 0;
+inline I kMaxRequiredBits = 0;
+inline I kLobbyInitialFrames = 0;
+inline I kLobbyExtendFrames = 0;
+inline I kLobbyMaxFrames = 0;
+inline I kCountdownFrames = 0;
+inline I kResultsHoldFrames = 0;
+inline I kMaxSlotsAutoStart = 0;
+inline I kBodyRadius = 0;
+inline I kBodyY = 0;
+inline I kBodyLayer = 0;
+inline I kBodyMask = 0;
+inline std::vector<I> kCornerTypeIds;
+inline std::vector<I> kPassThroughTypeIds;
+inline std::string kWallBodyPrefix;
+inline std::string kCarBodyPrefix;
+inline std::array<std::string, 4> kArenaBodyIds;
+}

package/native/kinetix-native-main.cpp

@@ -0,0 +1,37 @@
+#include <iostream>
+#include <vector>
+
+#include "kinetix-render-projection.hpp"
+#if defined(KINETIX_ALL_PROFILES) || defined(KINETIX_FIXED1000_PROFILE)
+#include "kinetix-fixed1000-native-profile.hpp"
+#endif
+#if defined(KINETIX_ALL_PROFILES) || defined(KINETIX_F64_PROFILE)
+#include "kinetix-f64-native-profile.hpp"
+#endif
+#include "kinetix-native-runtime.hpp"
+
+int main(int argc, char** argv) {
+#if defined(KINETIX_ALL_PROFILES) || defined(KINETIX_FIXED1000_PROFILE)
+  if (argc > 1 && std::string(argv[1]) == "--fixed1000") {
+    return rundot::kinetix::RunFixed1000Profile(argc - 1, argv + 1);
+  }
+#endif
+#if defined(KINETIX_ALL_PROFILES) || defined(KINETIX_F64_PROFILE)
+  if (argc > 1 && std::string(argv[1]) == "--f64") {
+    return rundot::kinetix::RunF64Profile(argc - 1, argv + 1);
+  }
+#endif
+  if (argc == 4 && std::string(argv[1]) == "--project") {
+    std::vector<std::string> payloads;
+    std::string payload;
+    while (std::getline(std::cin, payload)) payloads.push_back(payload);
+    std::cout << rundot::kinetix::ProjectRenderRecords(
+        std::stoull(argv[2]), argv[3], payloads) << '\n';
+    return 0;
+  }
+  rundot::kinetix::World world;
+  std::string input;
+  while (std::getline(std::cin, input)) world.Step(input);
+  std::cout << world.CanonicalState() << '\n';
+  return 0;
+}

package/native/kinetix-native-runtime.cpp

@@ -0,0 +1,20 @@
+#include "kinetix-native-runtime.hpp"
+
+namespace rundot::kinetix {
+
+void World::Step(const std::string& inputFrame) {
+  state_.tick += 1;
+  state_.lastInputFrame = inputFrame;
+}
+
+Snapshot World::TakeSnapshot() const { return state_; }
+
+void World::Restore(const Snapshot& snapshot) { state_ = snapshot; }
+
+std::string World::CanonicalState() const {
+  return "{\"lastInputFrame\":" + state_.lastInputFrame +
+      ",\"monotonicSpawnId\":" + std::to_string(state_.monotonicSpawnId) +
+      ",\"tick\":" + std::to_string(state_.tick) + "}";
+}
+
+}  // namespace rundot::kinetix

package/native/kinetix-native-runtime.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+namespace rundot::kinetix {
+
+struct Snapshot {
+  std::uint64_t tick;
+  std::uint64_t monotonicSpawnId;
+  std::string lastInputFrame;
+};
+
+class World {
+ public:
+  void Step(const std::string& inputFrame);
+  Snapshot TakeSnapshot() const;
+  void Restore(const Snapshot& snapshot);
+  std::string CanonicalState() const;
+
+ private:
+  Snapshot state_{0, 1, "null"};
+};
+
+}  // namespace rundot::kinetix

package/native/kinetix-render-projection.cpp

@@ -0,0 +1,20 @@
+#include "kinetix-render-projection.hpp"
+
+namespace rundot::kinetix {
+
+std::string ProjectRenderRecords(
+    std::uint64_t worldTick,
+    const std::string& bindingDigest,
+    const std::vector<std::string>& payloads) {
+  std::string output = "[";
+  for (std::size_t index = 0; index < payloads.size(); ++index) {
+    if (index > 0) output += ',';
+    output += "{\"bindingDigest\":\"" + bindingDigest +
+        "\",\"payload\":" + payloads[index] +
+        ",\"worldTick\":" + std::to_string(worldTick) + "}";
+  }
+  output += ']';
+  return output;
+}
+
+}

package/native/kinetix-render-projection.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace rundot::kinetix {
+
+std::string ProjectRenderRecords(
+    std::uint64_t worldTick,
+    const std::string& bindingDigest,
+    const std::vector<std::string>& payloads);
+
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@series-inc/rundot-kinetix",
+  "version": "0.0.0-bootstrap.0",
+  "description": "Data-only game runtime core: compiler, baker, world kernel, installed systems, deterministic math, render records, and the portable C++ runtime",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/series-ai/venus.git",
+    "directory": "packages/kinetix"
+  },
+  "type": "module",
+  "main": "./src/index.mjs",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./src/index.mjs"
+    },
+    "./runtime": {
+      "types": "./runtime.d.ts",
+      "default": "./src/runtime.mjs"
+    },
+    "./authoring": {
+      "types": "./authoring.d.ts",
+      "default": "./src/kinetix-authoring.mjs"
+    },
+    "./compiler": "./src/kinetix-project-compiler.mjs",
+    "./baker": "./src/kinetix-baker.mjs",
+    "./world-kernel": "./src/kinetix-world-kernel.mjs",
+    "./installed-systems": "./src/kinetix-installed-systems.mjs",
+    "./installed-mechanics": "./src/kinetix-installed-mechanics.mjs",
+    "./installed-f64-reference": "./src/kinetix-installed-f64-reference.mjs",
+    "./installed-f64-renderer": "./src/kinetix-installed-f64-renderer.mjs",
+    "./installed-f64-runtime": "./src/kinetix-installed-f64-runtime.mjs",
+    "./installed-f64-render-frames": "./src/kinetix-installed-f64-render-frames.mjs",
+    "./fixed1000-runtime": "./src/kinetix-fixed1000-runtime.mjs",
+    "./deterministic-math": "./src/kinetix-deterministic-math.mjs",
+    "./native-product": "./src/kinetix-native-product.mjs",
+    "./render-projection": "./src/kinetix-render-projection.mjs",
+    "./envelope": "./src/shared/kinetix-envelope-v1.mjs",
+    "./render-records": "./src/shared/render-records-v1.mjs",
+    "./f64-bits": "./src/shared/f64-bits.mjs",
+    "./build-native": "./scripts/build-native.mjs",
+    "./preflight": "./scripts/preflight.mjs",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "native",
+    "scripts",
+    "index.d.ts",
+    "runtime.d.ts",
+    "authoring.d.ts"
+  ],
+  "scripts": {
+    "build:native": "node scripts/build-native.mjs",
+    "test": "node --test tests/*.test.mjs"
+  },
+  "dependencies": {
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "MIT"
+}

package/runtime.d.ts

@@ -0,0 +1,76 @@
+export const kinetixRuntimeAbiVersion: 1;
+
+export interface KinetixRuntimeIdentity {
+  readonly abiVersion: typeof kinetixRuntimeAbiVersion;
+  readonly tickRate: 10 | 20 | 30 | 60;
+  readonly inputSchemaId: string;
+  readonly stateSchemaId: string;
+  readonly deterministicVersion: string;
+  readonly engineIdentityHash: string;
+}
+
+export interface KinetixAdvanceRequest<Input> {
+  readonly frame: number;
+  readonly inputs: readonly Readonly<Input>[];
+  readonly commands: readonly unknown[];
+  readonly checksum: boolean;
+}
+
+export interface KinetixAdvanceResult<Checkpoint> {
+  readonly frame: number;
+  readonly checkpoint: Checkpoint;
+  readonly checksum?: string;
+}
+
+export interface KinetixRuntime<State, Input, Checkpoint = unknown> {
+  readonly identity: KinetixRuntimeIdentity;
+  readonly sessionConfigDigest: string;
+  readonly currentFrame: number;
+  sessionConfigBytes(): Uint8Array;
+  capture(): Checkpoint;
+  advance(
+    requests: readonly KinetixAdvanceRequest<Input>[],
+  ): readonly KinetixAdvanceResult<Checkpoint>[];
+  restore(checkpoint: Checkpoint): void;
+  inspect(checkpoint: Checkpoint): State;
+  serializeCheckpoint(checkpoint: Checkpoint): Uint8Array;
+  hydrateCheckpoint(frame: number, bytes: Uint8Array): Checkpoint;
+  checksum(checkpoint: Checkpoint): string;
+  wireChecksum(checkpoint: Checkpoint): string;
+  release(checkpoint: Checkpoint): void;
+}
+
+export function assertKinetixRuntime<
+  State,
+  Input,
+  Checkpoint,
+  Runtime extends KinetixRuntime<State, Input, Checkpoint>,
+>(runtime: Runtime): Runtime;
+
+export function assertKinetixRuntimeIdentity(
+  identity: unknown,
+): asserts identity is KinetixRuntimeIdentity;
+
+export function createKinetixWorldRuntime<State, Input>(options: {
+  world: {
+    step(input: unknown): unknown;
+    snapshot(): State;
+    restore(snapshot: State): void;
+    canonicalStateBytes(): Uint8Array;
+  };
+  identity: KinetixRuntimeIdentity;
+  sessionConfigBytes?: Uint8Array;
+}): KinetixRuntime<State, Input>;
+
+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>): KinetixRuntime<unknown, unknown>;
+export function createInstalledSurvivalRuntime(options: Record<string, unknown>): KinetixRuntime<unknown, unknown>;
+export function createFixed1000Runtime(options: Record<string, unknown>): KinetixRuntime<unknown, unknown>;

package/scripts/build-native.mjs

@@ -0,0 +1,67 @@
+// Builds the portable C++ core. Probes for a compiler rather than hardcoding one,
+// so the same script serves macOS (clang++) and Linux CI (g++).
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = join(import.meta.dirname, '..');
+const outDir = join(root, 'build');
+
+const SOURCES = [
+  'kinetix-native-runtime.cpp',
+  'kinetix-render-projection.cpp',
+  'kinetix-fixed1000-native-profile.cpp',
+  'kinetix-fixed1000-physics.cpp',
+  'component_runtime.cpp',
+  'deterministic_math.cpp',
+  'kinetix-installed-f64-runtime.cpp',
+  'kinetix-installed-f64-renderer.cpp',
+  'kinetix-f64-native-profile.cpp',
+  'kinetix-native-main.cpp',
+];
+
+// -ffp-contract=off is load-bearing, not stylistic: it forbids the compiler from
+// fusing a*b+c into an FMA, which would change f64 results and break JS<->C++
+// determinism. Do not drop it when adding a compiler.
+const FLAGS = [
+  '-std=c++20',
+  '-O2',
+  '-ffp-contract=off',
+  '-DKINETIX_ALL_PROFILES',
+  '-DKINETIX_FIXED1000_SIM_ONLY',
+];
+
+const CANDIDATES = ['clang++', 'g++', 'c++'];
+
+function probeCompiler() {
+  for (const candidate of CANDIDATES) {
+    const probe = spawnSync(candidate, ['--version'], { encoding: 'utf8' });
+    if (probe.status === 0) return candidate;
+  }
+  throw new Error(`KINETIX_NATIVE_NO_COMPILER tried=${CANDIDATES.join(',')}`);
+}
+
+export function buildNative() {
+  mkdirSync(outDir, { recursive: true });
+  const compiler = probeCompiler();
+  const binary = join(outDir, 'kinetix-native-main');
+  const built = spawnSync(compiler, [
+    ...FLAGS,
+    ...SOURCES.map((source) => join(root, 'native', source)),
+    '-o',
+    binary,
+  ], { encoding: 'utf8' });
+  if (built.status !== 0) {
+    throw new Error(`KINETIX_NATIVE_BUILD_FAILED compiler=${compiler} ${built.stderr}`);
+  }
+  return binary;
+}
+
+// Build when invoked directly (`npm run build:native`). realpath both sides:
+// import.meta.url is symlink-resolved but process.argv[1] is not, so a checkout
+// under a symlinked path (macOS /tmp, some CI runners) would otherwise turn this
+// entry check — and thus the CI "build the core" step — into a silent no-op.
+if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {
+  console.log(`KINETIX_NATIVE_BUILD_OK ${buildNative()}`);
+}

package/scripts/emit-product-digests.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// Emits the product-digest oracle: sha256 over the stable (double-compiled,
+// byte-compared) product bytes for each validation game.
+//
+// This is the acceptance oracle for the promotion of the core out of the lab.
+// The digests are content-addressed over the compiler's output, so any change to
+// compiler, baker, envelope or installed-system behavior moves them. A move that
+// is genuinely inert leaves them untouched.
+import { createHash } from 'node:crypto';
+import { writeFileSync } from 'node:fs';
+
+import { stableKinetixProductBytes } from '../src/kinetix-baker.mjs';
+import { compileStableKinetixProducts } from '../src/kinetix-native-product.mjs';
+
+function option(name) {
+  const index = process.argv.indexOf(`--${name}`);
+  if (index < 0 || index + 1 >= process.argv.length) throw new Error(`KINETIX_OPTION_REQUIRED --${name}`);
+  return process.argv[index + 1];
+}
+
+const games = [
+  { id: 'game-f64', projectRoot: option('f64-root'), expectedCommit: option('f64-commit'), targetProfile: 'deterministic-f64' },
+  { id: 'game-fixed1000', projectRoot: option('fixed1000-root'), expectedCommit: option('fixed1000-commit'), targetProfile: 'fixed-1000-3d' },
+];
+
+const digests = {};
+for (const game of games) {
+  const result = compileStableKinetixProducts(game);
+  digests[game.id] = createHash('sha256').update(stableKinetixProductBytes(result.products)).digest('hex');
+}
+
+writeFileSync(option('out'), `${JSON.stringify(digests, null, 2)}\n`);
+console.log(`KINETIX_PRODUCT_DIGESTS ${JSON.stringify(digests)}`);

package/scripts/preflight.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+// Local pack preflight: compile a game at a commit and report unmatched
+// authoritative branches WITHOUT touching any server. This is the bridge
+// `rundot pack preflight` shells out to (the compiler is JS; the CLI is .NET).
+//
+// Usage:
+//   node preflight.mjs --project-root <dir> --commit <sha> --profile <deterministic-f64|fixed-1000-3d>
+//
+// Prints a JSON report to stdout and exits non-zero when the game does not
+// compile, so the CLI can format it and set the exit code without re-parsing.
+import { compileKinetixProject } from '../src/kinetix-project-compiler.mjs';
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const key = argv[i];
+    if (key.startsWith('--')) {
+      args[key.slice(2)] = argv[i + 1];
+      i += 1;
+    }
+  }
+  return args;
+}
+
+const PROFILES = new Set(['deterministic-f64', 'fixed-1000-3d']);
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const projectRoot = args['project-root'];
+  const commit = args.commit;
+  const profile = args.profile;
+  if (!projectRoot || !commit || !PROFILES.has(profile)) {
+    process.stderr.write(
+      'KINETIX_PREFLIGHT_USAGE --project-root <dir> --commit <sha> --profile <deterministic-f64|fixed-1000-3d>\n',
+    );
+    process.exit(2);
+  }
+
+  let result;
+  try {
+    result = compileKinetixProject({ projectRoot, expectedCommit: commit, targetProfile: profile });
+  } catch (err) {
+    process.stdout.write(
+      JSON.stringify({
+        format: 'kinetix-preflight-v1',
+        ok: false,
+        commitSha: commit,
+        numericProfile: profile,
+        error: err instanceof Error ? err.message : String(err),
+        diagnostics: [],
+        unmatchedCount: 0,
+      }) + '\n',
+    );
+    process.exit(1);
+  }
+
+  const diagnostics = (result.diagnostics ?? []).map((entry) => ({
+    code: entry.code,
+    file: entry.file,
+    line: entry.line,
+    enclosingMember: entry.enclosingMember,
+    message: entry.message,
+  }));
+  const ok = result.envelope !== null && diagnostics.length === 0;
+  process.stdout.write(JSON.stringify({
+    format: 'kinetix-preflight-v1',
+    ok,
+    commitSha: commit,
+    numericProfile: profile,
+    diagnostics,
+    unmatchedCount: diagnostics.length,
+  }) + '\n');
+  process.exit(ok ? 0 : 1);
+}
+
+main();