foottrace 1.1.0 → 1.2.0

package/dist/lib/cause/recordValidation.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectLoaded = exports.mapOf = exports.bundleOf = exports.dataCopy = exports.addressKey = exports.spend = exports.addressOf = exports.list = exports.name = exports.names = exports.own = exports.RecordRefusal = exports.marksOf = void 0;
+const validation_js_1 = require("./validation.js");
+Object.defineProperty(exports, "marksOf", { enumerable: true, get: function () { return validation_js_1.attention; } });
+const admission_js_1 = require("./admission.js");
+/** Loader refusals stay distinct from graph-port refusals so a failed host load keeps its original classification. */
+class RecordRefusal extends admission_js_1.EvidenceRefusal {
+    code;
+    constructor(code = 'invalid-data') {
+        super(code, 'cause: record unavailable');
+        this.code = code;
+    }
+}
+exports.RecordRefusal = RecordRefusal;
+const refuseRecord = (code) => new RecordRefusal(code);
+const recordDescriptors = { translateTrapErrors: true, requireOwnValue: true };
+function own(value, key) {
+    return (0, admission_js_1.ownData)(value, key, refuseRecord, recordDescriptors);
+}
+exports.own = own;
+function names(value, maximum = 128, path = false) {
+    return list(value, maximum).map((item) => name(item, path));
+}
+exports.names = names;
+function name(value, path = false) {
+    return (0, admission_js_1.boundedName)(value, 1024, refuseRecord, path);
+}
+exports.name = name;
+function list(value, maximum) {
+    return (0, admission_js_1.boundedList)(value, maximum, (item) => item, {
+        refuse: refuseRecord,
+        overflow: 'node-limit',
+        freeze: false,
+        descriptors: recordDescriptors,
+    });
+}
+exports.list = list;
+function addressOf(value) {
+    const logRunId = name(own(value, 'logRunId')), drillPath = names(own(value, 'drillPath'), 16);
+    if (logRunId.length + drillPath.reduce((n, s) => n + s.length, 0) > 1536)
+        throw new RecordRefusal();
+    return Object.freeze({ logRunId, drillPath: Object.freeze(drillPath) });
+}
+exports.addressOf = addressOf;
+function spend(budget, count) {
+    (0, admission_js_1.spendFields)(budget, count, refuseRecord);
+}
+exports.spend = spend;
+const addressKey = (a) => JSON.stringify([a.logRunId, ...a.drillPath]);
+exports.addressKey = addressKey;
+/** Iterative bounded copy: data descriptors only, no getters/toJSON/prototypes or opaque class instances. */
+function dataCopy(value, budget) {
+    const leaf = (v) => v === null || typeof v !== 'object';
+    const check = (v) => {
+        spend(budget, 1);
+        if (typeof v === 'function' || typeof v === 'symbol' || (typeof v === 'string' && v.length > 65536))
+            throw new RecordRefusal();
+    };
+    check(value);
+    if (leaf(value))
+        return value;
+    const make = (v) => {
+        let p;
+        try {
+            p = Object.getPrototypeOf(v);
+        }
+        catch {
+            throw new RecordRefusal();
+        }
+        if (!Array.isArray(v) && p !== Object.prototype && p !== null)
+            throw new RecordRefusal();
+        if (Array.isArray(v)) {
+            const length = own(v, 'length');
+            if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0)
+                throw new RecordRefusal();
+            spend(budget, length);
+            const array = [];
+            array.length = length;
+            return array;
+        }
+        return Object.create(null);
+    };
+    const root = make(value), seen = new Set([value]), work = [{ from: value, to: root }];
+    while (work.length) {
+        const { from, to } = work.pop();
+        let keys;
+        try {
+            keys = Object.keys(from);
+        }
+        catch {
+            throw new RecordRefusal();
+        }
+        if (keys.length > budget.left)
+            throw new RecordRefusal('node-limit');
+        for (const key of keys) {
+            if (key.length > 1024)
+                throw new RecordRefusal('node-limit');
+            const v = own(from, key);
+            check(v);
+            let copy = v;
+            if (!leaf(v)) {
+                if (seen.has(v))
+                    throw new RecordRefusal();
+                seen.add(v);
+                copy = make(v);
+                work.push({ from: v, to: copy });
+            }
+            Object.defineProperty(to, key, { value: copy, enumerable: true, writable: true, configurable: true });
+        }
+    }
+    return root;
+}
+exports.dataCopy = dataCopy;
+function bundleOf(value, idx, budget) {
+    const runtimeStageId = name(own(value, 'runtimeStageId')), stageId = name(own(value, 'stageId'));
+    const trace = list(own(value, 'trace'), 128).map((_, i) => {
+        const t = own(own(value, 'trace'), String(i)), path = name(own(t, 'path'), true), verb = own(t, 'verb');
+        if (!['set', 'merge', 'append', 'delete'].includes(verb))
+            throw new RecordRefusal();
+        const readKeys = own(t, 'readKeys');
+        return { path, verb: verb, ...(readKeys === undefined ? {} : { readKeys: names(readKeys, 128, true) }) };
+    });
+    spend(budget, trace.length + trace.reduce((n, t) => n + (t.readKeys?.length ?? 0), 0) + 1);
+    const overwrite = dataCopy(own(value, 'overwrite'), budget), updates = dataCopy(own(value, 'updates'), budget);
+    if (!overwrite ||
+        typeof overwrite !== 'object' ||
+        Array.isArray(overwrite) ||
+        !updates ||
+        typeof updates !== 'object' ||
+        Array.isArray(updates))
+        throw new RecordRefusal();
+    const redactedPaths = names(own(value, 'redactedPaths') ?? [], 128, true);
+    const untracked = own(value, 'untrackedSources'), phase = own(value, 'phase');
+    spend(budget, redactedPaths.length + (untracked === undefined ? 0 : list(untracked, 128).length));
+    return {
+        idx,
+        stage: stageId,
+        stageId,
+        runtimeStageId,
+        trace,
+        overwrite,
+        updates,
+        redactedPaths,
+        ...(untracked === undefined
+            ? {}
+            : {
+                untrackedSources: names(untracked).map((s) => {
+                    if (!['args', 'env', 'silent'].includes(s))
+                        throw new RecordRefusal();
+                    return s;
+                }),
+            }),
+        ...(phase === undefined
+            ? {}
+            : {
+                phase: (() => {
+                    if (phase !== 'exit' && phase !== 'repeat')
+                        throw new RecordRefusal();
+                    return phase;
+                })(),
+            }),
+    };
+}
+exports.bundleOf = bundleOf;
+function mapOf(value, limit, read, budget) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new RecordRefusal();
+    let keys;
+    try {
+        keys = Object.keys(value);
+    }
+    catch {
+        throw new RecordRefusal();
+    }
+    if (keys.length > limit)
+        throw new RecordRefusal('node-limit');
+    if (budget)
+        spend(budget, keys.length);
+    return new Map(keys.map((k) => [name(k), read(own(value, k))]));
+}
+exports.mapOf = mapOf;
+/** Observe native promises by intrinsic without assimilating a data object's then accessor. */
+function projectLoaded(work, project) {
+    return new Promise((resolve, reject) => {
+        const accept = (value) => {
+            try {
+                resolve(project(value));
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        let returned;
+        try {
+            returned = work();
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        try {
+            if (!(0, validation_js_1.observePromise)(returned, (value) => accept(value), reject))
+                accept(returned);
+        }
+        catch (error) {
+            reject(error instanceof validation_js_1.AdmissionError ? new RecordRefusal(error.code) : error);
+        }
+    });
+}
+exports.projectLoaded = projectLoaded;

package/dist/lib/cause/session.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = void 0;
+const validation_js_1 = require("./validation.js");
+const defaults = { maxNodes: 100, maxDepth: 20, maxEdges: 1000, maxCalls: 1000, timeoutMs: 1000 };
+const ceilings = { maxNodes: 10000, maxDepth: 1000, maxEdges: 100000, maxCalls: 100000, timeoutMs: 30000 };
+/** One deadline, memo table and work budget per public query, never per graph or store. */
+class Session {
+    limits;
+    context;
+    nodes = new Set();
+    controller = new AbortController();
+    cache = new Map();
+    calls = 0;
+    edges = 0;
+    timedOut = false;
+    deadline;
+    timer;
+    external;
+    onAbort = () => this.controller.abort();
+    methods = {};
+    constructor(graph, options = {}) {
+        try {
+            (0, validation_js_1.plain)(options);
+            const limits = { ...defaults };
+            for (const key of Object.keys(defaults)) {
+                const value = (0, validation_js_1.own)(options, key);
+                if (value !== undefined) {
+                    if (typeof value !== 'number' ||
+                        !Number.isSafeInteger(value) ||
+                        value < (key === 'maxDepth' ? 0 : 1) ||
+                        value > ceilings[key])
+                        throw new TypeError();
+                    limits[key] = value;
+                }
+            }
+            this.limits = Object.freeze(limits);
+            const rank = (0, validation_js_1.own)(options, 'rankRoots');
+            if (rank !== undefined && typeof rank !== 'function')
+                throw new TypeError();
+            const impactRank = (0, validation_js_1.own)(options, 'rankImpact');
+            if (impactRank !== undefined && typeof impactRank !== 'function')
+                throw new TypeError();
+            const signal = (0, validation_js_1.own)(options, 'signal');
+            if (signal !== undefined && !(signal instanceof AbortSignal))
+                throw new TypeError();
+            this.external = signal;
+            for (const key of ['parents', 'children', 'attention', 'gaps', 'roots']) {
+                let cursor = graph, method;
+                for (let depth = 0; cursor && cursor !== Object.prototype && depth < 8; depth++, cursor = Object.getPrototypeOf(cursor)) {
+                    const field = Object.getOwnPropertyDescriptor(cursor, key);
+                    if (field) {
+                        if (!('value' in field))
+                            throw new TypeError();
+                        method = field.value;
+                        break;
+                    }
+                }
+                if (typeof method !== 'function' && key !== 'roots')
+                    throw new TypeError();
+                if (typeof method === 'function')
+                    this.methods[key] = method.bind(graph);
+            }
+        }
+        catch {
+            throw new TypeError('CAUSE_CONFIGURATION_INVALID');
+        }
+        this.context = Object.freeze({ signal: this.controller.signal });
+        this.deadline = performance.now() + this.limits.timeoutMs;
+        this.external?.addEventListener('abort', this.onAbort, { once: true });
+        if (this.external?.aborted)
+            this.onAbort();
+        this.timer = setTimeout(() => {
+            this.timedOut = true;
+            this.controller.abort();
+        }, this.limits.timeoutMs);
+    }
+    dispose() {
+        clearTimeout(this.timer);
+        this.external?.removeEventListener('abort', this.onAbort);
+    }
+    stopGap(id) {
+        // Resolved Promise chains can starve timers. Check the monotonic deadline too.
+        if (!this.controller.signal.aborted && performance.now() >= this.deadline) {
+            this.timedOut = true;
+            this.controller.abort();
+        }
+        return this.controller.signal.aborted ? (0, validation_js_1.gap)(this.timedOut ? 'timeout' : 'cancelled', id) : undefined;
+    }
+    admit(id) {
+        (0, validation_js_1.name)(id);
+        if (this.nodes.has(id))
+            return undefined;
+        if (this.nodes.size >= this.limits.maxNodes)
+            return (0, validation_js_1.gap)('node-limit', id);
+        this.nodes.add(id);
+        return undefined;
+    }
+    hasRoots() {
+        return !!this.methods.roots;
+    }
+    read(method, id, project) {
+        const key = JSON.stringify([method, id]);
+        const cached = this.cache.get(key);
+        if (cached)
+            return cached;
+        const pending = this.invoke(id, () => {
+            const fn = this.methods[method];
+            if (!fn)
+                throw new validation_js_1.AdmissionError('not-collected');
+            return id === undefined ? fn(this.context) : fn(id, this.context);
+        }, project);
+        this.cache.set(key, pending);
+        return pending;
+    }
+    invoke(id, work, project) {
+        const stopped = this.stopGap(id);
+        if (stopped)
+            return Promise.resolve({ gap: stopped });
+        if (++this.calls > this.limits.maxCalls)
+            return Promise.resolve({ gap: (0, validation_js_1.gap)('call-limit', id) });
+        return new Promise((resolve) => {
+            let finished = false;
+            const finish = (result) => {
+                if (finished)
+                    return;
+                finished = true;
+                this.controller.signal.removeEventListener('abort', abort);
+                resolve(result);
+            };
+            const abort = () => finish({ gap: this.stopGap(id) ?? (0, validation_js_1.gap)('cancelled', id) });
+            const accept = (raw) => {
+                if (finished)
+                    return;
+                const stopped = this.stopGap(id);
+                if (stopped) {
+                    finish({ gap: stopped });
+                    return;
+                }
+                try {
+                    const value = project(raw), expired = this.stopGap(id);
+                    finish(expired ? { gap: expired } : { value });
+                }
+                catch (error) {
+                    finish({ gap: (0, validation_js_1.gap)(error instanceof validation_js_1.AdmissionError ? error.code : 'invalid-data', id) });
+                }
+            };
+            this.controller.signal.addEventListener('abort', abort, { once: true });
+            if (this.controller.signal.aborted) {
+                abort();
+                return;
+            }
+            try {
+                const returned = work();
+                // Observe native Promises by intrinsic, never assimilate a payload's `then` getter.
+                if (!(0, validation_js_1.observePromise)(returned, accept, () => finish({ gap: (0, validation_js_1.gap)('unavailable', id) })))
+                    accept(returned);
+            }
+            catch (error) {
+                finish({ gap: (0, validation_js_1.gap)(error instanceof validation_js_1.AdmissionError ? error.code : 'unavailable', id) });
+            }
+        });
+    }
+}
+exports.Session = Session;

package/dist/lib/cause/storedRecordAdapter.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStoredRecordGraph = void 0;
+const storedRecord_js_1 = require("../time-travel/storedRecord.js");
+const recordAdapter_js_1 = require("./recordAdapter.js");
+const recordValidation_js_1 = require("./recordValidation.js");
+/** Load one address only. The host owns auth/storage; cancellation is forwarded and waiting is independently bounded. */
+function createStoredRecordGraph(host, options = {}) {
+    const limits = (0, recordAdapter_js_1.recordOptions)(options);
+    return (0, recordAdapter_js_1.createLazyRecordGraph)((address, context) => (0, recordValidation_js_1.projectLoaded)(() => host.loadLog(address, context), (loaded) => {
+        const max = limits.maxCommits, budget = { left: limits.maxFields };
+        const raw = (0, recordValidation_js_1.list)((0, recordValidation_js_1.own)(loaded, 'entries'), max * 4 + 16), entries = [];
+        for (let i = 0; i < raw.length; i++) {
+            if (context.signal.aborted)
+                throw new recordValidation_js_1.RecordRefusal('cancelled');
+            const entry = (0, recordValidation_js_1.own)(raw, String(i)), a = (0, recordValidation_js_1.addressOf)((0, recordValidation_js_1.own)(entry, 'address'));
+            if ((0, recordValidation_js_1.addressKey)(a) !== (0, recordValidation_js_1.addressKey)(address))
+                throw new recordValidation_js_1.RecordRefusal();
+            const kind = (0, recordValidation_js_1.own)(entry, 'kind'), at = (0, recordValidation_js_1.own)(entry, 'at');
+            if (typeof at !== 'number' || !Number.isFinite(at))
+                throw new recordValidation_js_1.RecordRefusal();
+            if (kind === 'commit') {
+                const b = (0, recordValidation_js_1.own)(entry, 'bundle'), idx = (0, recordValidation_js_1.own)(b, 'idx');
+                if (!Number.isSafeInteger(idx) || idx < 0 || idx >= max)
+                    throw new recordValidation_js_1.RecordRefusal('node-limit');
+                entries.push({ kind, address: a, at, bundle: (0, recordValidation_js_1.bundleOf)(b, idx, budget) });
+            }
+            else if (kind === 'opened')
+                entries.push({ kind, address: a, at, initialState: (0, recordValidation_js_1.dataCopy)((0, recordValidation_js_1.own)(entry, 'initialState'), budget) });
+            else if (kind === 'closed')
+                entries.push({ kind, address: a, at, outcome: (0, recordValidation_js_1.own)(entry, 'outcome'), commits: (0, recordValidation_js_1.own)(entry, 'commits') });
+            else if (kind === 'note') {
+                /* opaque note bodies never enter dependency projection */
+            }
+            else
+                throw new recordValidation_js_1.RecordRefusal();
+        }
+        const record = (0, storedRecord_js_1.readStoredRecord)(entries, {
+            entries: max * 4 + 16,
+            missingCommits: max,
+            drillDepth: 16,
+            addressLength: 1536,
+        }), log = record.log(address);
+        if (!log)
+            throw new recordValidation_js_1.RecordRefusal();
+        if (log.gaps.length)
+            throw new recordValidation_js_1.RecordRefusal('not-collected');
+        return {
+            scope: {
+                address,
+                commitLog: log.commitLog,
+                reads: (0, recordValidation_js_1.own)(loaded, 'reads'),
+                controlDeps: (0, recordValidation_js_1.own)(loaded, 'controlDeps'),
+                attention: (0, recordValidation_js_1.own)(loaded, 'attention'),
+                complete: log.complete,
+            },
+            gaps: record.unread.length || log.gaps.length ? ['not-collected'] : [],
+        };
+    }), limits);
+}
+exports.createStoredRecordGraph = createStoredRecordGraph;

package/dist/lib/cause/strategies.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mostAffected = exports.largestDrop = void 0;
+/** Host-computed quality drops or impact counts: scores rank recorded candidates, never create evidence. */
+function maximum(scores) {
+    return (candidates) => {
+        let best = -Infinity;
+        const tied = [];
+        for (const candidate of candidates) {
+            const score = scores.get(candidate.nodeId);
+            if (score === undefined || !Number.isFinite(score))
+                throw new TypeError('CAUSE_STRATEGY_EVIDENCE_MISSING');
+            if (score > best) {
+                best = score;
+                tied.length = 0;
+            }
+            if (score === best)
+                tied.push(candidate.nodeId);
+        }
+        return Object.freeze(tied);
+    };
+}
+const largestDrop = (scores) => maximum(scores);
+exports.largestDrop = largestDrop;
+const mostAffected = (counts) => maximum(counts);
+exports.mostAffected = mostAffected;

package/dist/lib/cause/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/cause/validation.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueGaps = exports.gap = exports.nodeIds = exports.adjacency = exports.gaps = exports.attention = exports.refs = exports.list = exports.name = exports.plain = exports.own = exports.observePromise = exports.AdmissionError = void 0;
+const admission_js_1 = require("./admission.js");
+/** Graph-port refusals carry their code through Session; loader refusals are handled at the record boundary. */
+class AdmissionError extends admission_js_1.EvidenceRefusal {
+    code;
+    constructor(code = 'invalid-data') {
+        super(code, 'Invalid cause evidence');
+        this.code = code;
+    }
+}
+exports.AdmissionError = AdmissionError;
+/**
+ * Only ordinary native promise wrappers belong to the async host contract.
+ * An own constructor could run an accessor/species during intrinsic then().
+ * Exotic wrappers remain the trusted host's responsibility, including rejection handling.
+ */
+function observePromise(raw, accept, reject) {
+    if (!raw || typeof raw !== 'object' || Object.getPrototypeOf(raw) !== Promise.prototype)
+        return false;
+    if (Object.getOwnPropertyDescriptor(raw, 'constructor'))
+        throw new AdmissionError();
+    try {
+        Promise.prototype.then.call(raw, accept, reject);
+    }
+    catch {
+        throw new AdmissionError();
+    }
+    return true;
+}
+exports.observePromise = observePromise;
+const refuseGraph = (code) => new AdmissionError(code);
+const graphDescriptors = { translateTrapErrors: false, requireOwnValue: false };
+function own(value, key) {
+    return (0, admission_js_1.ownData)(value, key, refuseGraph, graphDescriptors);
+}
+exports.own = own;
+function plain(value) {
+    if (!value || typeof value !== 'object' || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+        throw new AdmissionError();
+}
+exports.plain = plain;
+function name(value, maximum = 2048) {
+    return (0, admission_js_1.boundedName)(value, maximum, refuseGraph);
+}
+exports.name = name;
+function list(value, maximum, read, overflow = 'invalid-data') {
+    return (0, admission_js_1.boundedList)(value, maximum, read, {
+        refuse: refuseGraph,
+        overflow,
+        freeze: true,
+        descriptors: graphDescriptors,
+    });
+}
+exports.list = list;
+const reasons = new Set([
+    'ERROR_RECORDED',
+    'UNKNOWN_EFFECT_RECORDED',
+    'RETRY_STOP_RECORDED',
+    'TIMEOUT_RECORDED',
+    'RETRY_RECORDED',
+    'QUALITY_DROP_RECORDED',
+    'EVIDENCE_NOT_COLLECTED',
+    'OUTLIER_RECORDED',
+    'BUSINESS_RULE_MATCHED',
+]);
+const codes = new Set([
+    'not-collected',
+    'untracked-input',
+    'redacted',
+    'conservative',
+    'scope-boundary',
+    'invalid-data',
+    'unavailable',
+    'timeout',
+    'cancelled',
+    'cycle',
+    'node-limit',
+    'depth-limit',
+    'edge-limit',
+    'call-limit',
+    'truncated',
+    'strategy-failed',
+]);
+const refs = (value) => list(value, 16, (item) => name(item, 512));
+exports.refs = refs;
+function attention(value) {
+    return list(value, 32, (item) => {
+        plain(item);
+        const kind = own(item, 'kind'), reason = own(item, 'reason');
+        if (typeof kind !== 'string' ||
+            !/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(kind) ||
+            typeof reason !== 'string' ||
+            !reasons.has(reason))
+            throw new AdmissionError();
+        const evidence = (0, exports.refs)(own(item, 'evidence'));
+        if (kind !== 'not-collected' && evidence.length === 0)
+            throw new AdmissionError();
+        return Object.freeze({ kind, reason: reason, evidence });
+    });
+}
+exports.attention = attention;
+function gaps(value) {
+    return list(value, 32, (item) => {
+        plain(item);
+        const code = own(item, 'code'), nodeId = own(item, 'nodeId');
+        if (typeof code !== 'string' || !codes.has(code))
+            throw new AdmissionError();
+        return Object.freeze({
+            code: code,
+            ...(nodeId === undefined ? {} : { nodeId: name(nodeId) }),
+            evidence: (0, exports.refs)(own(item, 'evidence')),
+        });
+    });
+}
+exports.gaps = gaps;
+function adjacency(value, maximum) {
+    plain(value);
+    const complete = own(value, 'complete');
+    if (typeof complete !== 'boolean')
+        throw new AdmissionError();
+    const edges = list(own(value, 'edges'), maximum, (item) => {
+        plain(item);
+        const nodeId = name(own(item, 'nodeId')), kind = own(item, 'kind'), attribution = own(item, 'attribution');
+        if ((kind !== 'data' && kind !== 'control') ||
+            (attribution !== 'per-write' && attribution !== 'stage' && attribution !== 'recorded-control') ||
+            (kind === 'control' && attribution !== 'recorded-control') ||
+            (kind === 'data' && attribution === 'recorded-control'))
+            throw new AdmissionError();
+        return Object.freeze({ nodeId, kind, attribution, evidence: (0, exports.refs)(own(item, 'evidence')) });
+    }, 'edge-limit');
+    return Object.freeze({ edges, complete });
+}
+exports.adjacency = adjacency;
+const nodeIds = (value, max) => list(value, max, (item) => name(item), 'node-limit');
+exports.nodeIds = nodeIds;
+const gap = (code, nodeId) => Object.freeze({ code, ...(nodeId === undefined ? {} : { nodeId }), evidence: Object.freeze([]) });
+exports.gap = gap;
+function uniqueGaps(items) {
+    const seen = new Set();
+    return Object.freeze(items.filter((item) => {
+        const key = JSON.stringify(item);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    }));
+}
+exports.uniqueGaps = uniqueGaps;