simfile 0.0.1

package/dist/report/probes.js

@@ -0,0 +1,164 @@
+import { parseDurationMs } from "../kernel/duration.js";
+import { attachVariablesToEventOccurrences, buildEventOccurrences, buildSampleOccurrences, normalizeProbeArtifact } from "./probeArtifact.js";
+const eventAtomMatch = (event, atom) => {
+    if (event.kind !== atom.event) {
+        return false;
+    }
+    if (atom.target !== undefined && atom.target !== event.target) {
+        return false;
+    }
+    if (atom.actor !== undefined && atom.actor !== event.actor) {
+        return false;
+    }
+    if (atom.scope !== undefined && atom.scope !== event.scope) {
+        return false;
+    }
+    return true;
+};
+const holdKey = (node) => `${node.variable}:${node.above ?? ""}:${node.below ?? ""}:${node.for ?? ""}`;
+const matchVariableAtom = (node, occurrence, holdState) => {
+    const value = occurrence.variables?.[node.variable];
+    const above = node.above ?? -Infinity;
+    const below = node.below ?? Infinity;
+    const passesWindow = value !== undefined && Number.isFinite(value) && value > above && value < below;
+    if (node.for === undefined) {
+        return passesWindow;
+    }
+    const key = holdKey(node);
+    if (!passesWindow || occurrence.simTime === undefined) {
+        holdState.startTimeByCondition.delete(key);
+        return false;
+    }
+    const started = holdState.startTimeByCondition.get(key);
+    if (started === undefined) {
+        holdState.startTimeByCondition.set(key, occurrence.simTime);
+        return parseDurationMs(node.for) <= 0;
+    }
+    return (occurrence.simTime - started) * 1_000 >= parseDurationMs(node.for);
+};
+const nodeHasEventAtom = (node) => {
+    if ("event" in node) {
+        return true;
+    }
+    if ("all" in node) {
+        return node.all.some(nodeHasEventAtom);
+    }
+    if ("any" in node) {
+        return node.any.some(nodeHasEventAtom);
+    }
+    if ("not" in node) {
+        return nodeHasEventAtom(node.not);
+    }
+    return false;
+};
+const matchesNode = (node, occurrence, holdState) => {
+    if ("all" in node) {
+        return node.all.every((child) => matchesNode(child, occurrence, holdState));
+    }
+    if ("any" in node) {
+        return node.any.some((child) => matchesNode(child, occurrence, holdState));
+    }
+    if ("not" in node) {
+        return !matchesNode(node.not, occurrence, holdState);
+    }
+    if ("event" in node) {
+        return occurrence.event ? eventAtomMatch(occurrence.event, node) : false;
+    }
+    if ("phase" in node) {
+        return occurrence.phase === node.phase;
+    }
+    return matchVariableAtom(node, occurrence, holdState);
+};
+const matchingOccurrences = (node, occurrences) => {
+    const holdState = { startTimeByCondition: new Map() };
+    return occurrences.filter((occurrence) => matchesNode(node, occurrence, holdState));
+};
+const filterWithAfter = (matches, afterMatches, probe) => {
+    if (probe.after === undefined) {
+        return [...matches];
+    }
+    if (probe.within === undefined) {
+        throw new Error("within is required when after is set");
+    }
+    const withinMs = parseDurationMs(probe.within);
+    return matches.filter((match) => {
+        if (match.simTime === undefined) {
+            return false;
+        }
+        const matchSimTime = match.simTime;
+        const matchTimeMs = matchSimTime * 1_000;
+        return afterMatches.some((afterMatch) => {
+            if (afterMatch.simTime === undefined || afterMatch.simTime >= matchSimTime) {
+                return false;
+            }
+            return matchTimeMs - (afterMatch.simTime * 1_000) <= withinMs;
+        });
+    });
+};
+const parseExpectation = (expect) => {
+    if ("at_least" in expect) {
+        if (!Number.isInteger(expect.at_least) || expect.at_least < 0) {
+            throw new Error("expect.at_least must be a non-negative integer");
+        }
+        return { mode: "at_least", value: expect.at_least };
+    }
+    if ("at_most" in expect) {
+        if (!Number.isInteger(expect.at_most) || expect.at_most < 0) {
+            throw new Error("expect.at_most must be a non-negative integer");
+        }
+        return { mode: "at_most", value: expect.at_most };
+    }
+    if ("always" in expect) {
+        return { mode: "always" };
+    }
+    if ("at_end" in expect) {
+        return { mode: "at_end" };
+    }
+    throw new Error("unsupported expect mode");
+};
+const uniqueEvidence = (occurrences) => {
+    const seen = new Set();
+    const evidence = [];
+    occurrences.forEach((occurrence) => {
+        if (seen.has(occurrence.evidenceId)) {
+            return;
+        }
+        seen.add(occurrence.evidenceId);
+        evidence.push(occurrence.evidenceId);
+    });
+    return evidence;
+};
+const selectOccurrences = (node, eventOccurrences, sampleOccurrences) => (nodeHasEventAtom(node) ? eventOccurrences : sampleOccurrences);
+export const evaluateProbe = (probeId, artifactOrEvents, probe) => {
+    const artifact = normalizeProbeArtifact(artifactOrEvents);
+    const sampleOccurrences = buildSampleOccurrences(artifact.events, artifact.samples ?? []);
+    const eventOccurrences = attachVariablesToEventOccurrences(buildEventOccurrences(artifact.events), sampleOccurrences);
+    const baseOccurrences = selectOccurrences(probe.when, eventOccurrences, sampleOccurrences);
+    const whenMatches = matchingOccurrences(probe.when, baseOccurrences);
+    const afterMatches = probe.after === undefined
+        ? []
+        : matchingOccurrences(probe.after, selectOccurrences(probe.after, eventOccurrences, sampleOccurrences));
+    const matched = filterWithAfter(whenMatches, afterMatches, probe);
+    const count = matched.length;
+    const expectation = parseExpectation(probe.expect);
+    const evidence = uniqueEvidence(matched);
+    let passed = false;
+    if (expectation.mode === "at_least") {
+        passed = count >= expectation.value;
+    }
+    else if (expectation.mode === "at_most") {
+        passed = count <= expectation.value;
+    }
+    else if (expectation.mode === "always") {
+        passed = baseOccurrences.length > 0 && count === baseOccurrences.length;
+    }
+    else {
+        passed = matched.length > 0 && matched[matched.length - 1]?.evidenceId === baseOccurrences.at(-1)?.evidenceId;
+    }
+    return {
+        probeId,
+        passed,
+        evidence,
+        count
+    };
+};

package/dist/report/score.d.ts

@@ -0,0 +1,27 @@
+import type { LedgerEvent } from "../ledger/markers.js";
+/**
+ * Genre-neutral scored-task inputs: which actor's world.act on which target
+ * variable counts as the submission, and which rule's firing counts as the
+ * mechanical proof of correctness. Callers supply the ids; this module names
+ * no fixture, world, or setting of its own.
+ */
+export interface ScoreSingleSubmissionInput {
+    actor: string;
+    target: string;
+    rule: string;
+}
+export interface ScoreSingleSubmissionResult {
+    score: 0 | 1;
+    submissions: number;
+    ruleFirings: number;
+}
+/**
+ * Scores a single-submission scored task from the ledger alone. `submissions`
+ * counts `world.act` events by `(actor, target)`; `ruleFirings` counts
+ * `rule.fired` events by `actor === rule`. `score` is 1 iff both are exactly
+ * 1 — one accepted submission, mechanically proven correct by the paired
+ * rule firing. Two accepted acts (a resubmission) scores 0 even if the rule
+ * fired, by design: it is discipline pressure, not a scoring bug.
+ */
+export declare const scoreSingleSubmission: (events: readonly LedgerEvent[], input: ScoreSingleSubmissionInput) => ScoreSingleSubmissionResult;
+//# sourceMappingURL=score.d.ts.map

package/dist/report/score.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"score.d.ts","sourceRoot":"","sources":["../../src/report/score.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAChC,QAAQ,SAAS,WAAW,EAAE,EAC9B,OAAO,0BAA0B,KAChC,2BAYF,CAAC"}

package/dist/report/score.js

@@ -0,0 +1,14 @@
+/**
+ * Scores a single-submission scored task from the ledger alone. `submissions`
+ * counts `world.act` events by `(actor, target)`; `ruleFirings` counts
+ * `rule.fired` events by `actor === rule`. `score` is 1 iff both are exactly
+ * 1 — one accepted submission, mechanically proven correct by the paired
+ * rule firing. Two accepted acts (a resubmission) scores 0 even if the rule
+ * fired, by design: it is discipline pressure, not a scoring bug.
+ */
+export const scoreSingleSubmission = (events, input) => {
+    const submissions = events.filter((event) => event.kind === "world.act" && event.actor === input.actor && event.target === input.target).length;
+    const ruleFirings = events.filter((event) => event.kind === "rule.fired" && event.actor === input.rule).length;
+    const score = submissions === 1 && ruleFirings === 1 ? 1 : 0;
+    return { score, submissions, ruleFirings };
+};

package/dist/report/transcripts.d.ts

@@ -0,0 +1,12 @@
+export type ReportTranscriptSource = "harness-derived" | "moltnet-exported";
+export interface ReportTranscriptSourceArtifact {
+    source?: string;
+}
+export interface TranscriptAcceptanceResult {
+    accepted: boolean;
+    reason?: string;
+    required_source: "moltnet-exported";
+    source?: ReportTranscriptSource | "unknown";
+}
+export declare const evaluateTranscriptAcceptance: (artifact?: ReportTranscriptSourceArtifact) => TranscriptAcceptanceResult;
+//# sourceMappingURL=transcripts.d.ts.map

package/dist/report/transcripts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcripts.d.ts","sourceRoot":"","sources":["../../src/report/transcripts.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,sBAAsB,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;AAE5E,MAAM,WAAW,8BAA8B;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,kBAAkB,CAAC;IACpC,MAAM,CAAC,EAAE,sBAAsB,GAAG,SAAS,CAAC;CAC7C;AAID,eAAO,MAAM,4BAA4B,GACvC,WAAW,8BAA8B,KACxC,0BAgBF,CAAC"}

package/dist/report/transcripts.js

@@ -0,0 +1,17 @@
+const acceptedSource = "moltnet-exported";
+export const evaluateTranscriptAcceptance = (artifact) => {
+    if (artifact?.source === acceptedSource) {
+        return {
+            accepted: true,
+            required_source: acceptedSource,
+            source: acceptedSource
+        };
+    }
+    const source = artifact?.source === "harness-derived" ? artifact.source : "unknown";
+    return {
+        accepted: false,
+        reason: "live simulation acceptance requires a moltnet-exported transcript",
+        required_source: acceptedSource,
+        source
+    };
+};

package/dist/runtime/causal-fixture.d.ts

@@ -0,0 +1,26 @@
+import { CAUSAL_ENVELOPE_VERSION, type CausalEmitter } from "../ledger/stable.js";
+import type { RuntimeTraceEvent } from "./types.js";
+export interface CausalFixtureRecord {
+    version: typeof CAUSAL_ENVELOPE_VERSION;
+    run_id: string;
+    event_id: string;
+    emitter: CausalEmitter;
+    type: string;
+    principal_id: string;
+    recorded_at: string;
+    cause_event_ids: string[];
+    payload: Record<string, unknown>;
+}
+/**
+ * Maps a runtime trace event (simfile's native ledger envelope) onto the
+ * noopolis.causal-event.v1 wire shape defined by root's
+ * `specs/causal-event.v1.schema.json` (referenced for shape parity, never
+ * imported — simfile keeps its own native TS type per the type-sharing rule).
+ *
+ * This is B92's real entry point: root's conformance harness invokes
+ * `npm run emit-causal-fixture` in this package and validates the printed
+ * JSONL, line by line, against the schema plus payload minimums.
+ */
+export declare const toCausalFixtureRecord: (event: RuntimeTraceEvent) => CausalFixtureRecord;
+export declare const buildCausalFixtureRecords: (events: readonly RuntimeTraceEvent[]) => CausalFixtureRecord[];
+//# sourceMappingURL=causal-fixture.d.ts.map

package/dist/runtime/causal-fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"causal-fixture.d.ts","sourceRoot":"","sources":["../../src/runtime/causal-fixture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAA2E,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC3J,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,uBAAuB,CAAC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,aAAa,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAgBD;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,iBAAiB,KAAG,mBAU/D,CAAC;AAEH,eAAO,MAAM,yBAAyB,GAAI,QAAQ,SAAS,iBAAiB,EAAE,KAAG,mBAAmB,EACjE,CAAC"}

package/dist/runtime/causal-fixture.js

@@ -0,0 +1,36 @@
+import { CAUSAL_ENVELOPE_VERSION, DEFAULT_EMITTER_STREAM_ID, DEFAULT_PRINCIPAL_ID, SIMFILE_EMITTER_SYSTEM } from "../ledger/stable.js";
+const asWirePayload = (event) => {
+    const extra = event.payload && typeof event.payload === "object" && !Array.isArray(event.payload)
+        ? event.payload
+        : { value: event.payload };
+    return {
+        sim_time: event.sim_time,
+        provenance: event.provenance,
+        actor: event.actor,
+        target: event.target,
+        scope: event.scope,
+        ...extra
+    };
+};
+/**
+ * Maps a runtime trace event (simfile's native ledger envelope) onto the
+ * noopolis.causal-event.v1 wire shape defined by root's
+ * `specs/causal-event.v1.schema.json` (referenced for shape parity, never
+ * imported — simfile keeps its own native TS type per the type-sharing rule).
+ *
+ * This is B92's real entry point: root's conformance harness invokes
+ * `npm run emit-causal-fixture` in this package and validates the printed
+ * JSONL, line by line, against the schema plus payload minimums.
+ */
+export const toCausalFixtureRecord = (event) => ({
+    version: event.version ?? CAUSAL_ENVELOPE_VERSION,
+    run_id: event.run_id ?? "",
+    event_id: event.event_id,
+    emitter: event.emitter ?? { system: SIMFILE_EMITTER_SYSTEM, stream_id: DEFAULT_EMITTER_STREAM_ID, seq: 0 },
+    type: event.kind,
+    principal_id: event.principal_id ?? DEFAULT_PRINCIPAL_ID,
+    recorded_at: event.recorded_at ?? new Date(0).toISOString(),
+    cause_event_ids: event.cause_event_ids ? [...event.cause_event_ids] : [],
+    payload: asWirePayload(event)
+});
+export const buildCausalFixtureRecords = (events) => events.map(toCausalFixtureRecord);

package/dist/runtime/clock.d.ts

@@ -0,0 +1,25 @@
+interface ParsedPhase {
+    id: string;
+    startSeconds: number;
+}
+export interface ClockSpec {
+    seed?: string;
+    tick: string;
+    sim_per_tick?: string;
+    phases?: Record<string, string>;
+}
+export interface ClockRuntime {
+    tickSeconds: number;
+    simPerTickSeconds: number;
+    phases: readonly ParsedPhase[];
+}
+export interface ResolvedClockState {
+    tick: number;
+    simTime: number;
+    phase: string | undefined;
+}
+export declare const parseClockSpec: (clock: ClockSpec) => ClockRuntime;
+export declare const resolveClockPhase: (clock: ClockRuntime, simTimeSeconds: number) => string | undefined;
+export declare const resolveClockState: (clock: ClockRuntime, tick: number) => ResolvedClockState;
+export {};
+//# sourceMappingURL=clock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../../src/runtime/clock.ts"],"names":[],"mappings":"AAEA,UAAU,WAAW;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;AAoBD,eAAO,MAAM,cAAc,GAAI,OAAO,SAAS,KAAG,YAoBjD,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,OAAO,YAAY,EAAE,gBAAgB,MAAM,KAAG,MAAM,GAAG,SAwBxF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,OAAO,YAAY,EAAE,MAAM,MAAM,KAAG,kBAOrE,CAAC"}

package/dist/runtime/clock.js

@@ -0,0 +1,63 @@
+import { parseDurationSeconds } from "../kernel/duration.js";
+const DAY_SECONDS = 86_400;
+const parsePhaseTime = (value) => {
+    const normalized = value.trim();
+    const [hoursRaw, minutesRaw] = normalized.split(":", 2);
+    if (hoursRaw === undefined || minutesRaw === undefined) {
+        throw new Error(`invalid phase time: ${value}`);
+    }
+    const hours = Number(hoursRaw);
+    const minutes = Number(minutesRaw);
+    if (!Number.isInteger(hours) || !Number.isInteger(minutes) || hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+        throw new Error(`invalid phase time: ${value}`);
+    }
+    return hours * 3600 + minutes * 60;
+};
+export const parseClockSpec = (clock) => {
+    const tickSeconds = parseDurationSeconds(clock.tick);
+    if (tickSeconds <= 0) {
+        throw new Error(`clock tick must be positive: ${clock.tick}`);
+    }
+    const simPerTickSeconds = clock.sim_per_tick ? parseDurationSeconds(clock.sim_per_tick) : tickSeconds;
+    if (simPerTickSeconds <= 0) {
+        throw new Error(`clock sim_per_tick must be positive: ${clock.sim_per_tick}`);
+    }
+    const phases = Object.entries(clock.phases ?? {})
+        .map(([id, rawStart]) => ({ id, startSeconds: parsePhaseTime(rawStart) }))
+        .sort((left, right) => left.startSeconds - right.startSeconds);
+    return {
+        tickSeconds,
+        simPerTickSeconds,
+        phases
+    };
+};
+export const resolveClockPhase = (clock, simTimeSeconds) => {
+    if (clock.phases.length === 0) {
+        return undefined;
+    }
+    const normalized = ((simTimeSeconds % DAY_SECONDS) + DAY_SECONDS) % DAY_SECONDS;
+    const first = clock.phases[0]?.startSeconds ?? 0;
+    const rotated = normalized < first ? normalized + DAY_SECONDS : normalized;
+    for (let index = 0; index < clock.phases.length; index += 1) {
+        const current = clock.phases[index];
+        if (!current) {
+            continue;
+        }
+        const next = clock.phases[(index + 1) % clock.phases.length];
+        const end = index + 1 === clock.phases.length
+            ? next.startSeconds + DAY_SECONDS
+            : next.startSeconds;
+        if (rotated >= current.startSeconds && rotated < end) {
+            return current.id;
+        }
+    }
+    return clock.phases.at(-1)?.id;
+};
+export const resolveClockState = (clock, tick) => {
+    const simTime = tick * clock.simPerTickSeconds;
+    return {
+        tick,
+        simTime,
+        phase: resolveClockPhase(clock, simTime)
+    };
+};

package/dist/runtime/condition.d.ts

@@ -0,0 +1,55 @@
+export interface ConditionVariableNode {
+    variable: string;
+    above?: number;
+    below?: number;
+    for?: string;
+}
+export interface ConditionPhaseNode {
+    phase: string;
+}
+export interface ConditionEventNode {
+    event: string;
+    target?: string;
+    actor?: string;
+    scope?: string;
+}
+export interface ConditionAllNode {
+    all: readonly ConditionNode[];
+}
+export interface ConditionAnyNode {
+    any: readonly ConditionNode[];
+}
+export interface ConditionNotNode {
+    not: ConditionNode;
+}
+export type ConditionNode = ConditionVariableNode | ConditionPhaseNode | ConditionEventNode | ConditionAllNode | ConditionAnyNode | ConditionNotNode;
+export interface ConditionEventMatch {
+    kind: string;
+    actor?: string;
+    target?: string;
+    scope?: string;
+}
+export interface RuntimeConditionContext {
+    tick: number;
+    simTime: number;
+    phase?: string;
+    variables: Readonly<Record<string, number>>;
+    eventsAtTick: readonly ConditionEventMatch[];
+}
+/**
+ * Every `variable` id referenced anywhere in a condition tree, deduped, in
+ * first-seen order — read straight off the compiled `when:` tree, never
+ * invented. The grounding for "this rule/event is about variable X": a
+ * caller (`trace-compile.ts`'s `compileRules`) uses this to precompute
+ * `RuleRuntime.variableIds`, which `step-tick.ts` then threads onto the
+ * rule's own `rule.fired` event and every world-effect event it emits, so
+ * the viewer can attribute those events to the variable's own storyline
+ * (`src/view/runTimelineRecords.ts`'s `buildWorldRecord`) without this
+ * package importing anything view-specific.
+ */
+export declare const conditionVariableIds: (node: ConditionNode) => string[];
+export declare class ConditionEvaluator {
+    private readonly holdState;
+    evaluate(node: ConditionNode, context: RuntimeConditionContext): boolean;
+}
+//# sourceMappingURL=condition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"condition.d.ts","sourceRoot":"","sources":["../../src/runtime/condition.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,SAAS,aAAa,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,SAAS,aAAa,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,aAAa,CAAC;CACpB;AAED,MAAM,MAAM,aAAa,GAAG,qBAAqB,GAAG,kBAAkB,GAAG,kBAAkB,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,gBAAgB,CAAC;AAErJ,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5C,YAAY,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAC9C;AAqFD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,aAAa,KAAG,MAAM,EA2BhE,CAAC;AAEF,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkD;IAErE,QAAQ,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,uBAAuB,GAAG,OAAO;CA2BhF"}

package/dist/runtime/condition.js

@@ -0,0 +1,122 @@
+import { parseDurationSeconds } from "../kernel/duration.js";
+const conditionKey = (node) => {
+    return `${node.variable}:${node.above ?? ""}:${node.below ?? ""}:${node.for ?? ""}`;
+};
+const matchesVariableCondition = (node, state, holdState) => {
+    const value = state.variables[node.variable];
+    const above = node.above ?? -Infinity;
+    const below = node.below ?? Infinity;
+    const now = Number.isFinite(value) ? value : 0;
+    const passesWindow = now > above && now < below;
+    if (node.for === undefined) {
+        return passesWindow;
+    }
+    const key = conditionKey(node);
+    const required = parseDurationSeconds(node.for);
+    if (!passesWindow) {
+        holdState.startTimeByCondition.delete(key);
+        return false;
+    }
+    const started = holdState.startTimeByCondition.get(key);
+    if (started === undefined) {
+        holdState.startTimeByCondition.set(key, state.simTime);
+        return required <= 0;
+    }
+    return state.simTime - started >= required;
+};
+const matchesEventCondition = (node, eventsAtTick) => {
+    return eventsAtTick.some((event) => {
+        if (event.kind !== node.event) {
+            return false;
+        }
+        if (node.actor !== undefined && node.actor !== event.actor) {
+            return false;
+        }
+        if (node.target !== undefined && node.target !== event.target) {
+            return false;
+        }
+        if (node.scope !== undefined && node.scope !== event.scope) {
+            return false;
+        }
+        return true;
+    });
+};
+const asVariableNode = (node) => {
+    return "variable" in node;
+};
+const asPhaseNode = (node) => {
+    return "phase" in node;
+};
+const asEventNode = (node) => {
+    return "event" in node;
+};
+const asAllNode = (node) => {
+    return "all" in node;
+};
+const asAnyNode = (node) => {
+    return "any" in node;
+};
+const asNotNode = (node) => {
+    return "not" in node;
+};
+/**
+ * Every `variable` id referenced anywhere in a condition tree, deduped, in
+ * first-seen order — read straight off the compiled `when:` tree, never
+ * invented. The grounding for "this rule/event is about variable X": a
+ * caller (`trace-compile.ts`'s `compileRules`) uses this to precompute
+ * `RuleRuntime.variableIds`, which `step-tick.ts` then threads onto the
+ * rule's own `rule.fired` event and every world-effect event it emits, so
+ * the viewer can attribute those events to the variable's own storyline
+ * (`src/view/runTimelineRecords.ts`'s `buildWorldRecord`) without this
+ * package importing anything view-specific.
+ */
+export const conditionVariableIds = (node) => {
+    const ids = [];
+    const seen = new Set();
+    const visit = (current) => {
+        if (asVariableNode(current)) {
+            if (!seen.has(current.variable)) {
+                seen.add(current.variable);
+                ids.push(current.variable);
+            }
+            return;
+        }
+        if (asAllNode(current)) {
+            current.all.forEach(visit);
+            return;
+        }
+        if (asAnyNode(current)) {
+            current.any.forEach(visit);
+            return;
+        }
+        if (asNotNode(current)) {
+            visit(current.not);
+        }
+    };
+    visit(node);
+    return ids;
+};
+export class ConditionEvaluator {
+    holdState = { startTimeByCondition: new Map() };
+    evaluate(node, context) {
+        if (asVariableNode(node)) {
+            return matchesVariableCondition(node, context, this.holdState);
+        }
+        if (asPhaseNode(node)) {
+            return context.phase === node.phase;
+        }
+        if (asEventNode(node)) {
+            return matchesEventCondition(node, context.eventsAtTick);
+        }
+        if (asAllNode(node)) {
+            return node.all.every((child) => this.evaluate(child, context));
+        }
+        if (asAnyNode(node)) {
+            return node.any.some((child) => this.evaluate(child, context));
+        }
+        if (asNotNode(node)) {
+            return !this.evaluate(node.not, context);
+        }
+        return false;
+    }
+}

package/dist/runtime/emit-causal-fixture.d.ts

@@ -0,0 +1,2 @@
+export declare const emitCausalFixtureJsonl: () => string[];
+//# sourceMappingURL=emit-causal-fixture.d.ts.map

package/dist/runtime/emit-causal-fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-causal-fixture.d.ts","sourceRoot":"","sources":["../../src/runtime/emit-causal-fixture.ts"],"names":[],"mappings":"AA8BA,eAAO,MAAM,sBAAsB,QAAO,MAAM,EAK/C,CAAC"}

package/dist/runtime/emit-causal-fixture.js

@@ -0,0 +1,45 @@
+import { parseSimfileSource } from "../schema/parse.js";
+import { buildCausalFixtureRecords } from "./causal-fixture.js";
+import { runSimfileTrace } from "./trace-run.js";
+/**
+ * B92's entry point into simfile: root's conformance harness shells out to
+ * `npm run emit-causal-fixture` and validates each printed line against
+ * `specs/causal-event.v1.schema.json` plus payload minimums. Keep stdout
+ * pure JSONL — one noopolis.causal-event.v1 record per line, no banner, no
+ * other console output.
+ */
+const FIXTURE_SOURCE = `
+simfile_version: "0.1"
+name: causal-fixture-world
+clock:
+  seed: causal-fixture
+  tick: 1m
+rules:
+  announce:
+    fire: once
+    when:
+      event: clock.sync
+    do:
+      - action: moltnet:message
+        to: room:office-floor:case-warroom
+        content: "causal fixture message"
+      - action: wake:recommend
+        to: room:office-floor:case-warroom
+`;
+export const emitCausalFixtureJsonl = () => {
+    const runId = process.env.NOOPOLIS_RUN_ID ?? "simfile-fixture-run";
+    const { simfile } = parseSimfileSource(FIXTURE_SOURCE, { path: "causal-fixture.yaml" });
+    const trace = runSimfileTrace(simfile, { runId, seed: "causal-fixture-seed", ticks: 2 });
+    return buildCausalFixtureRecords(trace.events).map((record) => JSON.stringify(record));
+};
+/* c8 ignore start -- thin stdout entry point, exercised via emitCausalFixtureJsonl in tests */
+const isMainModule = () => {
+    const entry = process.argv[1];
+    return typeof entry === "string" && import.meta.url === new URL(`file://${entry}`).href;
+};
+if (isMainModule()) {
+    for (const line of emitCausalFixtureJsonl()) {
+        process.stdout.write(`${line}\n`);
+    }
+}
+/* c8 ignore stop */

package/dist/runtime/expression.d.ts

@@ -0,0 +1,11 @@
+export interface CompiledExpression {
+    source: string;
+    dependencies: string[];
+    evaluate: (input: {
+        variables: Readonly<Record<string, number>>;
+        tick: number;
+        t: number;
+    }) => number;
+}
+export declare const compileExpression: (source: string) => CompiledExpression;
+//# sourceMappingURL=expression.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../../src/runtime/expression.ts"],"names":[],"mappings":"AA+UA,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,CAAC,KAAK,EAAE;QAAE,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,CAAC;CACvG;AAED,eAAO,MAAM,iBAAiB,GAAI,QAAQ,MAAM,KAAG,kBAkBlD,CAAC"}