@descryy/runtime-evidence-store 0.0.0

package/dist/evidence-store.js

@@ -0,0 +1,511 @@
+/**
+ * Evidence store (plan §13; plan §36 gate 9 "evidence persistence").
+ * Persistence keyed by executionId, backed by `node:sqlite` — mirrors
+ * descry-core's choice (CLAUDE.md: "node:sqlite behind a driver
+ * interface") for the same reason: zero native deps, no node-gyp-per-
+ * platform distribution problem. A full swappable-driver abstraction
+ * (descry-core's `SqlDriver`) is skipped here — one table, no real
+ * swap-target in view — but the row-rehydration pattern is kept:
+ * `node:sqlite` returns null-prototype row objects, which trips up
+ * `JSON.stringify` and structural-equality checks in ways that are easy to
+ * miss, so every row is spread into a plain object before use.
+ *
+ * `node:sqlite` is experimental in this Node version and prints an
+ * `ExperimentalWarning`. descry-core's own policy is to suppress that only
+ * at a CLI entrypoint, never in library code or tests — this package has
+ * no entrypoint of its own, so nothing here suppresses it.
+ */
+import { DatabaseSync } from "node:sqlite";
+import { randomUUID } from "node:crypto";
+import { EVIDENCE_SOURCES, REDACTION_STATUSES, RUNTIME_EVENT_TYPES, } from "@descryy/runtime-contracts";
+import { redact } from "./redaction.js";
+import { captureEnvironment, environmentDifferences, } from "./replay.js";
+export class EvidenceStore {
+    #db;
+    #redactionPolicy;
+    #retentionMs;
+    constructor(options) {
+        this.#redactionPolicy = options.redactionPolicy ?? {};
+        this.#retentionMs = options.retentionMs ?? null;
+        this.#db = new DatabaseSync(options.path);
+        this.#db.exec(`
+      CREATE TABLE IF NOT EXISTS evidence (
+        evidence_id TEXT PRIMARY KEY,
+        execution_id TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        source TEXT NOT NULL,
+        service TEXT,
+        process TEXT,
+        event_type TEXT NOT NULL,
+        payload TEXT NOT NULL,
+        trace_id TEXT,
+        request_id TEXT,
+        correlation_id TEXT,
+        graph_node_id TEXT,
+        source_location TEXT,
+        stack_trace TEXT,
+        confidence REAL NOT NULL,
+        redaction_status TEXT NOT NULL,
+        collector_version TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_evidence_execution ON evidence(execution_id);
+      -- §24's missing half. Evidence survived a process restart; the
+      -- execution that produced it did not -- it lived in
+      -- ExecutionController's memory and nowhere on disk, so after a
+      -- restart the store held rows keyed by an executionId that no longer
+      -- resolved to an application, a commit, or a configuration.
+      --
+      -- A NEW TABLE, never a new column on the evidence table. An added
+      -- table appears under CREATE TABLE IF NOT EXISTS on an existing store
+      -- file;
+      -- an added column would need a migration this package has no
+      -- mechanism for, and inventing one to persist a fingerprint would be
+      -- a schema-versioning decision taken sideways.
+      CREATE TABLE IF NOT EXISTS executions (
+        execution_id TEXT PRIMARY KEY,
+        application TEXT NOT NULL,
+        repository TEXT NOT NULL,
+        commit_sha TEXT NOT NULL,
+        recorded_at TEXT NOT NULL,
+        configuration TEXT NOT NULL,
+        environment TEXT NOT NULL,
+        redacted_keys TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_evidence_trace ON evidence(trace_id);
+      CREATE INDEX IF NOT EXISTS idx_evidence_request ON evidence(request_id);
+      CREATE INDEX IF NOT EXISTS idx_evidence_correlation ON evidence(correlation_id);
+      CREATE INDEX IF NOT EXISTS idx_evidence_service ON evidence(service);
+      CREATE INDEX IF NOT EXISTS idx_evidence_node ON evidence(graph_node_id);
+      CREATE INDEX IF NOT EXISTS idx_evidence_timestamp ON evidence(timestamp);
+      -- An expression index, because source_location is stored as JSON
+      -- rather than split into columns. Splitting it would be the faster
+      -- schema and would also mean migrating every existing store on disk;
+      -- the JSON stays authoritative and the index makes the file lookup a
+      -- seek instead of a scan.
+      CREATE INDEX IF NOT EXISTS idx_evidence_source_file ON evidence(json_extract(source_location, '$.file'));
+    `);
+    }
+    /**
+     * The only way to persist evidence. Redaction runs here, unconditionally
+     * — `EvidenceInput` has no `redactionStatus` field a caller could set,
+     * so there is no way to write a record claiming redaction happened
+     * without redact() actually having run. This is the structural
+     * guarantee plan §28 asks for: "raw runtime evidence must not
+     * automatically become unrestricted AI context."
+     */
+    write(input) {
+        // **Validated at the boundary, not trusted from the type system (§3).**
+        // `EvidenceInput` is typed, and inside one compiled program that is
+        // enough. It stops being enough the moment a value arrives from anywhere
+        // the compiler did not check — a JSON body, a stored row from another
+        // version, a hand-written fixture, a collector built against an older
+        // contract. §3's own rows are "invalid event rejected" and "unknown event
+        // handled explicitly", and a compile-time union answers neither.
+        //
+        // Throws rather than coerces. A caller writing an event type this build
+        // does not know is a bug, and the cheapest moment to say so is before the
+        // row exists.
+        assertInVocabulary("eventType", input.eventType, RUNTIME_EVENT_TYPES);
+        assertInVocabulary("source", input.source, EVIDENCE_SOURCES);
+        const { payload, redactionStatus } = redact(input.payload, this.#redactionPolicy);
+        const evidence = { ...input, evidenceId: randomUUID(), payload, redactionStatus };
+        this.#db
+            .prepare(`INSERT INTO evidence (
+          evidence_id, execution_id, timestamp, source, service, process, event_type,
+          payload, trace_id, request_id, correlation_id, graph_node_id,
+          source_location, stack_trace, confidence, redaction_status, collector_version
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(evidence.evidenceId, evidence.executionId, evidence.timestamp, evidence.source, evidence.service, evidence.process, evidence.eventType, JSON.stringify(evidence.payload), evidence.traceId, evidence.requestId, evidence.correlationId, evidence.graphNodeId, evidence.sourceLocation ? JSON.stringify(evidence.sourceLocation) : null, evidence.stackTrace ? JSON.stringify(evidence.stackTrace) : null, evidence.confidence, evidence.redactionStatus, evidence.collectorVersion);
+        return evidence;
+    }
+    /** Every item this execution produced, oldest first — retrievable after the execution has ended, as long as the store is reopened against the same file (plan §36 gate 9). */
+    getByExecution(executionId) {
+        const rows = this.#db
+            .prepare(`SELECT * FROM evidence WHERE execution_id = ? ORDER BY timestamp ASC`)
+            .all(executionId);
+        return rows.map(rowToEvidence);
+    }
+    getById(evidenceId) {
+        const row = this.#db.prepare(`SELECT * FROM evidence WHERE evidence_id = ?`).get(evidenceId);
+        return row ? rowToEvidence(row) : null;
+    }
+    /**
+     * Every row whose enum fields this build cannot interpret (§3).
+     *
+     * The explicit runtime path for an unknown event. Reads the raw columns
+     * without rehydrating, so it works on precisely the store that `query()`
+     * refuses — a caller that hits the refusal can call this to learn which
+     * rows, which fields and which values, instead of having a throw and no
+     * next step.
+     *
+     * Deliberately reports rather than repairs. Rewriting an unknown
+     * `event_type` to something this build knows would be inventing an
+     * observation, and deleting the row would destroy evidence that a newer
+     * build can read perfectly well.
+     */
+    integrityCheck() {
+        const rows = this.#db
+            .prepare(`SELECT evidence_id, source, event_type, redaction_status FROM evidence`)
+            .all();
+        const issues = [];
+        for (const raw of rows) {
+            const row = { ...raw };
+            for (const [field, value, vocabulary] of [
+                ["eventType", row.event_type, RUNTIME_EVENT_TYPES],
+                ["source", row.source, EVIDENCE_SOURCES],
+                ["redactionStatus", row.redaction_status, REDACTION_STATUSES],
+            ]) {
+                if (!vocabulary.includes(value)) {
+                    issues.push({ evidenceId: row.evidence_id, field, value });
+                }
+            }
+        }
+        return issues;
+    }
+    /**
+     * Persist the execution behind an `executionId` (§24).
+     *
+     * **The configuration is redacted on the way in, and that is not an
+     * over-application of §20.** Every one of §20's rows is about an evidence
+     * payload, but `configuration.services[x].command` is a command line, and
+     * a command line is one of the classic places a credential travels:
+     * `node server.mjs --api-key=…`. The same `redact()` the evidence write
+     * path uses runs here, on the same terms, and `redactedKeys` reports what
+     * it caught rather than leaving a caller to guess.
+     *
+     * Re-recording the same `executionId` replaces the row. An execution is
+     * recorded once by the component that owns it; a second record for the
+     * same id is a re-run of that recording, not a second execution.
+     */
+    recordExecution(input) {
+        const { payload: configuration, redactedKeys } = redact(input.configuration, this.#redactionPolicy);
+        const environment = input.environment ?? captureEnvironment(serviceCommandsOf(configuration));
+        const recordedAt = input.recordedAt ?? new Date().toISOString();
+        this.#db
+            .prepare(`INSERT INTO executions (
+           execution_id, application, repository, commit_sha, recorded_at,
+           configuration, environment, redacted_keys
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(execution_id) DO UPDATE SET
+           application = excluded.application,
+           repository = excluded.repository,
+           commit_sha = excluded.commit_sha,
+           recorded_at = excluded.recorded_at,
+           configuration = excluded.configuration,
+           environment = excluded.environment,
+           redacted_keys = excluded.redacted_keys`)
+            .run(input.executionId, input.application, input.repository, input.commit, recordedAt, JSON.stringify(configuration), JSON.stringify(environment), JSON.stringify(redactedKeys));
+        return {
+            executionId: input.executionId,
+            application: input.application,
+            repository: input.repository,
+            commit: input.commit,
+            recordedAt,
+            configuration,
+            environment,
+            redactedKeys,
+        };
+    }
+    getExecution(executionId) {
+        const row = this.#db.prepare(`SELECT * FROM executions WHERE execution_id = ?`).get(executionId);
+        if (row === undefined)
+            return null;
+        return {
+            executionId: String(row["execution_id"]),
+            application: String(row["application"]),
+            repository: String(row["repository"]),
+            commit: String(row["commit_sha"]),
+            recordedAt: String(row["recorded_at"]),
+            configuration: JSON.parse(String(row["configuration"])),
+            environment: JSON.parse(String(row["environment"])),
+            redactedKeys: JSON.parse(String(row["redacted_keys"])),
+        };
+    }
+    /**
+     * Replay an execution's evidence (§24).
+     *
+     * **Replays evidence, not the application.** Nothing is spawned, driven or
+     * reissued; this returns what was recorded, in recorded order, so
+     * correlation, findings and an evidence package can be re-derived without
+     * booting anything. A replay that quietly re-executed would produce a *new*
+     * observation while claiming to reproduce an old one.
+     *
+     * Throws for an unrecorded execution rather than returning an empty
+     * replay. Evidence rows can exist for an `executionId` that was never
+     * recorded — that is precisely the pre-§24 state — and answering with
+     * "here is your replay, minus the execution" would present the gap as a
+     * result.
+     */
+    replay(executionId, currentEnvironment) {
+        const execution = this.getExecution(executionId);
+        if (execution === null) {
+            throw new Error(`replay: no execution recorded for ${JSON.stringify(executionId)}. Evidence may still exist for ` +
+                "it — this store held evidence for unrecorded executions before recordExecution existed — but " +
+                "a replay without the configuration and environment it ran under is not a replay.");
+        }
+        const evidence = this.getByExecution(executionId);
+        const current = currentEnvironment ?? captureEnvironment(serviceCommandsOf(execution.configuration));
+        const warnings = [];
+        const differences = environmentDifferences(execution.environment, current);
+        if (differences.length > 0) {
+            warnings.push({
+                kind: "environment-changed",
+                detail: `The environment differs from the one this execution was recorded in: ${differences.join("; ")}. ` +
+                    "Reported, not enforced — whether it matters is a judgement this store has no information to make.",
+            });
+        }
+        if (evidence.length === 0) {
+            warnings.push({
+                kind: "no-evidence",
+                detail: "The execution is recorded but produced no stored evidence. That is a real state (a run that " +
+                    "observed nothing) and is not the same as an unrecorded execution, which throws.",
+            });
+        }
+        // getByExecution orders by timestamp, so this cannot detect a bad sort —
+        // it detects a recorded stream whose own timestamps were never
+        // monotonic, which means "recorded order" and "the order things
+        // happened" are not the same list and a reader replaying by index is
+        // reading a sequence that never occurred.
+        for (let i = 1; i < evidence.length; i += 1) {
+            if (evidence[i - 1].timestamp === evidence[i].timestamp)
+                continue;
+            if (evidence[i - 1].timestamp < evidence[i].timestamp)
+                continue;
+            warnings.push({
+                kind: "unordered-timestamps",
+                detail: "At least one pair of evidence items is out of timestamp order after sorting, which means the " +
+                    "recorded timestamps are not a total order. Replay order is by timestamp, so the sequence " +
+                    "returned here is not necessarily the sequence that occurred.",
+            });
+            break;
+        }
+        return { execution, evidence, currentEnvironment: current, warnings };
+    }
+    /**
+     * Record that correlation resolved this evidence to a graph node.
+     *
+     * **Written because the correlation was never durable, and that made two
+     * of the evidence package's four selection tiers inert.** Found by
+     * mutation, not by reading: `assembleEvidencePackage`'s tier 2 queries
+     * `graphNodeId`, and a mutation that dropped the execution scope from that
+     * query changed nothing at all — because in the real pipeline no stored row
+     * has a `graphNodeId` to match. `graphNodeId` was set in memory at
+     * composition time, on a copy, and thrown away with the array that held it.
+     * Every downstream question of the form "what else named this node" was
+     * therefore answerable only for evidence some caller happened to still be
+     * holding.
+     *
+     * **Refuses to re-attribute to a different node.** One observation
+     * genuinely can name two graph entities (RT-052's backend exception names
+     * the endpoint in its text and the function in its stack), and the answer
+     * to that is `EvidenceAttribution` passed alongside the evidence — an
+     * output of correlation, not a property of the observation. Letting this
+     * method overwrite would silently discard the first correlation and leave
+     * the store asserting the second as if it were the only one. Idempotent
+     * for the same node, so re-running a correlation pass is safe.
+     *
+     * Throws for an unknown `evidenceId`: a caller attributing evidence this
+     * store does not hold has a bug, and writing nothing would hide it.
+     */
+    attribute(evidenceId, graphNodeId) {
+        const existing = this.getById(evidenceId);
+        if (existing === null) {
+            throw new Error(`attribute: no evidence with id ${JSON.stringify(evidenceId)} in this store`);
+        }
+        if (existing.graphNodeId !== null && existing.graphNodeId !== graphNodeId) {
+            throw new Error(`attribute: evidence ${evidenceId} is already attributed to ${existing.graphNodeId}; refusing to ` +
+                `overwrite with ${graphNodeId}. One observation naming two nodes is expressed as an ` +
+                "EvidenceAttribution alongside the evidence, not by rewriting the stored one.");
+        }
+        if (existing.graphNodeId === graphNodeId)
+            return;
+        this.#db.prepare(`UPDATE evidence SET graph_node_id = ? WHERE evidence_id = ?`).run(graphNodeId, evidenceId);
+    }
+    /**
+     * The general query surface (§19).
+     *
+     * Before this, the store answered two questions — by id and by execution —
+     * and §19 asks for six axes: trace, service, graph node, source location,
+     * time, and execution. **Five of the six did not exist**, which is
+     * invisible from "evidence persistence works" and was found by auditing
+     * the checklist rather than by anything failing.
+     *
+     * **`executionId` is required and may be explicitly `null`, and that is
+     * the load-bearing design choice here.** Every other field is optional.
+     * Evidence not leaking between executions is a guarantee this repo
+     * enforces elsewhere (`composeFinding` excludes foreign executions with a
+     * named reason), and a query is the obvious way to lose it: ask for a
+     * trace id and quietly receive a prior run's evidence too. Making the
+     * field optional-with-a-default would mean the safe behaviour depends on
+     * remembering to pass something, which is how the default gets forgotten
+     * exactly once. Passing `null` is a deliberate statement that a
+     * cross-execution answer is wanted — the same discipline
+     * `resolveSymbolNode` applies to `repo`, where there is no honest default
+     * either.
+     *
+     * Criteria combine with AND. An empty criteria object plus a null
+     * execution returns everything, which is a real request (a store dump)
+     * and is spelled out rather than reachable by accident.
+     */
+    query(criteria) {
+        const clauses = [];
+        const params = [];
+        if (criteria.executionId !== null) {
+            clauses.push("execution_id = ?");
+            params.push(criteria.executionId);
+        }
+        // Each of these is an exact match, never a LIKE. A prefix or substring
+        // match on a trace id or a service name would return evidence about a
+        // *different* thing that happens to share a prefix -- RT-031's
+        // identity-proxy class, and the last place it belongs is the query
+        // layer that everything above reads through.
+        for (const [column, value] of [
+            ["trace_id", criteria.traceId],
+            ["request_id", criteria.requestId],
+            ["correlation_id", criteria.correlationId],
+            ["service", criteria.service],
+            ["source", criteria.source],
+            ["event_type", criteria.eventType],
+            ["graph_node_id", criteria.graphNodeId],
+        ]) {
+            if (value === undefined)
+                continue;
+            clauses.push(`${column} = ?`);
+            params.push(value);
+        }
+        if (criteria.sourceFile !== undefined) {
+            clauses.push("json_extract(source_location, '$.file') = ?");
+            params.push(criteria.sourceFile);
+        }
+        if (criteria.sourceLine !== undefined) {
+            clauses.push("json_extract(source_location, '$.line') = ?");
+            params.push(criteria.sourceLine);
+        }
+        // ISO-8601 UTC strings sort lexicographically in the same order they
+        // sort chronologically, which is why `timestamp` is comparable as TEXT.
+        // Inclusive at both ends: a caller asking for a window around a known
+        // event should get that event.
+        if (criteria.from !== undefined) {
+            clauses.push("timestamp >= ?");
+            params.push(criteria.from);
+        }
+        if (criteria.to !== undefined) {
+            clauses.push("timestamp <= ?");
+            params.push(criteria.to);
+        }
+        const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+        const limit = criteria.limit !== undefined ? "LIMIT ?" : "";
+        if (criteria.limit !== undefined)
+            params.push(criteria.limit);
+        const rows = this.#db
+            .prepare(`SELECT * FROM evidence ${where} ORDER BY timestamp ASC ${limit}`)
+            .all(...params);
+        return rows.map(rowToEvidence);
+    }
+    /**
+     * Deletes every row whose own `timestamp` is older than `retentionMs`
+     * (constructor option) relative to `now` (defaults to the real current
+     * time; overridable so a test can purge without a real sleep). Never
+     * called automatically -- no timer, no call from `write()` -- a caller
+     * decides when retention actually runs. Throws rather than silently
+     * no-op-ing if `retentionMs` was never configured: a caller explicitly
+     * asking to purge with no policy in place is a configuration mistake
+     * worth surfacing, not masking.
+     */
+    purgeExpired(now = new Date()) {
+        if (this.#retentionMs === null) {
+            throw new Error("purgeExpired() called but no retentionMs was configured on this EvidenceStore.");
+        }
+        const cutoff = new Date(now.getTime() - this.#retentionMs).toISOString();
+        const result = this.#db.prepare(`DELETE FROM evidence WHERE timestamp < ?`).run(cutoff);
+        return Number(result.changes);
+    }
+    close() {
+        this.#db.close();
+    }
+}
+/**
+ * Throws when a value is outside the vocabulary this build knows.
+ *
+ * The message names the value **and** the vocabulary, because the two useful
+ * conclusions are opposite: an unknown value is either a typo (fix the caller)
+ * or a newer contract (this build is the old one), and only seeing both lists
+ * distinguishes them.
+ */
+function assertInVocabulary(field, value, vocabulary) {
+    if (vocabulary.includes(value))
+        return;
+    throw new Error(`EvidenceStore: ${field} ${JSON.stringify(value)} is not one of ${JSON.stringify(vocabulary)}. ` +
+        "Either the caller is wrong, or this store is being written by a build with a newer contract " +
+        "than the one reading it — the two need opposite fixes, so neither is assumed.");
+}
+/**
+ * Rehydrate a row, refusing one this build cannot interpret.
+ *
+ * **The previous version blind-cast every enum field** — `row.event_type as
+ * Evidence["eventType"]` — which is a `as` that cannot fail and a value that
+ * can. A store file written by a build with an extra `RuntimeEventType`, a
+ * restored backup, or a hand-edited row produced a fully-typed `Evidence`
+ * whose `eventType` no `switch` in this program handles, and nothing anywhere
+ * said so. §3's "unknown event handled explicitly" row was open for exactly
+ * this, and the handling could not be added upstream because there was no
+ * point at which the unknown was ever recognised as unknown.
+ *
+ * **It throws rather than skipping.** Skipping would return fewer rows while
+ * every caller treated the result as complete — the "unsupported silently
+ * becomes no failure" shape, applied to a query result, which is the worst
+ * place for it: `composeFinding` would compose over a subset and report
+ * confidently. `integrityCheck()` exists so a caller facing this can find out
+ * how bad it is without the throw being a dead end.
+ */
+function rowToEvidence(raw) {
+    const row = { ...raw };
+    assertInVocabulary("eventType", row.event_type, RUNTIME_EVENT_TYPES);
+    assertInVocabulary("source", row.source, EVIDENCE_SOURCES);
+    assertInVocabulary("redactionStatus", row.redaction_status, REDACTION_STATUSES);
+    return {
+        evidenceId: row.evidence_id,
+        executionId: row.execution_id,
+        timestamp: row.timestamp,
+        source: row.source,
+        service: row.service,
+        process: row.process,
+        eventType: row.event_type,
+        payload: JSON.parse(row.payload),
+        traceId: row.trace_id,
+        requestId: row.request_id,
+        correlationId: row.correlation_id,
+        graphNodeId: row.graph_node_id,
+        sourceLocation: row.source_location
+            ? JSON.parse(row.source_location)
+            : null,
+        stackTrace: row.stack_trace ? JSON.parse(row.stack_trace) : null,
+        confidence: row.confidence,
+        redactionStatus: row.redaction_status,
+        collectorVersion: row.collector_version,
+    };
+}
+/**
+ * `serviceName -> command` out of an `ExecutionConfiguration`-shaped object.
+ *
+ * Written defensively against `unknown` rather than typed against
+ * `ExecutionConfiguration`, because the configuration reaching this store has
+ * already been through `redact()` and is no longer that type: a redacted
+ * command is the string `[REDACTED]`, which is still a string, but a redacted
+ * *services* object could in principle be a marker too. Reading it
+ * structurally means a surprising shape yields an empty map rather than a
+ * throw inside a persistence call.
+ */
+function serviceCommandsOf(configuration) {
+    const services = configuration?.services;
+    if (services === null || typeof services !== "object")
+        return {};
+    const commands = {};
+    for (const [name, service] of Object.entries(services)) {
+        const command = service?.command;
+        if (typeof command === "string")
+            commands[name] = command;
+    }
+    return commands;
+}
+//# sourceMappingURL=evidence-store.js.map

package/dist/evidence-store.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { RedactionResult, RedactionPolicy } from "./redaction.ts";
+export { redact, collidingKeys, redactCommand } from "./redaction.ts";
+export type { EvidenceStoreOptions, EvidenceInput, EvidenceQuery } from "./evidence-store.ts";
+export { EvidenceStore } from "./evidence-store.ts";
+export { captureEnvironment, environmentDifferences, type EnvironmentFingerprint, type RecordedExecution, type Replay, type ReplayWarning, } from "./replay.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEtE,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC9F,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,MAAM,EACX,KAAK,aAAa,GACnB,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { redact, collidingKeys, redactCommand } from "./redaction.js";
+export { EvidenceStore } from "./evidence-store.js";
+export { captureEnvironment, environmentDifferences, } from "./replay.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGtE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EACL,kBAAkB,EAClB,sBAAsB,GAKvB,MAAM,aAAa,CAAC"}