simfile 0.0.1

package/dist/observe/seedSpreadArtifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seedSpreadArtifacts.d.ts","sourceRoot":"","sources":["../../src/observe/seedSpreadArtifacts.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AAEH,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AA4BD;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,uBAAuB,EAAE,CAepG,CAAC;AAyBF;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,GACtC,QAAQ,MAAM,KACb,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAmBzC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAgB7F,CAAC"}

package/dist/observe/seedSpreadArtifacts.js

@@ -0,0 +1,118 @@
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+const walkFiles = async (root) => {
+    const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+    const files = [];
+    for (const entry of entries) {
+        const entryPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await walkFiles(entryPath)));
+        }
+        else if (entry.isFile()) {
+            files.push(entryPath);
+        }
+    }
+    return files;
+};
+const messageText = (parts) => (parts ?? [])
+    .filter((part) => part.kind === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join(" ");
+/**
+ * Reads every `transcript.json` under `<runDir>/raw/moltnet/**` (today a
+ * single file; globbed so a future multi-network export nesting transcripts
+ * per network/room still gets picked up) and flattens every conversation's
+ * messages to `{id, fromId, text}`. Only the `moltnet.transcript-export.v1`
+ * export shape (`{conversations:[{messages}]}`) is read here — the seed-spread
+ * path only ever runs against a real composed/world-driven run, never the
+ * hand-authored golden-fixture shape (which never carries `seed_declaration`).
+ */
+export const readSpreadTranscriptMessages = async (runDir) => {
+    const moltnetDir = path.join(runDir, "raw", "moltnet");
+    const files = (await walkFiles(moltnetDir)).filter((file) => file.endsWith("transcript.json")).sort();
+    const messages = [];
+    for (const file of files) {
+        const raw = JSON.parse(await readFile(file, "utf8"));
+        for (const conversation of raw.conversations ?? []) {
+            for (const message of conversation.messages ?? []) {
+                if (typeof message.id !== "string")
+                    continue;
+                messages.push({ id: message.id, fromId: message.from?.id, text: messageText(message.parts) });
+            }
+        }
+    }
+    return messages;
+};
+/** Skips a line that fails to parse rather than crashing the whole read —
+ * these are diagnostic bank/tick artifacts, never the causal ledger itself. */
+const parseJsonlLines = (text) => {
+    const parsed = [];
+    for (const rawLine of text.split(/\r?\n/u)) {
+        const line = rawLine.trim();
+        if (line.length === 0)
+            continue;
+        try {
+            parsed.push(JSON.parse(line));
+        }
+        catch {
+            continue;
+        }
+    }
+    return parsed;
+};
+/**
+ * Reads every mneme bank's `events.jsonl` (the write-side/interim signal —
+ * same file `memoryBanks.ts` falls back to) into `{id, type, agentId, text}`,
+ * keyed by bank directory name. Every field is read verbatim from the
+ * sealed file; a malformed line is skipped rather than crashing the whole
+ * read (mirrors this folder's "report, don't stitch" posture for a
+ * diagnostic-only artifact).
+ */
+export const readSpreadMnemeEventsByBank = async (runDir) => {
+    const mnemeDir = path.join(runDir, "raw", "mneme");
+    const bankDirs = await readdir(mnemeDir, { withFileTypes: true }).catch(() => []);
+    const byBank = new Map();
+    for (const entry of bankDirs) {
+        if (!entry.isDirectory())
+            continue;
+        const text = await readFile(path.join(mnemeDir, entry.name, "events.jsonl"), "utf8").catch(() => null);
+        if (text === null)
+            continue;
+        const events = [];
+        for (const line of parseJsonlLines(text)) {
+            const row = line;
+            if (typeof row.id !== "string" || typeof row.type !== "string")
+                continue;
+            events.push({ id: row.id, type: row.type, agentId: row.principal?.agentId, text: row.content?.text ?? "" });
+        }
+        byBank.set(entry.name, events);
+    }
+    return byBank;
+};
+/**
+ * Reads `<runDir>/world/ingested-messages.jsonl` (note: NOT under `raw/` —
+ * `worldLedgerWriter.ts`'s own diagnostic, one line per tick,
+ * `{tick, message_ids}`) into a `message_id -> tick` map: the one exact,
+ * non-wall-clock fact the live world loop recorded about when it folded a
+ * given Moltnet message into the run. Absent entirely for a run that wasn't
+ * world-driven (batch `composedOfficeSimDriver`-style runs never write this
+ * file) — returns an empty map rather than failing.
+ */
+export const readTickByIngestedMessageId = async (runDir) => {
+    const filePath = path.join(runDir, "world", "ingested-messages.jsonl");
+    const text = await readFile(filePath, "utf8").catch(() => null);
+    if (text === null)
+        return new Map();
+    const byMessageId = new Map();
+    for (const line of parseJsonlLines(text)) {
+        const row = line;
+        if (typeof row.tick !== "number" || !Array.isArray(row.message_ids))
+            continue;
+        for (const messageId of row.message_ids) {
+            if (typeof messageId === "string" && !byMessageId.has(messageId)) {
+                byMessageId.set(messageId, row.tick);
+            }
+        }
+    }
+    return byMessageId;
+};

package/dist/observe/spreadMatcher.d.ts

@@ -0,0 +1,45 @@
+export declare const DEFAULT_EDIT_DISTANCE = 2;
+export type ParsedSpreadMatcherPolicy = {
+    readonly kind: "exact";
+} | {
+    readonly kind: "edit-distance";
+    readonly maxDistance: number;
+};
+export interface SpreadMatchResult {
+    matched: boolean;
+    /** Zero for a miss; otherwise the normalized closeness of the best match. */
+    fidelity: number;
+}
+export declare class UnsupportedSpreadMatcherPolicyError extends Error {
+    readonly policy: string;
+    constructor(policy: string);
+}
+export declare class InvalidSpreadMatcherPolicyError extends Error {
+    readonly policy: string;
+    constructor(policy: string);
+}
+/**
+ * Parses the manifest's pinned matcher policy. `edit-distance` defaults to
+ * k=2. `edit-distance:<k>` is the canonical parameterized spelling; the
+ * contract-style `edit-distance<=<k>` and `edit-distance≤<k>` spellings are
+ * accepted too. Bounds must be non-negative safe integers.
+ *
+ * Embedding/judge spellings are recognized but throw a typed error because
+ * this runtime-neutral build has no model with which to execute them.
+ */
+export declare const parseSpreadMatcherPolicy: (policy: string) => ParsedSpreadMatcherPolicy;
+/** Standard Levenshtein distance over Unicode code points, not UTF-16 units. */
+export declare const levenshteinDistance: (left: string, right: string) => number;
+/**
+ * Finds a seed occurrence under a pinned matcher policy.
+ *
+ * Exact matching delegates to `containsAlias`, preserving its case-insensitive
+ * Unicode word boundaries. Edit-distance matching NFC-normalizes and case-folds
+ * lexical words, then compares each token-set entry with viable contiguous text
+ * windows (punctuation/whitespace between words normalize to one space). A
+ * qualifying pair's fidelity is
+ * `1 - distance / max(codePointLength(candidate), codePointLength(seed))`;
+ * the highest qualifying fidelity wins.
+ */
+export declare const matchSeedSpread: (text: string, tokenSet: readonly string[], matcherPolicy: string | ParsedSpreadMatcherPolicy) => SpreadMatchResult;
+//# sourceMappingURL=spreadMatcher.d.ts.map

package/dist/observe/spreadMatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spreadMatcher.d.ts","sourceRoot":"","sources":["../../src/observe/spreadMatcher.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC,MAAM,MAAM,yBAAyB,GACjC;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAErE,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,mCAAoC,SAAQ,KAAK;IAC5D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM;CAK3B;AAED,qBAAa,+BAAgC,SAAQ,KAAK;IACxD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM;CAK3B;AAKD;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,GAAI,QAAQ,MAAM,KAAG,yBAgBzD,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,KAAG,MAmBjE,CAAC;AAwDF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GAC1B,MAAM,MAAM,EACZ,UAAU,SAAS,MAAM,EAAE,EAC3B,eAAe,MAAM,GAAG,yBAAyB,KAChD,iBAaF,CAAC"}

package/dist/observe/spreadMatcher.js

@@ -0,0 +1,124 @@
+import { containsAlias } from "../ledger/markers.js";
+export const DEFAULT_EDIT_DISTANCE = 2;
+export class UnsupportedSpreadMatcherPolicyError extends Error {
+    policy;
+    constructor(policy) {
+        super(`unsupported policy in this build: "${policy}" requires an embedding or judge model`);
+        this.name = "UnsupportedSpreadMatcherPolicyError";
+        this.policy = policy;
+    }
+}
+export class InvalidSpreadMatcherPolicyError extends Error {
+    policy;
+    constructor(policy) {
+        super(`invalid seed spread matcher policy: "${policy}"`);
+        this.name = "InvalidSpreadMatcherPolicyError";
+        this.policy = policy;
+    }
+}
+const EDIT_DISTANCE_POLICY = /^edit-distance(?:\s*(?::|<=|≤)\s*(\d+))?$/u;
+const EMBEDDING_POLICY = /^embedding(?:$|\s*(?::|>=|≥))/u;
+/**
+ * Parses the manifest's pinned matcher policy. `edit-distance` defaults to
+ * k=2. `edit-distance:<k>` is the canonical parameterized spelling; the
+ * contract-style `edit-distance<=<k>` and `edit-distance≤<k>` spellings are
+ * accepted too. Bounds must be non-negative safe integers.
+ *
+ * Embedding/judge spellings are recognized but throw a typed error because
+ * this runtime-neutral build has no model with which to execute them.
+ */
+export const parseSpreadMatcherPolicy = (policy) => {
+    const normalized = policy.trim();
+    if (normalized === "exact")
+        return { kind: "exact" };
+    const editDistance = EDIT_DISTANCE_POLICY.exec(normalized);
+    if (editDistance) {
+        const maxDistance = editDistance[1] === undefined ? DEFAULT_EDIT_DISTANCE : Number(editDistance[1]);
+        if (Number.isSafeInteger(maxDistance))
+            return { kind: "edit-distance", maxDistance };
+        throw new InvalidSpreadMatcherPolicyError(policy);
+    }
+    if (EMBEDDING_POLICY.test(normalized) || normalized === "judge" || normalized === "judge-model") {
+        throw new UnsupportedSpreadMatcherPolicyError(policy);
+    }
+    throw new InvalidSpreadMatcherPolicyError(policy);
+};
+/** Standard Levenshtein distance over Unicode code points, not UTF-16 units. */
+export const levenshteinDistance = (left, right) => {
+    const leftPoints = [...left];
+    const rightPoints = [...right];
+    let previous = Array.from({ length: rightPoints.length + 1 }, (_, index) => index);
+    for (let leftIndex = 1; leftIndex <= leftPoints.length; leftIndex += 1) {
+        const current = [leftIndex];
+        for (let rightIndex = 1; rightIndex <= rightPoints.length; rightIndex += 1) {
+            const substitutionCost = leftPoints[leftIndex - 1] === rightPoints[rightIndex - 1] ? 0 : 1;
+            current[rightIndex] = Math.min(current[rightIndex - 1] + 1, previous[rightIndex] + 1, previous[rightIndex - 1] + substitutionCost);
+        }
+        previous = current;
+    }
+    return previous[rightPoints.length];
+};
+const lexicalWords = (value) => (value.normalize("NFC").match(/[\p{L}\p{M}\p{N}_]+/gu) ?? []).map((word) => word.toLowerCase());
+const codePointLength = (value) => [...value].length;
+const bestWindowMatch = (textWords, seedWords, maxDistance) => {
+    let matched = false;
+    let bestFidelity = 0;
+    const normalizedSeed = seedWords.join(" ");
+    const seedLength = codePointLength(normalizedSeed);
+    for (let start = 0; start < textWords.length; start += 1) {
+        const candidateWords = [];
+        for (let end = start; end < textWords.length; end += 1) {
+            candidateWords.push(textWords[end]);
+            const candidate = candidateWords.join(" ");
+            const candidateLength = codePointLength(candidate);
+            if (candidateLength > seedLength + maxDistance)
+                break;
+            if (Math.abs(candidateLength - seedLength) > maxDistance)
+                continue;
+            const distance = levenshteinDistance(candidate, normalizedSeed);
+            if (distance > maxDistance)
+                continue;
+            matched = true;
+            const denominator = Math.max(candidateLength, seedLength);
+            const fidelity = denominator === 0 ? 1 : 1 - distance / denominator;
+            bestFidelity = Math.max(bestFidelity, fidelity);
+        }
+    }
+    return { matched, fidelity: matched ? bestFidelity : 0 };
+};
+const editDistanceMatch = (text, tokenSet, maxDistance) => {
+    const textWords = lexicalWords(text);
+    let bestMatch = { matched: false, fidelity: 0 };
+    for (const token of tokenSet) {
+        const seedWords = lexicalWords(token);
+        if (seedWords.length === 0)
+            continue;
+        const aliasMatch = bestWindowMatch(textWords, seedWords, maxDistance);
+        if (aliasMatch.matched && (!bestMatch.matched || aliasMatch.fidelity > bestMatch.fidelity)) {
+            bestMatch = aliasMatch;
+        }
+    }
+    return bestMatch;
+};
+/**
+ * Finds a seed occurrence under a pinned matcher policy.
+ *
+ * Exact matching delegates to `containsAlias`, preserving its case-insensitive
+ * Unicode word boundaries. Edit-distance matching NFC-normalizes and case-folds
+ * lexical words, then compares each token-set entry with viable contiguous text
+ * windows (punctuation/whitespace between words normalize to one space). A
+ * qualifying pair's fidelity is
+ * `1 - distance / max(codePointLength(candidate), codePointLength(seed))`;
+ * the highest qualifying fidelity wins.
+ */
+export const matchSeedSpread = (text, tokenSet, matcherPolicy) => {
+    const policy = typeof matcherPolicy === "string" ? parseSpreadMatcherPolicy(matcherPolicy) : matcherPolicy;
+    if (policy.kind === "edit-distance" && (!Number.isSafeInteger(policy.maxDistance) || policy.maxDistance < 0)) {
+        throw new InvalidSpreadMatcherPolicyError(JSON.stringify(policy));
+    }
+    if (policy.kind === "exact") {
+        const matched = tokenSet.some((token) => containsAlias(text, token));
+        return { matched, fidelity: matched ? 1 : 0 };
+    }
+    return editDistanceMatch(text, tokenSet, policy.maxDistance);
+};

package/dist/report/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./probes.js";
+export * from "./score.js";
+export * from "./transcripts.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/report/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC"}

package/dist/report/index.js

@@ -0,0 +1,3 @@
+export * from "./probes.js";
+export * from "./score.js";
+export * from "./transcripts.js";

package/dist/report/probeArtifact.d.ts

@@ -0,0 +1,26 @@
+import type { LedgerEvent } from "../ledger/markers.js";
+export interface ProbeSample {
+    evidence_id?: string;
+    event_id?: string;
+    tick?: number;
+    sim_time?: number;
+    phase?: string;
+    variables?: Record<string, number>;
+}
+export interface ProbeArtifact {
+    events: readonly LedgerEvent[];
+    samples?: readonly ProbeSample[];
+}
+export interface ProbeOccurrence {
+    evidenceId: string;
+    simTime?: number;
+    tick?: number;
+    phase?: string;
+    variables?: Readonly<Record<string, number>>;
+    event?: LedgerEvent;
+}
+export declare const normalizeProbeArtifact: (input: readonly LedgerEvent[] | ProbeArtifact) => ProbeArtifact;
+export declare const buildSampleOccurrences: (events: readonly LedgerEvent[], explicitSamples: readonly ProbeSample[]) => ProbeOccurrence[];
+export declare const buildEventOccurrences: (events: readonly LedgerEvent[]) => ProbeOccurrence[];
+export declare const attachVariablesToEventOccurrences: (events: readonly ProbeOccurrence[], samples: readonly ProbeOccurrence[]) => ProbeOccurrence[];
+//# sourceMappingURL=probeArtifact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"probeArtifact.d.ts","sourceRoot":"","sources":["../../src/report/probeArtifact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IAC/B,OAAO,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;CAClC;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB;AAqCD,eAAO,MAAM,sBAAsB,GAAI,OAAO,SAAS,WAAW,EAAE,GAAG,aAAa,KAAG,aAMtF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,QAAQ,SAAS,WAAW,EAAE,EAC9B,iBAAiB,SAAS,WAAW,EAAE,KACtC,eAAe,EA0DjB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,QAAQ,SAAS,WAAW,EAAE,KAAG,eAAe,EAwBrF,CAAC;AAEF,eAAO,MAAM,iCAAiC,GAC5C,QAAQ,SAAS,eAAe,EAAE,EAClC,SAAS,SAAS,eAAe,EAAE,KAClC,eAAe,EAcjB,CAAC"}

package/dist/report/probeArtifact.js

@@ -0,0 +1,119 @@
+const isObject = (value) => typeof value === "object" && value !== null;
+const evidenceId = (event, fallbackIndex) => event.event_id ?? `index:${fallbackIndex}`;
+const clockSampleFromEvent = (event, index) => {
+    if (event.kind !== "clock.sync" || !isObject(event.payload)) {
+        return undefined;
+    }
+    const payload = event.payload;
+    const tick = typeof payload.tick === "number" && Number.isFinite(payload.tick) ? payload.tick : undefined;
+    const simTime = typeof event.sim_time === "number" && Number.isFinite(event.sim_time)
+        ? event.sim_time
+        : typeof payload.sim_time === "number" && Number.isFinite(payload.sim_time)
+            ? payload.sim_time
+            : undefined;
+    const phase = typeof payload.phase === "string" ? payload.phase : undefined;
+    return {
+        evidenceId: evidenceId(event, index),
+        tick,
+        simTime,
+        phase
+    };
+};
+const explicitSampleId = (sample, index) => sample.evidence_id ?? sample.event_id ?? `sample:${index}`;
+export const normalizeProbeArtifact = (input) => {
+    if (Array.isArray(input)) {
+        return { events: input, samples: [] };
+    }
+    const artifact = input;
+    return { events: artifact.events, samples: artifact.samples ?? [] };
+};
+export const buildSampleOccurrences = (events, explicitSamples) => {
+    const clockSamples = events
+        .map((event, index) => clockSampleFromEvent(event, index))
+        .filter((sample) => sample !== undefined);
+    const explicitByTick = new Map();
+    const explicitByEvidence = new Map();
+    const matchedExplicit = new Set();
+    explicitSamples.forEach((sample, index) => {
+        if (sample.tick !== undefined && !explicitByTick.has(sample.tick)) {
+            explicitByTick.set(sample.tick, { sample, index });
+        }
+        const sampleId = explicitSampleId(sample, index);
+        if (!explicitByEvidence.has(sampleId)) {
+            explicitByEvidence.set(sampleId, { sample, index });
+        }
+    });
+    const normalized = clockSamples.map((clockSample) => {
+        const byEvidence = explicitByEvidence.get(clockSample.evidenceId);
+        const byTick = clockSample.tick !== undefined ? explicitByTick.get(clockSample.tick) : undefined;
+        const explicit = byEvidence ?? byTick;
+        if (explicit) {
+            matchedExplicit.add(explicit.index);
+        }
+        return {
+            evidenceId: explicit ? explicitSampleId(explicit.sample, explicit.index) : clockSample.evidenceId,
+            tick: explicit?.sample.tick ?? clockSample.tick,
+            simTime: explicit?.sample.sim_time ?? clockSample.simTime,
+            phase: explicit?.sample.phase ?? clockSample.phase,
+            variables: explicit?.sample.variables
+        };
+    });
+    explicitSamples.forEach((sample, index) => {
+        if (matchedExplicit.has(index)) {
+            return;
+        }
+        normalized.push({
+            evidenceId: explicitSampleId(sample, index),
+            tick: sample.tick,
+            simTime: sample.sim_time,
+            phase: sample.phase,
+            variables: sample.variables
+        });
+    });
+    return normalized.sort((left, right) => {
+        const leftTick = left.tick ?? Number.MAX_SAFE_INTEGER;
+        const rightTick = right.tick ?? Number.MAX_SAFE_INTEGER;
+        if (leftTick !== rightTick) {
+            return leftTick - rightTick;
+        }
+        const leftTime = left.simTime ?? Number.MAX_SAFE_INTEGER;
+        const rightTime = right.simTime ?? Number.MAX_SAFE_INTEGER;
+        return leftTime - rightTime;
+    });
+};
+export const buildEventOccurrences = (events) => {
+    const occurrences = [];
+    let activeTick;
+    let activePhase;
+    let activeSimTime;
+    events.forEach((event, index) => {
+        const clockSample = clockSampleFromEvent(event, index);
+        if (clockSample) {
+            activeTick = clockSample.tick;
+            activePhase = clockSample.phase;
+            activeSimTime = clockSample.simTime;
+        }
+        occurrences.push({
+            evidenceId: evidenceId(event, index),
+            simTime: event.sim_time ?? activeSimTime,
+            tick: activeTick,
+            phase: activePhase,
+            event
+        });
+    });
+    return occurrences;
+};
+export const attachVariablesToEventOccurrences = (events, samples) => {
+    const sampleByTick = new Map();
+    samples.forEach((sample) => {
+        if (sample.tick !== undefined && !sampleByTick.has(sample.tick)) {
+            sampleByTick.set(sample.tick, sample);
+        }
+    });
+    return events.map((event) => ({
+        ...event,
+        variables: event.tick !== undefined ? sampleByTick.get(event.tick)?.variables : undefined,
+        phase: event.tick !== undefined ? sampleByTick.get(event.tick)?.phase ?? event.phase : event.phase,
+        simTime: event.tick !== undefined ? sampleByTick.get(event.tick)?.simTime ?? event.simTime : event.simTime
+    }));
+};

package/dist/report/probes.d.ts

@@ -0,0 +1,52 @@
+import type { LedgerEvent } from "../ledger/markers.js";
+import { type ProbeArtifact } from "./probeArtifact.js";
+export interface ProbeEventAtom {
+    event: string;
+    target?: string;
+    actor?: string;
+    scope?: string;
+}
+export interface ProbeVariableAtom {
+    variable: string;
+    above?: number;
+    below?: number;
+    for?: string;
+}
+export interface ProbePhaseAtom {
+    phase: string;
+}
+export interface ProbeAllNode {
+    all: readonly ProbeNode[];
+}
+export interface ProbeAnyNode {
+    any: readonly ProbeNode[];
+}
+export interface ProbeNotNode {
+    not: ProbeNode;
+}
+export type ProbeNode = ProbeEventAtom | ProbeVariableAtom | ProbePhaseAtom | ProbeAllNode | ProbeAnyNode | ProbeNotNode;
+export type ProbeExpectation = {
+    at_least: number;
+} | {
+    at_most: number;
+} | {
+    always: true;
+} | {
+    at_end: true;
+};
+export interface ProbeDefinition {
+    when: ProbeNode;
+    expect: ProbeExpectation;
+    after?: ProbeWhenCondition;
+    within?: string;
+}
+export type ProbeWhenCondition = ProbeNode;
+export type { ProbeArtifact, ProbeSample } from "./probeArtifact.js";
+export interface ProbeEvaluationResult {
+    probeId: string;
+    passed: boolean;
+    evidence: string[];
+    count: number;
+}
+export declare const evaluateProbe: (probeId: string, artifactOrEvents: readonly LedgerEvent[] | ProbeArtifact, probe: ProbeDefinition) => ProbeEvaluationResult;
+//# sourceMappingURL=probes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"probes.d.ts","sourceRoot":"","sources":["../../src/report/probes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAKL,KAAK,aAAa,EAGnB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,cAAc;IAC7B,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,iBAAiB;IAChC,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,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,SAAS,SAAS,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,SAAS,SAAS,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,SAAS,CAAC;CAChB;AAED,MAAM,MAAM,SAAS,GAAG,cAAc,GAAG,iBAAiB,GAAG,cAAc,GAAG,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC;AAEzH,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GACpB;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GACnB;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,GAChB;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC;AAErB,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,kBAAkB,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,kBAAkB,GAAG,SAAS,CAAC;AAE3C,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAErE,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAwKD,eAAO,MAAM,aAAa,GACxB,SAAS,MAAM,EACf,kBAAkB,SAAS,WAAW,EAAE,GAAG,aAAa,EACxD,OAAO,eAAe,KACrB,qBAoCF,CAAC"}