simfile 0.0.1

package/dist/runtime/expression.js

@@ -0,0 +1,305 @@
+import { parseDurationSeconds } from "../kernel/duration.js";
+const FUNCTION_ARITY = {
+    sin: { min: 1, max: 1 },
+    cos: { min: 1, max: 1 },
+    abs: { min: 1, max: 1 },
+    sqrt: { min: 1, max: 1 },
+    exp: { min: 1, max: 1 },
+    log: { min: 1, max: 1 },
+    floor: { min: 1, max: 1 },
+    ceil: { min: 1, max: 1 },
+    mod: { min: 2, max: 2 },
+    pow: { min: 2, max: 2 },
+    min: { min: 2, max: Number.POSITIVE_INFINITY },
+    max: { min: 2, max: Number.POSITIVE_INFINITY },
+    clamp: { min: 3, max: 3 },
+    lerp: { min: 3, max: 3 },
+    step: { min: 2, max: 2 },
+    smoothstep: { min: 3, max: 3 }
+};
+const FUNCTIONS = {
+    sin: (x) => finite(Math.sin(x)),
+    cos: (x) => finite(Math.cos(x)),
+    abs: (x) => finite(Math.abs(x)),
+    sqrt: (x) => finite(x < 0 ? 0 : Math.sqrt(x)),
+    exp: (x) => finite(Math.exp(finite(x))),
+    log: (x) => finite(x <= 0 ? 0 : Math.log(x)),
+    floor: (x) => finite(Math.floor(x)),
+    ceil: (x) => finite(Math.ceil(x)),
+    mod: (x, y) => finite(y === 0 ? 0 : x % y),
+    pow: (x, y) => finite(Math.pow(x, y)),
+    min: (...values) => finite(Math.min(...values)),
+    max: (...values) => finite(Math.max(...values)),
+    clamp: (value, lo, hi) => finite(Math.max(lo, Math.min(hi, value))),
+    lerp: (start, end, step) => finite(start + (end - start) * clamp01(step)),
+    step: (edge, value) => finite(value < edge ? 0 : 1),
+    smoothstep: (edge0, edge1, value) => {
+        if (edge0 === edge1) {
+            return 1;
+        }
+        const t = clamp01((value - edge0) / (edge1 - edge0));
+        return finite(t * t * (3 - 2 * t));
+    }
+};
+const RESERVED = new Set(["t", "tick", "pi", "e"]);
+const NUMBER = /^(?:0|[1-9][0-9]*)(?:\.[0-9]+)?/u;
+const IDENT = /^[a-zA-Z_][a-zA-Z0-9_-]*/u;
+const finite = (value) => (Number.isFinite(value) ? value : 0);
+const clamp01 = (value) => {
+    if (!Number.isFinite(value) || value < 0) {
+        return 0;
+    }
+    if (value > 1) {
+        return 1;
+    }
+    return value;
+};
+const rewriteDurations = (source) => source.replace(/-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:ms|s|m|h|d|w)\b/gu, (raw) => String(parseDurationSeconds(raw)));
+class Lexer {
+    tokens = [];
+    cursor = 0;
+    constructor(source) {
+        let index = 0;
+        while (index < source.length) {
+            const current = source[index];
+            if (/\s/u.test(current)) {
+                index += 1;
+                continue;
+            }
+            const remainder = source.slice(index);
+            if (remainder.startsWith("**")) {
+                this.tokens.push({ type: "operator", value: "**" });
+                index += 2;
+                continue;
+            }
+            if (current === "+" || current === "-" || current === "*" || current === "/" || current === "(" || current === ")" || current === ",") {
+                this.tokens.push({
+                    type: current === "(" ? "left-paren" : current === ")" ? "right-paren" : current === "," ? "comma" : "operator",
+                    value: current
+                });
+                index += 1;
+                continue;
+            }
+            if (NUMBER.test(remainder)) {
+                const matched = remainder.match(/^((?:0|[1-9][0-9]*)(?:\.[0-9]+)?)/u);
+                if (!matched) {
+                    throw new Error(`invalid number token at ${index}`);
+                }
+                this.tokens.push({ type: "number", value: matched[0] });
+                index += matched[0].length;
+                continue;
+            }
+            if (IDENT.test(remainder)) {
+                const matched = remainder.match(IDENT);
+                if (!matched) {
+                    throw new Error(`invalid identifier token at ${index}`);
+                }
+                this.tokens.push({ type: "identifier", value: matched[0] });
+                index += matched[0].length;
+                continue;
+            }
+            throw new Error(`unexpected token at ${index}: ${current}`);
+        }
+        this.tokens.push({ type: "eof", value: "" });
+    }
+    peek(offset = 0) {
+        return this.tokens[this.cursor + offset] ?? { type: "eof", value: "" };
+    }
+    advance() {
+        const current = this.peek();
+        this.cursor += 1;
+        return current;
+    }
+    match(type, value) {
+        const current = this.peek();
+        return current.type === type && (value === undefined || current.value === value);
+    }
+    consume(type, value) {
+        if (!this.match(type, value)) {
+            const current = this.peek();
+            throw new Error(`expected ${value ?? type}, got ${current.type} ${current.value}`);
+        }
+        return this.advance();
+    }
+}
+class Parser {
+    lexer;
+    constructor(source) {
+        this.lexer = new Lexer(source);
+    }
+    parseExpression() {
+        return this.parseAdditive();
+    }
+    parseRootExpression() {
+        const output = this.parseExpression();
+        if (!this.lexer.match("eof")) {
+            throw new Error(`unexpected token: ${this.lexer.peek().value}`);
+        }
+        return output;
+    }
+    parseAdditive() {
+        let node = this.parseMultiplicative();
+        while (this.lexer.match("operator", "+") || this.lexer.match("operator", "-")) {
+            const operator = this.lexer.advance().value;
+            const right = this.parseMultiplicative();
+            node = { kind: "binary", operator, left: node, right };
+        }
+        return node;
+    }
+    parseMultiplicative() {
+        let node = this.parseExponent();
+        while (this.lexer.match("operator", "*") || this.lexer.match("operator", "/")) {
+            const operator = this.lexer.advance().value;
+            const right = this.parseExponent();
+            node = { kind: "binary", operator, left: node, right };
+        }
+        return node;
+    }
+    parseExponent() {
+        const node = this.parseUnary();
+        if (this.lexer.match("operator", "**")) {
+            this.lexer.advance();
+            const right = this.parseExponent();
+            return { kind: "binary", operator: "**", left: node, right };
+        }
+        return node;
+    }
+    parseUnary() {
+        if (this.lexer.match("operator", "+") || this.lexer.match("operator", "-")) {
+            const operator = this.lexer.advance().value;
+            return { kind: "unary", operator, argument: this.parseUnary() };
+        }
+        return this.parsePrimary();
+    }
+    parsePrimary() {
+        if (this.lexer.match("number")) {
+            return { kind: "number", value: Number(this.lexer.advance().value) };
+        }
+        if (this.lexer.match("identifier")) {
+            const token = this.lexer.advance();
+            const name = token.value;
+            if (this.lexer.match("left-paren")) {
+                this.lexer.consume("left-paren");
+                const args = [];
+                if (!this.lexer.match("right-paren")) {
+                    args.push(this.parseExpression());
+                    while (this.lexer.match("comma")) {
+                        this.lexer.consume("comma");
+                        args.push(this.parseExpression());
+                    }
+                }
+                this.lexer.consume("right-paren");
+                return { kind: "call", callee: name, args };
+            }
+            return { kind: "variable", name };
+        }
+        if (this.lexer.match("left-paren")) {
+            this.lexer.consume("left-paren");
+            const output = this.parseExpression();
+            this.lexer.consume("right-paren");
+            return output;
+        }
+        throw new Error(`unexpected token: ${this.lexer.peek().value}`);
+    }
+}
+const collectDependencies = (node, output) => {
+    if (node.kind === "variable") {
+        output.add(node.name);
+        return;
+    }
+    if (node.kind === "unary") {
+        collectDependencies(node.argument, output);
+        return;
+    }
+    if (node.kind === "binary") {
+        collectDependencies(node.left, output);
+        collectDependencies(node.right, output);
+        return;
+    }
+    if (node.kind === "call") {
+        node.args.forEach((arg) => collectDependencies(arg, output));
+    }
+};
+const validate = (node) => {
+    if (node.kind === "binary") {
+        validate(node.left);
+        validate(node.right);
+        return;
+    }
+    if (node.kind === "unary") {
+        validate(node.argument);
+        return;
+    }
+    if (node.kind === "call") {
+        if (FUNCTION_ARITY[node.callee] === undefined) {
+            throw new Error(`unknown function '${node.callee}'`);
+        }
+        const arity = FUNCTION_ARITY[node.callee];
+        if (node.args.length < arity.min || node.args.length > arity.max) {
+            throw new Error(`function '${node.callee}' arity mismatch`);
+        }
+        node.args.forEach(validate);
+    }
+};
+const evaluateNode = (node, variables, tick, simTime) => {
+    if (node.kind === "number") {
+        return node.value;
+    }
+    if (node.kind === "variable") {
+        if (node.name === "t") {
+            return simTime;
+        }
+        if (node.name === "tick") {
+            return tick;
+        }
+        if (node.name === "pi") {
+            return Math.PI;
+        }
+        if (node.name === "e") {
+            return Math.E;
+        }
+        return finite(variables[node.name]);
+    }
+    if (node.kind === "unary") {
+        const value = evaluateNode(node.argument, variables, tick, simTime);
+        return node.operator === "-" ? -value : value;
+    }
+    if (node.kind === "binary") {
+        const left = evaluateNode(node.left, variables, tick, simTime);
+        const right = evaluateNode(node.right, variables, tick, simTime);
+        if (node.operator === "+") {
+            return left + right;
+        }
+        if (node.operator === "-") {
+            return left - right;
+        }
+        if (node.operator === "*") {
+            return left * right;
+        }
+        if (node.operator === "/") {
+            return right === 0 ? 0 : left / right;
+        }
+        return finite(Math.pow(left, right));
+    }
+    const impl = FUNCTIONS[node.callee];
+    const args = node.args.map((arg) => evaluateNode(arg, variables, tick, simTime));
+    return finite(impl(...args));
+};
+export const compileExpression = (source) => {
+    const rewritten = rewriteDurations(source);
+    const parser = new Parser(rewritten);
+    const ast = parser.parseRootExpression();
+    validate(ast);
+    const dependencySet = new Set();
+    collectDependencies(ast, dependencySet);
+    for (const name of dependencySet) {
+        if (RESERVED.has(name) || name in FUNCTIONS) {
+            dependencySet.delete(name);
+        }
+    }
+    return {
+        source: rewritten,
+        dependencies: [...dependencySet],
+        evaluate: ({ variables, tick, t }) => finite(evaluateNode(ast, variables, tick, t))
+    };
+};

package/dist/runtime/numeric.d.ts

@@ -0,0 +1,7 @@
+export interface RangeSpec {
+    min: number;
+    max: number;
+}
+export declare const finite: (value: number) => number;
+export declare const clampAndRound: (value: number, range: RangeSpec, precision: number) => number;
+//# sourceMappingURL=numeric.d.ts.map

package/dist/runtime/numeric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric.d.ts","sourceRoot":"","sources":["../../src/runtime/numeric.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,MAAM,KAAG,MAA8C,CAAC;AAEtF,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,EAAE,OAAO,SAAS,EAAE,WAAW,MAAM,KAAG,MASlF,CAAC"}

package/dist/runtime/numeric.js

@@ -0,0 +1,11 @@
+export const finite = (value) => (Number.isFinite(value) ? value : 0);
+export const clampAndRound = (value, range, precision) => {
+    const rounded = Number(finite(value).toFixed(precision));
+    if (rounded < range.min) {
+        return range.min;
+    }
+    if (rounded > range.max) {
+        return range.max;
+    }
+    return rounded === -0 ? 0 : rounded;
+};

package/dist/runtime/rule-actions.d.ts

@@ -0,0 +1,5 @@
+import type { SimfileRuleAction } from "../schema/model.js";
+import { type RangeSpec } from "./numeric.js";
+import type { RuntimeTraceEvent } from "./types.js";
+export declare const runRuleActions: (runId: string, seq: number, ruleId: string, tick: number, simTime: number, phase: string | undefined, actions: readonly SimfileRuleAction[], templateVariables: Readonly<Record<string, number>>, precision: number, ranges: Map<string, RangeSpec>, nextVariables: Record<string, number>, causeEventIds: readonly string[], variableIds: readonly string[], emit: (event: RuntimeTraceEvent) => void) => number;
+//# sourceMappingURL=rule-actions.d.ts.map

package/dist/runtime/rule-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-actions.d.ts","sourceRoot":"","sources":["../../src/runtime/rule-actions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAyHpD,eAAO,MAAM,cAAc,GACzB,OAAO,MAAM,EACb,KAAK,MAAM,EACX,QAAQ,MAAM,EACd,MAAM,MAAM,EACZ,SAAS,MAAM,EACf,OAAO,MAAM,GAAG,SAAS,EACzB,SAAS,SAAS,iBAAiB,EAAE,EACrC,mBAAmB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACnD,WAAW,MAAM,EACjB,QAAQ,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAC9B,eAAe,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACrC,eAAe,SAAS,MAAM,EAAE,EAChC,aAAa,SAAS,MAAM,EAAE,EAC9B,MAAM,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,KACvC,MAqCF,CAAC"}

package/dist/runtime/rule-actions.js

@@ -0,0 +1,82 @@
+import { createCanonicalEventEnvelope, DEFAULT_EMITTER_STREAM_ID, DEFAULT_PRINCIPAL_ID } from "../ledger/stable.js";
+import { clampAndRound } from "./numeric.js";
+const WORLD_ACTOR = "@world";
+const replaceTemplateValues = (source, variables, precision) => source.replace(/\{([a-z][a-z0-9_-]*)\}/giu, (match, variableId) => {
+    const value = variables[variableId];
+    return Number.isFinite(value) ? value.toFixed(precision) : match;
+});
+/** Unique, deterministic identifier for a single world act (rule-emitted action). */
+const actId = (runId, seq) => `${runId}:act:${seq}`;
+const createActionEvent = (runId, seq, kind, simTime, actor, target, scope, payload, causeEventIds) => createCanonicalEventEnvelope({
+    runId,
+    seq,
+    kind,
+    simTime,
+    provenance: "mechanical",
+    actor,
+    target,
+    scope,
+    payload,
+    streamId: DEFAULT_EMITTER_STREAM_ID,
+    principalId: DEFAULT_PRINCIPAL_ID,
+    causeEventIds
+});
+/**
+ * world.act payload minimum: {sim_time, provenance, actor, target, scope,
+ * act_id, action, value}. Rule-emitted world events (world.message, world.dm,
+ * wake.recommended) are simfile's world.act variants, so every one of these
+ * carries the minimum keys directly in payload alongside its existing fields.
+ */
+const worldActPayload = (fields, extra) => ({
+    sim_time: fields.simTime,
+    provenance: "mechanical",
+    actor: fields.actor,
+    target: fields.target,
+    scope: fields.scope,
+    act_id: actId(fields.runId, fields.seq),
+    action: fields.action,
+    value: fields.value,
+    ...extra
+});
+/** `{ variables: variableIds }` when non-empty, else `{}` — spread into a payload's `extra` so a rule with no variable condition emits byte-identical payloads to before this field existed (never a fabricated empty array). */
+const variablesExtra = (variableIds) => variableIds.length > 0 ? { variables: [...variableIds] } : {};
+const emitRuleActionEvents = (runId, seq, ruleId, tick, simTime, phase, action, templateVariables, precision, causeEventIds, variableIds, emit) => {
+    if (action.action === "variable:set" || action.action === "variable:delta") {
+        return seq;
+    }
+    if (action.action === "moltnet:message") {
+        const content = replaceTemplateValues(action.content, templateVariables, precision);
+        emit(createActionEvent(runId, seq, "world.message", simTime, WORLD_ACTOR, action.to, action.to, worldActPayload({ simTime, actor: WORLD_ACTOR, target: action.to, scope: action.to, seq, runId, action: action.action, value: content }, { rule: ruleId, content, tick, phase, ...variablesExtra(variableIds) }), causeEventIds));
+        return seq + 1;
+    }
+    if (action.action === "moltnet:dm") {
+        const content = replaceTemplateValues(action.content, templateVariables, precision);
+        emit(createActionEvent(runId, seq, "world.dm", simTime, WORLD_ACTOR, action.to, action.to, worldActPayload({ simTime, actor: WORLD_ACTOR, target: action.to, scope: action.to, seq, runId, action: action.action, value: content }, { rule: ruleId, content, tick, phase, ...variablesExtra(variableIds) }), causeEventIds));
+        return seq + 1;
+    }
+    emit(createActionEvent(runId, seq, "wake.recommended", simTime, ruleId, action.to, action.to, worldActPayload({ simTime, actor: ruleId, target: action.to, scope: action.to, seq, runId, action: action.action, value: null }, { reason: ruleId, target: action.to, tick, phase, ...variablesExtra(variableIds) }), causeEventIds));
+    return seq + 1;
+};
+export const runRuleActions = (runId, seq, ruleId, tick, simTime, phase, actions, templateVariables, precision, ranges, nextVariables, causeEventIds, variableIds, emit) => {
+    let nextSeq = seq;
+    for (const action of actions) {
+        if (action.action === "variable:set") {
+            const range = ranges.get(action.variable);
+            if (!range) {
+                throw new Error(`action variable:set references unknown variable ${action.variable}`);
+            }
+            nextVariables[action.variable] = clampAndRound(action.value, range, precision);
+            continue;
+        }
+        if (action.action === "variable:delta") {
+            const range = ranges.get(action.variable);
+            if (!range) {
+                throw new Error(`action variable:delta references unknown variable ${action.variable}`);
+            }
+            nextVariables[action.variable] = clampAndRound((nextVariables[action.variable] ?? 0) + action.value, range, precision);
+            continue;
+        }
+        nextSeq = emitRuleActionEvents(runId, nextSeq, ruleId, tick, simTime, phase, action, templateVariables, precision, causeEventIds, variableIds, emit);
+    }
+    return nextSeq;
+};

package/dist/runtime/run-record.d.ts

@@ -0,0 +1,73 @@
+import { type MarkerCoverageResult } from "../ledger/markers.js";
+import { type ProbeEvaluationResult } from "../report/probes.js";
+import { type TranscriptAcceptanceResult } from "../report/transcripts.js";
+import type { Simfile } from "../schema/model.js";
+import type { QueuedWorldAct, RuntimeTrace, RuntimeVariableSample, WorldActResult } from "./types.js";
+import { type ViewerContractTrace } from "./viewer-trace.js";
+export { buildCausalFixtureRecords, toCausalFixtureRecord, type CausalFixtureRecord } from "./causal-fixture.js";
+export interface RunRecordOptions {
+    moltnetArtifact?: MoltnetArtifactKind;
+    outDir: string;
+    precision?: number;
+    runId: string;
+    seed: string;
+    simfile: Simfile;
+    sourcePath: string;
+    sourceText: string;
+    ticks: number;
+    worldActs?: readonly QueuedWorldAct[];
+}
+export interface RunReport {
+    markers: MarkerCoverageResult[];
+    moltnet?: {
+        transcript?: TranscriptAcceptanceResult;
+    };
+    probes: ProbeEvaluationResult[];
+    run_id: string;
+    seed: string;
+    ticks: number;
+    world_acts: WorldActResult[];
+}
+export interface TelemetryArtifact {
+    run_id: string;
+    samples: RuntimeVariableSample[];
+    snapshot_every?: number;
+    version: "simfile.telemetry.v1";
+}
+export type MoltnetArtifactKind = "delivery" | "transcript";
+export interface MoltnetArtifactEntry {
+    event_id: string;
+    kind: "wake.recommended" | "world.dm" | "world.message";
+    marker_ids: string[];
+    rule_id?: string;
+    scope: string;
+    sim_time: number;
+    target: string;
+    text?: string;
+}
+export interface MoltnetTranscriptArtifact {
+    source: "harness-derived";
+    entries: MoltnetArtifactEntry[];
+    run_id: string;
+    version: "simfile.moltnet.transcript.v1";
+}
+export interface MoltnetDeliveryArtifact {
+    source: "harness-derived";
+    deliveries: MoltnetArtifactEntry[];
+    run_id: string;
+    version: "simfile.moltnet.delivery.v1";
+}
+export interface RunRecordResult {
+    ledgerPath: string;
+    manifestPath: string;
+    moltnetArtifactPath?: string;
+    outDir: string;
+    report: RunReport;
+    reportPath: string;
+    telemetryPath: string;
+    trace: RuntimeTrace;
+    viewerTrace: ViewerContractTrace;
+    viewerTracePath: string;
+}
+export declare const writeRunRecord: (options: RunRecordOptions) => Promise<RunRecordResult>;
+//# sourceMappingURL=run-record.d.ts.map

package/dist/runtime/run-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-record.d.ts","sourceRoot":"","sources":["../../src/runtime/run-record.ts"],"names":[],"mappings":"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"}

package/dist/runtime/run-record.js

@@ -0,0 +1,179 @@
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import YAML from "yaml";
+import { evaluateContainmentMarker, evaluatePropagationMarker, scanMarkers } from "../ledger/markers.js";
+import { parseCanonicalLedgerJsonl } from "../ledger/validation.js";
+import { evaluateProbe } from "../report/probes.js";
+import { evaluateTranscriptAcceptance } from "../report/transcripts.js";
+import { serializeCanonicalEvents } from "./trace-export.js";
+import { runSimfileTrace } from "./trace-run.js";
+import { buildViewerTrace } from "./viewer-trace.js";
+// Re-exported so the `emit-causal-fixture` npm script (B92's real entry
+// point into simfile) has a single, stable import surface next to the rest
+// of run-record's artifact-writing API. See causal-fixture.ts for the
+// noopolis.causal-event.v1 wire mapping.
+export { buildCausalFixtureRecords, toCausalFixtureRecord } from "./causal-fixture.js";
+const sha256 = (value) => createHash("sha256").update(value, "utf8").digest("hex");
+const evaluateMarkers = (simfile, trace) => {
+    const hits = scanMarkers(trace.events, simfile.markers);
+    return Object.entries(simfile.markers).map(([markerId, marker]) => {
+        const markerHits = hits[markerId] ?? [];
+        return marker.mode === "containment"
+            ? evaluateContainmentMarker(markerId, marker, markerHits)
+            : evaluatePropagationMarker(markerId, marker, markerHits);
+    });
+};
+const evaluateProbes = (simfile, trace) => Object.entries(simfile.probes).map(([probeId, probe]) => evaluateProbe(probeId, { events: trace.events, samples: trace.samples }, probe));
+const manifestFor = (options) => {
+    const artifacts = {
+        ledger: "ledger.jsonl",
+        report: "report.json",
+        telemetry: "telemetry.json",
+        viewer_trace: "viewer-trace.json"
+    };
+    if (options.moltnetArtifact) {
+        artifacts.moltnet = `moltnet-${options.moltnetArtifact}.json`;
+    }
+    return {
+        simfile_version: options.simfile.simfile_version,
+        run_id: options.runId,
+        run_name: options.simfile.name,
+        seed: options.seed,
+        ticks: options.ticks,
+        source: {
+            path: options.sourcePath,
+            sha256: sha256(options.sourceText)
+        },
+        artifacts
+    };
+};
+const telemetryFor = (simfile, trace) => {
+    const snapshotEvery = simfile.telemetry?.snapshot_every;
+    const samples = snapshotEvery === undefined
+        ? trace.samples
+        : trace.samples.filter((sample, index) => index === trace.samples.length - 1 || sample.tick % snapshotEvery === 0);
+    return {
+        run_id: trace.runId,
+        samples,
+        snapshot_every: snapshotEvery,
+        version: "simfile.telemetry.v1"
+    };
+};
+const MOLTNET_EVENT_KINDS = new Set(["wake.recommended", "world.dm", "world.message"]);
+const markerIdsByEvent = (simfile, trace) => {
+    const hits = scanMarkers(trace.events, simfile.markers);
+    const markersByEvent = new Map();
+    for (const [markerId, markerHits] of Object.entries(hits)) {
+        for (const hit of markerHits) {
+            const existing = markersByEvent.get(hit.eventId) ?? [];
+            existing.push(markerId);
+            markersByEvent.set(hit.eventId, existing);
+        }
+    }
+    for (const markerIds of markersByEvent.values()) {
+        markerIds.sort();
+    }
+    return markersByEvent;
+};
+const toMoltnetEntry = (event, markersByEvent) => {
+    const payload = event.payload && typeof event.payload === "object"
+        ? event.payload
+        : undefined;
+    return {
+        event_id: event.event_id,
+        kind: event.kind,
+        marker_ids: markersByEvent.get(event.event_id) ?? [],
+        rule_id: typeof payload?.rule === "string" ? payload.rule : undefined,
+        scope: event.scope,
+        sim_time: event.sim_time,
+        target: event.target,
+        text: typeof payload?.content === "string"
+            ? payload.content
+            : typeof payload?.reason === "string"
+                ? payload.reason
+                : undefined
+    };
+};
+const buildMoltnetArtifact = (kind, simfile, trace) => {
+    const markersByEvent = markerIdsByEvent(simfile, trace);
+    const entries = trace.events
+        .filter((event) => MOLTNET_EVENT_KINDS.has(event.kind))
+        .map((event) => toMoltnetEntry(event, markersByEvent));
+    return kind === "delivery"
+        ? {
+            source: "harness-derived",
+            deliveries: entries,
+            run_id: trace.runId,
+            version: "simfile.moltnet.delivery.v1"
+        }
+        : {
+            source: "harness-derived",
+            entries,
+            run_id: trace.runId,
+            version: "simfile.moltnet.transcript.v1"
+        };
+};
+const reportMoltnetSection = (options) => {
+    if (options.moltnetArtifact !== "transcript") {
+        return undefined;
+    }
+    return {
+        transcript: evaluateTranscriptAcceptance({ source: "harness-derived" })
+    };
+};
+export const writeRunRecord = async (options) => {
+    const trace = runSimfileTrace(options.simfile, {
+        precision: options.precision,
+        runId: options.runId,
+        seed: options.seed,
+        ticks: options.ticks,
+        worldActs: options.worldActs
+    });
+    const markers = evaluateMarkers(options.simfile, trace);
+    const probes = evaluateProbes(options.simfile, trace);
+    const moltnet = reportMoltnetSection(options);
+    const report = {
+        markers,
+        ...(moltnet ? { moltnet } : {}),
+        probes,
+        run_id: options.runId,
+        seed: options.seed,
+        ticks: options.ticks,
+        world_acts: trace.actResults
+    };
+    const telemetry = telemetryFor(options.simfile, trace);
+    const viewerTrace = buildViewerTrace(options.simfile, trace, markers, probes);
+    await mkdir(options.outDir, { recursive: true });
+    const manifestPath = join(options.outDir, "manifest.yaml");
+    const ledgerPath = join(options.outDir, "ledger.jsonl");
+    const reportPath = join(options.outDir, "report.json");
+    const telemetryPath = join(options.outDir, "telemetry.json");
+    const viewerTracePath = join(options.outDir, "viewer-trace.json");
+    const moltnetArtifactPath = options.moltnetArtifact
+        ? join(options.outDir, `moltnet-${options.moltnetArtifact}.json`)
+        : undefined;
+    const ledgerJsonl = `${serializeCanonicalEvents(trace.events).join("\n")}\n`;
+    parseCanonicalLedgerJsonl(ledgerJsonl, { runId: options.runId });
+    await writeFile(manifestPath, YAML.stringify(manifestFor(options)), "utf8");
+    await writeFile(ledgerPath, ledgerJsonl, "utf8");
+    await writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+    await writeFile(telemetryPath, `${JSON.stringify(telemetry, null, 2)}\n`, "utf8");
+    await writeFile(viewerTracePath, `${JSON.stringify(viewerTrace, null, 2)}\n`, "utf8");
+    if (options.moltnetArtifact && moltnetArtifactPath) {
+        const moltnetArtifact = buildMoltnetArtifact(options.moltnetArtifact, options.simfile, trace);
+        await writeFile(moltnetArtifactPath, `${JSON.stringify(moltnetArtifact, null, 2)}\n`, "utf8");
+    }
+    return {
+        ledgerPath,
+        manifestPath,
+        moltnetArtifactPath,
+        outDir: options.outDir,
+        report,
+        reportPath,
+        telemetryPath,
+        trace,
+        viewerTrace,
+        viewerTracePath
+    };
+};