@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/internal/EvidenceInventoryMerge.js

@@ -0,0 +1,343 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceInventoryMerge = void 0;
+const _jsonStringifyString_1 = __importStar(require("typia/lib/internal/_jsonStringifyString"));
+const _jsonStringifyTail_1 = __importStar(require("typia/lib/internal/_jsonStringifyTail"));
+const _jsonStringifyNumber_1 = __importStar(require("typia/lib/internal/_jsonStringifyNumber"));
+const typia_1 = __importDefault(require("typia"));
+const EvidenceInventorySources_1 = require("./EvidenceInventorySources");
+/**
+ * Combines compatible adapter inventories into one analysis snapshot.
+ *
+ * Conflicts mark the result incomplete instead of choosing whichever adapter
+ * happened to run first, preserving the failure boundary for graph evaluation.
+ */
+var EvidenceInventoryMerge;
+(function (EvidenceInventoryMerge) {
+    /**
+     * Merges compatible source, unit, host, and declaration records into one
+     * inventory.
+     *
+     * Conflicting semantic identities remain diagnostics and mark the merged
+     * result incomplete, so input order cannot select an arbitrary graph
+     * population.
+     */
+    function combine(inputs) {
+        EvidenceInventorySources_1.EvidenceInventorySources.reconcile(inputs);
+        const output = {
+            schemaVersion: 1,
+            sources: [],
+            annotationRanges: [],
+            units: [],
+            addresses: [],
+            hosts: [],
+            declarations: [],
+            reviews: [],
+            diagnostics: [],
+            dependencies: [],
+            complete: inputs.every((input) => input.complete),
+        };
+        const sources = new Map();
+        const units = new Map();
+        const hosts = new Map();
+        for (const input of inputs) {
+            output.diagnostics.push(...input.diagnostics);
+            output.annotationRanges.push(...input.annotationRanges);
+            for (const source of input.sources) {
+                const previous = sources.get(source.id);
+                if (previous === undefined)
+                    sources.set(source.id, source);
+                else if (previous.digest !== source.digest ||
+                    previous.content !== source.content ||
+                    previous.fingerprintPath !== source.fingerprintPath ||
+                    fingerprintRootKey(previous) !== fingerprintRootKey(source))
+                    conflict(output, "source", source.id);
+                else
+                    previous.addresses.push(...source.addresses);
+            }
+            for (const unit of input.units) {
+                const previous = units.get(unit.id);
+                if (previous === undefined)
+                    units.set(unit.id, unit);
+                else if (unitKey(previous) !== unitKey(unit))
+                    conflict(output, "unit", unit.id);
+                else {
+                    if (previous.contentDigest !== undefined &&
+                        unit.contentDigest !== undefined &&
+                        previous.contentDigest !== unit.contentDigest)
+                        conflict(output, "unit content digest", unit.id);
+                    else if (previous.contentDigest === undefined &&
+                        unit.contentDigest !== undefined)
+                        previous.contentDigest = unit.contentDigest;
+                    for (const site of unit.sites) {
+                        const existing = previous.sites.find((candidate) => candidate.id === site.id);
+                        if (existing === undefined)
+                            previous.sites.push(site);
+                        else if (siteKey(existing) !== siteKey(site) ||
+                            contentKey(existing) !== contentKey(site))
+                            conflict(output, "declaration site", site.id);
+                    }
+                    previous.withdrawals.push(...unit.withdrawals);
+                }
+            }
+            for (const host of input.hosts) {
+                const previous = hosts.get(host.id);
+                if (previous === undefined)
+                    hosts.set(host.id, host);
+                else if (hostKey(previous) !== hostKey(host))
+                    conflict(output, "host", host.id);
+                else {
+                    previous.unitIds.push(...host.unitIds);
+                    previous.origins = [
+                        ...(previous.origins ?? [previous.file]),
+                        ...(host.origins ?? [host.file]),
+                    ];
+                }
+            }
+            output.addresses.push(...input.addresses);
+            output.declarations.push(...input.declarations);
+            output.reviews.push(...input.reviews);
+            output.dependencies.push(...input.dependencies);
+        }
+        output.sources = Array.from(sources.values());
+        output.units = Array.from(units.values());
+        output.hosts = Array.from(hosts.values());
+        // Duplicate physical tags can appear through aliases; conflicting bodies
+        // cannot be chosen by scan order.
+        const declarations = new Map();
+        for (const declaration of output.declarations) {
+            const previous = declarations.get(declaration.id);
+            const body = (() => {
+                const _so0 = input => `{"hostId":${_jsonStringifyString_1._jsonStringifyString(input.hostId)},"target":${_jsonStringifyString_1._jsonStringifyString(input.target)},"location":${_so1(input.location)},"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},"kind":${"\"" + input.kind + "\""},"reason":${_jsonStringifyString_1._jsonStringifyString(input.reason)}}`;
+                const _so1 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},${undefined === input.range ? "" : `"range":${undefined !== input.range ? _so2(input.range) : undefined}`}`)}}`;
+                const _so2 = input => `{"start":${_so3(input.start)},"end":${_so3(input.end)}}`;
+                const _so3 = input => `{"offset":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.offset))},"line":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.line))},"column":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.column))}}`;
+                const _io1 = input => "string" === typeof input.file && (undefined === input.range || "object" === typeof input.range && null !== input.range && _io2(input.range));
+                const _io2 = input => "object" === typeof input.start && null !== input.start && _io3(input.start) && ("object" === typeof input.end && null !== input.end && _io3(input.end));
+                const _io3 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+                return input => _so0(input);
+            })()(declaration);
+            if (previous !== undefined && previous !== body)
+                conflict(output, "acknowledgement", declaration.id);
+            declarations.set(declaration.id, body);
+        }
+        const reviews = new Map();
+        for (const review of output.reviews) {
+            const previous = reviews.get(review.id);
+            const body = (() => {
+                const _so0 = input => `{"hostId":${_jsonStringifyString_1._jsonStringifyString(input.hostId)},"target":${_jsonStringifyString_1._jsonStringifyString(input.target)},"location":${_so1(input.location)},"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},"reviews":${"\"" + input.reviews + "\""},${undefined === input.fingerprint ? "" : `"fingerprint":${undefined !== input.fingerprint ? _jsonStringifyString_1._jsonStringifyString(input.fingerprint) : undefined},`}"description":${_jsonStringifyString_1._jsonStringifyString(input.description)}}`;
+                const _so1 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},${undefined === input.range ? "" : `"range":${undefined !== input.range ? _so2(input.range) : undefined}`}`)}}`;
+                const _so2 = input => `{"start":${_so3(input.start)},"end":${_so3(input.end)}}`;
+                const _so3 = input => `{"offset":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.offset))},"line":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.line))},"column":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.column))}}`;
+                const _io1 = input => "string" === typeof input.file && (undefined === input.range || "object" === typeof input.range && null !== input.range && _io2(input.range));
+                const _io2 = input => "object" === typeof input.start && null !== input.start && _io3(input.start) && ("object" === typeof input.end && null !== input.end && _io3(input.end));
+                const _io3 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+                return input => _so0(input);
+            })()(review);
+            if (previous !== undefined && previous !== body)
+                conflict(output, "review", review.id);
+            reviews.set(review.id, body);
+        }
+        if (!output.complete &&
+            !output.diagnostics.some((diagnostic) => diagnostic.code === "inventory-incomplete"))
+            output.diagnostics.push({
+                code: "inventory-incomplete",
+                severity: "error",
+                message: "At least one adapter or source snapshot is incomplete.",
+                repair: "Resolve the underlying analysis failure before evaluating evidence coverage.",
+            });
+        return output;
+    }
+    EvidenceInventoryMerge.combine = combine;
+    /**
+     * Deduplicates values by semantic key and orders the result
+     * deterministically.
+     *
+     * Later records replace earlier records for the same key before bytewise key
+     * ordering removes source traversal order from serialized output.
+     */
+    function unique(values, key) {
+        const records = new Map();
+        for (const value of values)
+            records.set(key(value), value);
+        return Array.from(records)
+            .sort(([x], [y]) => compare(x, y))
+            .map(([, value]) => value);
+    }
+    EvidenceInventoryMerge.unique = unique;
+    /**
+     * Compares opaque identity strings without locale-dependent ordering.
+     *
+     * Inventory serialization uses this bytewise relation so the same graph sorts
+     * identically across machines with different locale settings.
+     */
+    function compare(x, y) {
+        return x < y ? -1 : x > y ? 1 : 0;
+    }
+    EvidenceInventoryMerge.compare = compare;
+    /**
+     * Deduplicates source addresses while preserving direct selection over
+     * dependency loading.
+     *
+     * When equivalent addresses collide, a selected address clears the dependency
+     * marker because it represents part of the configured public population.
+     */
+    function sourceAddresses(values) {
+        const records = new Map();
+        for (const value of values) {
+            const key = JSON.stringify([
+                value.absolute,
+                value.relative,
+                value.display,
+            ]);
+            const previous = records.get(key);
+            if (previous === undefined)
+                records.set(key, value);
+            else if (previous.selected === false && value.selected !== false)
+                delete previous.selected;
+        }
+        return Array.from(records)
+            .sort(([x], [y]) => compare(x, y))
+            .map(([, value]) => value);
+    }
+    EvidenceInventoryMerge.sourceAddresses = sourceAddresses;
+    /**
+     * Serializes structural site identity without its independently merged
+     * content spans.
+     *
+     * Unit merging compares this key before unioning content ranges, so
+     * compatible declarations share a physical host without requiring identical
+     * extraction order.
+     */
+    function siteKey(site) {
+        return JSON.stringify([
+            site.id,
+            site.file,
+            (() => {
+                const _so0 = input => `{"start":${_so1(input.start)},"end":${_so1(input.end)}}`;
+                const _so1 = input => `{"offset":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.offset))},"line":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.line))},"column":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.column))}}`;
+                const _io1 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+                return input => _so0(input);
+            })()(site.range),
+        ]);
+    }
+    EvidenceInventoryMerge.siteKey = siteKey;
+    /**
+     * Serializes deduplicated content ranges for source-order-independent
+     * conflict detection.
+     *
+     * The range values are normalized through {@link unique} before a shared site
+     * can be accepted as equivalent across inventories.
+     */
+    function contentKey(site) {
+        return JSON.stringify(unique(site.content.map((range) => (() => {
+            const _so0 = input => `{"start":${_so1(input.start)},"end":${_so1(input.end)}}`;
+            const _so1 = input => `{"offset":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.offset))},"line":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.line))},"column":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.column))}}`;
+            const _io1 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+            return input => _so0(input);
+        })()(range)), (value) => value));
+    }
+    EvidenceInventoryMerge.contentKey = contentKey;
+    /**
+     * Captures the unit fields that must agree for one semantic identity.
+     *
+     * A mismatch means inventories disagree about the declaration itself and
+     * cannot safely merge their physical sites or public addresses.
+     */
+    function unitKey(unit) {
+        return JSON.stringify([
+            unit.type,
+            unit.symbol,
+            unit.parentId,
+            unit.identity,
+            unit.name,
+        ]);
+    }
+    /**
+     * Captures host attachment semantics that cannot be safely unioned on
+     * conflict.
+     *
+     * Hosts with the same ID must retain one source range, site, and attachment
+     * meaning before their unit IDs and origins can be combined.
+     */
+    function hostKey(host) {
+        return JSON.stringify([
+            host.file,
+            (() => {
+                const _so0 = input => `{"start":${_so1(input.start)},"end":${_so1(input.end)}}`;
+                const _so1 = input => `{"offset":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.offset))},"line":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.line))},"column":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.column))}}`;
+                const _io1 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+                return input => _so0(input);
+            })()(host.range),
+            host.siteId,
+            host.attachment,
+            host.problem,
+        ]);
+    }
+    /**
+     * Records a non-recoverable identity disagreement without dropping either
+     * record.
+     *
+     * Marking the output incomplete prevents graph evaluation from treating a
+     * reduced or arbitrarily selected merged population as successful.
+     */
+    function conflict(output, kind, id) {
+        output.complete = false;
+        output.diagnostics.push({
+            code: "inventory-conflict",
+            severity: "error",
+            message: `Conflicting ${kind} records share identity ${id}.`,
+            repair: "Correct the adapter identity or use a consistent source snapshot before combining inventories.",
+        });
+    }
+})(EvidenceInventoryMerge || (exports.EvidenceInventoryMerge = EvidenceInventoryMerge = {}));
+/**
+ * Serializes optional portable-root metadata for source conflict detection.
+ *
+ * A shared process-local source identity cannot select different logical roots
+ * according to inventory order because that would change public fingerprints.
+ */
+function fingerprintRootKey(source) {
+    return source.fingerprintRoot === undefined
+        ? ""
+        : JSON.stringify([
+            source.fingerprintRoot.physicalPath,
+            source.fingerprintRoot.fingerprintPath,
+        ]);
+}

package/lib/internal/EvidenceInventorySources.d.ts

@@ -0,0 +1,19 @@
+import type { IEvidenceInventory } from "../structures/IEvidenceInventory";
+/**
+ * Reconciles physical source paths across inventories without rewriting public
+ * addresses.
+ *
+ * Merge consumers need one physical key for source content and annotations, but
+ * adapters retain logical origins because they remain valid user-facing
+ * targets.
+ */
+export declare namespace EvidenceInventorySources {
+    /**
+     * Normalizes location-bearing records in place and reports impossible source
+     * conflicts.
+     *
+     * Merge callers obtain one canonical physical path per source ID while public
+     * logical addresses remain untouched for target resolution and reporting.
+     */
+    function reconcile(inputs: IEvidenceInventory[]): void;
+}

package/lib/internal/EvidenceInventorySources.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceInventorySources = void 0;
+/**
+ * Reconciles physical source paths across inventories without rewriting public
+ * addresses.
+ *
+ * Merge consumers need one physical key for source content and annotations, but
+ * adapters retain logical origins because they remain valid user-facing
+ * targets.
+ */
+var EvidenceInventorySources;
+(function (EvidenceInventorySources) {
+    /**
+     * Normalizes location-bearing records in place and reports impossible source
+     * conflicts.
+     *
+     * Merge callers obtain one canonical physical path per source ID while public
+     * logical addresses remain untouched for target resolution and reporting.
+     */
+    function reconcile(inputs) {
+        const canonical = new Map();
+        const owners = new Map();
+        for (const input of inputs)
+            for (const source of input.sources) {
+                const previous = canonical.get(source.id);
+                if (previous === undefined || source.physicalPath < previous)
+                    canonical.set(source.id, source.physicalPath);
+                const owner = owners.get(source.physicalPath);
+                if (owner !== undefined && owner !== source.id) {
+                    input.complete = false;
+                    input.diagnostics.push({
+                        code: "inventory-source",
+                        severity: "error",
+                        message: "One physical source path has conflicting filesystem identities.",
+                        repair: "Load populations from a consistent filesystem snapshot before combining them.",
+                        location: { file: source.physicalPath },
+                    });
+                }
+                owners.set(source.physicalPath, source.id);
+            }
+        const paths = new Map();
+        for (const input of inputs)
+            for (const source of input.sources)
+                paths.set(source.physicalPath, canonical.get(source.id) ?? source.physicalPath);
+        /**
+         * Rewrites one physical location through the source-ID canonicalization
+         * map.
+         *
+         * This helper leaves logical addresses unchanged because the map represents
+         * filesystem identity, not the source spelling a user can target.
+         */
+        function locate(location) {
+            location.file = paths.get(location.file) ?? location.file;
+        }
+        for (const input of inputs) {
+            for (const source of input.sources)
+                source.physicalPath = canonical.get(source.id) ?? source.physicalPath;
+            for (const annotation of input.annotationRanges)
+                locate(annotation);
+            for (const unit of input.units) {
+                for (const site of unit.sites)
+                    locate(site);
+                for (const withdrawal of unit.withdrawals)
+                    locate(withdrawal.location);
+            }
+            for (const host of input.hosts) {
+                host.origins = host.origins ?? [host.file];
+                locate(host);
+            }
+            for (const declaration of input.declarations)
+                locate(declaration.location);
+            for (const review of input.reviews)
+                locate(review.location);
+            for (const diagnostic of input.diagnostics)
+                if (diagnostic.location !== undefined)
+                    locate(diagnostic.location);
+        }
+    }
+    EvidenceInventorySources.reconcile = reconcile;
+})(EvidenceInventorySources || (exports.EvidenceInventorySources = EvidenceInventorySources = {}));

package/lib/internal/EvidenceParserSlots.d.ts

@@ -0,0 +1,87 @@
+/**
+ * FIFO admission queue for the lifetime of parser extraction callbacks.
+ *
+ * Acquire reserves ownership until the caller releases it in cleanup. Closing
+ * rejects new requests while allowing already queued requests to drain, so the
+ * parser runtime can wait for all accepted native-resource owners to finish.
+ */
+export declare class EvidenceParserSlots {
+    /**
+     * Maximum simultaneously reserved slots.
+     *
+     * Requests beyond this bound wait until an existing owner releases its
+     * slot.
+     */
+    private readonly limit;
+    /**
+     * Number of reserved slots, including slots transferred to queued requests.
+     *
+     * A transfer keeps this count unchanged until the receiving request releases
+     * it.
+     */
+    active: number;
+    /**
+     * Whether admission has closed to new requests.
+     *
+     * Accepted requests may still be active or queued while close waits for
+     * drainage.
+     */
+    closed: boolean;
+    /**
+     * Resolvers waiting for ownership in arrival order.
+     *
+     * Releasing a slot wakes the oldest request before reducing the active count.
+     */
+    private readonly queue;
+    /**
+     * Close callers waiting for the final reserved slot to be released.
+     *
+     * Retaining all resolvers makes repeated concurrent close calls await one
+     * drain.
+     */
+    private readonly drains;
+    /**
+     * Creates an empty queue with the parser runtime's validated concurrency
+     * limit.
+     *
+     * Validation belongs to the public parser options boundary; this queue only
+     * manages ownership and assumes a positive integer limit.
+     */
+    constructor(
+    /**
+     * Maximum simultaneously reserved slots.
+     *
+     * Requests beyond this bound wait until an existing owner releases its
+     * slot.
+     */
+    limit: number);
+    /**
+     * Counts accepted requests that do not yet own a slot.
+     *
+     * Runtime state inspection uses this separately from the active reservation
+     * count.
+     */
+    get waiting(): number;
+    /**
+     * Reserves an available slot or waits for FIFO ownership transfer.
+     *
+     * Requests arriving after close reject immediately. A request accepted before
+     * close still resumes and must eventually call release exactly once.
+     */
+    acquire(): Promise<void>;
+    /**
+     * Relinquishes one acquired slot and advances accepted work.
+     *
+     * The caller must have acquired ownership. Once no queued successor or active
+     * owner remains, every pending close operation is released.
+     */
+    release(): void;
+    /**
+     * Stops new admission and waits for every accepted request to release
+     * ownership.
+     *
+     * Call this outside an owned slot; awaiting close while holding a slot would
+     * wait for the caller's own release.
+     */
+    close(): Promise<void>;
+}

package/lib/internal/EvidenceParserSlots.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceParserSlots = void 0;
+/**
+ * FIFO admission queue for the lifetime of parser extraction callbacks.
+ *
+ * Acquire reserves ownership until the caller releases it in cleanup. Closing
+ * rejects new requests while allowing already queued requests to drain, so the
+ * parser runtime can wait for all accepted native-resource owners to finish.
+ */
+class EvidenceParserSlots {
+    limit;
+    /**
+     * Number of reserved slots, including slots transferred to queued requests.
+     *
+     * A transfer keeps this count unchanged until the receiving request releases
+     * it.
+     */
+    active = 0;
+    /**
+     * Whether admission has closed to new requests.
+     *
+     * Accepted requests may still be active or queued while close waits for
+     * drainage.
+     */
+    closed = false;
+    /**
+     * Resolvers waiting for ownership in arrival order.
+     *
+     * Releasing a slot wakes the oldest request before reducing the active count.
+     */
+    queue = [];
+    /**
+     * Close callers waiting for the final reserved slot to be released.
+     *
+     * Retaining all resolvers makes repeated concurrent close calls await one
+     * drain.
+     */
+    drains = [];
+    /**
+     * Creates an empty queue with the parser runtime's validated concurrency
+     * limit.
+     *
+     * Validation belongs to the public parser options boundary; this queue only
+     * manages ownership and assumes a positive integer limit.
+     */
+    constructor(
+    /**
+     * Maximum simultaneously reserved slots.
+     *
+     * Requests beyond this bound wait until an existing owner releases its
+     * slot.
+     */
+    limit) {
+        this.limit = limit;
+    }
+    /**
+     * Counts accepted requests that do not yet own a slot.
+     *
+     * Runtime state inspection uses this separately from the active reservation
+     * count.
+     */
+    get waiting() {
+        return this.queue.length;
+    }
+    /**
+     * Reserves an available slot or waits for FIFO ownership transfer.
+     *
+     * Requests arriving after close reject immediately. A request accepted before
+     * close still resumes and must eventually call release exactly once.
+     */
+    async acquire() {
+        if (this.closed)
+            throw new Error("The parser runtime is closed.");
+        if (this.active < this.limit) {
+            ++this.active;
+            return;
+        }
+        const pending = new Promise((resolve) => {
+            this.queue.push(resolve);
+        });
+        await pending;
+    }
+    /**
+     * Relinquishes one acquired slot and advances accepted work.
+     *
+     * The caller must have acquired ownership. Once no queued successor or active
+     * owner remains, every pending close operation is released.
+     */
+    release() {
+        const next = this.queue.shift();
+        // Transfer ownership without lowering active: close must not observe a
+        // temporary zero while an already accepted request is about to resume.
+        if (next !== undefined)
+            next();
+        else {
+            --this.active;
+            if (this.active === 0)
+                for (const drain of this.drains.splice(0))
+                    drain();
+        }
+    }
+    /**
+     * Stops new admission and waits for every accepted request to release
+     * ownership.
+     *
+     * Call this outside an owned slot; awaiting close while holding a slot would
+     * wait for the caller's own release.
+     */
+    async close() {
+        this.closed = true;
+        if (this.active === 0)
+            return;
+        const pending = new Promise((resolve) => {
+            this.drains.push(resolve);
+        });
+        await pending;
+    }
+}
+exports.EvidenceParserSlots = EvidenceParserSlots;