reverseport 0.0.0-stage → 1.2.0

package/dist/domain/artifactInventoryEvidence.js

@@ -0,0 +1,166 @@
+import { artifactInventoryResultSchema, } from "./artifactGraph.js";
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
+import { canonicalJson } from "./comparisonSemantics.js";
+import { artifactContradictionId, artifactEdgeId, artifactGraphDigest, artifactIdForContent, artifactManifestId, occurrenceIdForLocation, } from "./artifactIdentity.js";
+import { parseEvidence } from "./evidence.js";
+import { artifactInspectionResultSchema } from "./artifactInspection.js";
+/** Parse, merge, and verify inventory Evidence pages. */
+export const parseArtifactInventoryEvidence = (input) => assembleInventorySet((Array.isArray(input) ? input : [input]).map((value) => {
+    const evidence = parseEvidence(value);
+    const inventoryEvidence = evidence.operation === "inventory_artifact"
+        ? evidence
+        : evidence.operation === "inspect_artifact"
+            ? artifactInspectionResultSchema.parse(evidence.normalized_result)
+                .substeps[0]?.evidence
+            : undefined;
+    if (inventoryEvidence === undefined)
+        throw new TypeError("Artifact comparison requires inspect_artifact Evidence");
+    const inventory = artifactInventoryResultSchema.parse(inventoryEvidence.normalized_result);
+    if (inventoryEvidence.subject === null ||
+        inventoryEvidence.subject.digest.sha256 !==
+            inventory.manifest.root_sha256 ||
+        inventoryEvidence.subject.format !== inventory.manifest.root_format)
+        throw new TypeError("Artifact inventory Evidence subject does not match its root digest");
+    validateInventoryPage(inventory);
+    return { evidence, inventory };
+}));
+const validateInventoryPage = (inventory) => {
+    assertUnique(inventory.nodes.map(({ artifact_id: id }) => id), "node ID");
+    assertUnique(inventory.occurrences.map(({ occurrence_id: id }) => id), "occurrence ID");
+    assertUnique(inventory.occurrences.map(({ logical_path: path }) => path), "logical path");
+    assertUnique(inventory.edges.map(({ edge_id: id }) => id), "edge ID");
+    for (const node of inventory.nodes)
+        if (node.artifact_id !== artifactIdForContent(node.sha256))
+            throw new TypeError("Artifact node ID is not content-addressed");
+};
+const assembleInventorySet = (pages) => {
+    const first = pages[0];
+    if (first === undefined)
+        throw new TypeError("Artifact inventory requires Evidence pages");
+    const manifestJson = canonicalJson(first.inventory.manifest, "Artifact inventory");
+    const nodes = new Map();
+    const occurrences = new Map();
+    const paths = new Map();
+    const edges = new Map();
+    for (const page of pages) {
+        if (canonicalJson(page.inventory.manifest, "Artifact inventory") !==
+            manifestJson)
+            throw new TypeError("Artifact inventory pages do not share one manifest");
+        if (canonicalJson(page.inventory.integrity_contradictions, "Artifact inventory") !==
+            canonicalJson(first.inventory.integrity_contradictions, "Artifact inventory"))
+            throw new TypeError("Artifact inventory pages do not share integrity contradictions");
+        for (const node of page.inventory.nodes)
+            mergeExact(nodes, node.artifact_id, node, "node");
+        for (const occurrence of page.inventory.occurrences) {
+            mergeExact(occurrences, occurrence.occurrence_id, occurrence, "occurrence");
+            mergeExact(paths, occurrence.logical_path, occurrence, "logical path");
+        }
+        for (const edge of page.inventory.edges)
+            mergeExact(edges, edge.edge_id, edge, "edge");
+    }
+    const inventory = orderedInventory(first.inventory, pages, {
+        nodes,
+        occurrences,
+        edges,
+    });
+    if (inventory.complete)
+        validateCompleteInventory(inventory);
+    return { evidence: pages.map(({ evidence }) => evidence), inventory };
+};
+const orderedInventory = (first, pages, values) => {
+    const nodes = [...values.nodes.values()].sort((left, right) => compareUnicodeCodePoints(left.artifact_id, right.artifact_id));
+    const occurrences = [...values.occurrences.values()].sort((left, right) => compareUnicodeCodePoints(left.logical_path, right.logical_path));
+    const edges = [...values.edges.values()].sort((left, right) => compareUnicodeCodePoints(left.edge_id, right.edge_id));
+    return {
+        manifest: first.manifest,
+        nodes,
+        occurrences,
+        edges,
+        integrityContradictions: first.integrity_contradictions,
+        limitations: [
+            ...new Set(pages.flatMap(({ inventory }) => inventory.limitations)),
+        ].sort(compareUnicodeCodePoints),
+        complete: nodes.length === first.manifest.node_count &&
+            occurrences.length === first.manifest.occurrence_count &&
+            edges.length === first.manifest.edge_count,
+    };
+};
+const validateCompleteInventory = (inventory) => {
+    const nodeIds = new Set(inventory.nodes.map(({ artifact_id: id }) => id));
+    const occurrenceIds = new Set(inventory.occurrences.map(({ occurrence_id: id }) => id));
+    const rootNode = inventory.nodes.find(({ artifact_id: id }) => id === inventory.manifest.root_artifact_id);
+    if (rootNode?.sha256 !== inventory.manifest.root_sha256)
+        throw new TypeError("Artifact root node does not match its manifest digest");
+    const rootOccurrence = inventory.occurrences.find(({ logical_path }) => logical_path === ".");
+    if (rootOccurrence?.artifact_id !== inventory.manifest.root_artifact_id ||
+        rootOccurrence.artifact_format !== inventory.manifest.root_format)
+        throw new TypeError("Artifact root occurrence does not match its manifest representation");
+    for (const occurrence of inventory.occurrences)
+        validateOccurrence(occurrence, inventory, nodeIds, occurrenceIds);
+    const occurrencesById = new Map(inventory.occurrences.map((occurrence) => [
+        occurrence.occurrence_id,
+        occurrence,
+    ]));
+    for (const edge of inventory.edges)
+        validateEdge(edge, nodeIds, occurrencesById);
+    for (const contradiction of inventory.integrityContradictions) {
+        if (!nodeIds.has(contradiction.parent_artifact_id) ||
+            !occurrenceIds.has(contradiction.occurrence_id))
+            throw new TypeError("Integrity contradiction references a missing graph member");
+        const expectedId = artifactContradictionId({
+            rootArtifactId: inventory.manifest.root_artifact_id,
+            logicalPath: contradiction.logical_path,
+            declaredSha256: contradiction.declared_sha256,
+            observedSha256: contradiction.observed_sha256,
+        });
+        if (contradiction.contradiction_id !== expectedId)
+            throw new TypeError("Integrity contradiction ID does not match its identity");
+    }
+    const graphSha256 = artifactGraphDigest({
+        nodes: inventory.nodes,
+        occurrences: inventory.occurrences,
+        edges: inventory.edges,
+        contradictions: inventory.integrityContradictions,
+    });
+    if (graphSha256 !== inventory.manifest.graph_sha256)
+        throw new TypeError("Artifact graph commitment does not match its members");
+    const manifestId = artifactManifestId(inventory.manifest.root_artifact_id, graphSha256);
+    if (manifestId !== inventory.manifest.manifest_id)
+        throw new TypeError("Artifact manifest ID does not match its commitment");
+};
+const validateOccurrence = (occurrence, inventory, nodeIds, occurrenceIds) => {
+    if (occurrence.artifact_id !== null && !nodeIds.has(occurrence.artifact_id))
+        throw new TypeError("Artifact occurrence references a missing node");
+    if (occurrence.parent_occurrence_id !== null &&
+        !occurrenceIds.has(occurrence.parent_occurrence_id))
+        throw new TypeError("Artifact occurrence references a missing parent");
+    const expectedId = occurrenceIdForLocation({
+        rootArtifactId: inventory.manifest.root_artifact_id,
+        logicalPath: occurrence.logical_path,
+        entryKind: occurrence.entry_kind,
+    });
+    if (occurrence.occurrence_id !== expectedId)
+        throw new TypeError("Artifact occurrence ID does not match its identity");
+};
+const validateEdge = (edge, nodeIds, occurrences) => {
+    const occurrence = occurrences.get(edge.occurrence_id);
+    if (!nodeIds.has(edge.parent_artifact_id) ||
+        occurrence?.artifact_id === null ||
+        occurrence === undefined ||
+        !nodeIds.has(occurrence.artifact_id))
+        throw new TypeError("Artifact edge references a missing graph member");
+    if (edge.edge_id !== artifactEdgeId(edge, occurrence))
+        throw new TypeError("Artifact edge ID does not match its identity");
+};
+const mergeExact = (output, key, value, label) => {
+    const previous = output.get(key);
+    if (previous !== undefined &&
+        canonicalJson(previous, "Artifact inventory") !==
+            canonicalJson(value, "Artifact inventory"))
+        throw new TypeError(`Artifact inventory has conflicting ${label} pages`);
+    output.set(key, value);
+};
+const assertUnique = (values, label) => {
+    if (new Set(values).size !== values.length)
+        throw new TypeError(`Artifact inventory contains a duplicate ${label}`);
+};

package/dist/domain/artifactInventorySnapshot.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/artifactOperationError.js

@@ -0,0 +1,20 @@
+import { AnalysisError, } from "./analysisErrorBase.js";
+/** Artifact inventory or extraction failed a typed safety boundary. */
+export class ArtifactOperationError extends AnalysisError {
+    operation;
+    reason;
+    artifactDetails;
+    detail;
+    _tag = "ArtifactOperationError";
+    constructor(operation, reason, artifactDetails, 
+    /** The specific constraint that failed, such as the colliding path. */
+    detail, options) {
+        super(artifactDetails === undefined
+            ? `Artifact ${operation} failed: ${reason}`
+            : `Artifact ${operation} failed: ${reason} at ${artifactDetails.logicalPath} (declared_sha256=${artifactDetails.declaredSha256 ?? "unavailable"}, calculated_sha256=${artifactDetails.calculatedSha256 ?? "unavailable"}, unpacked=${String(artifactDetails.unpacked)})`, options);
+        this.operation = operation;
+        this.reason = reason;
+        this.artifactDetails = artifactDetails;
+        this.detail = detail;
+    }
+}

package/dist/domain/artifactPartialObservation.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/artifactPathSyntax.js

@@ -0,0 +1,75 @@
+/**
+ * Pure string predicates for artifact path syntax. The local artifact
+ * resolver, the Electron native specifier check, and (by reference) the
+ * live-DOM and source-map URL handling share these character-level rules.
+ *
+ * Policy divergence (deliberate, not yet unified):
+ * - Local artifact paths resolve against an inventoried container root and
+ *   report rejected | external | not-found. Confinement is lexical
+ *   (normalizeJoinedLogicalPath must stay inside the root).
+ * - Live DOM destinations resolve against the document base URL and report
+ *   approved | outside_policy | unsupported against allowedOrigins
+ *   (see CdpCaptureDocuments.domDestination).
+ * - Source-map fetches require exact-origin http(s) without credentials
+ *   (see WebSourceMapFetcher.approvedUrl).
+ * Unifying those outcome vocabularies is a separate, observable change.
+ */
+/** Whether a reference carries a URI scheme (`https:`, `file:`, …). */
+export const hasScheme = (value) => /^[A-Za-z][A-Za-z0-9+.-]*:/u.test(value);
+/** Whether a reference is scheme-qualified or protocol-relative. */
+export const looksExternal = (value) => hasScheme(value) || value.startsWith("//");
+/** Drop any query string and fragment from a declared reference. */
+export const stripQueryAndFragment = (value) => value.split("#", 1)[0]?.split("?", 1)[0] ?? "";
+/** Path syntax admitted for a canonical artifact path. */
+export const admitsCanonicalPathSyntax = (value) => !value.includes("\0") &&
+    !value.includes("\\") &&
+    !/%(?:2e|2f|5c)/iu.test(value);
+/** C0 controls and space, which the URL parser strips around its input. */
+const isUrlTrimmed = (code) => code <= 0x20;
+/**
+ * The URL text a browser parses from an HTML URL attribute: HTML strips
+ * surrounding ASCII whitespace, and the URL parser strips surrounding C0
+ * controls and spaces and removes every tab and newline.
+ */
+export const htmlUrlText = (value) => {
+    let start = 0;
+    let end = value.length;
+    while (start < end && isUrlTrimmed(value.charCodeAt(start)))
+        start += 1;
+    while (end > start && isUrlTrimmed(value.charCodeAt(end - 1)))
+        end -= 1;
+    return value.slice(start, end).replace(/[\t\n\r]/gu, "");
+};
+const UTF8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+const UTF8_ENCODER = new TextEncoder();
+/**
+ * Percent-decode a URL path as the URL standard does: valid `%XX` sequences
+ * become bytes and any other `%` stays literal. Returns null when the bytes
+ * are not UTF-8 or include NUL, because no canonical artifact path can match
+ * them. Callers refuse encoded dot and separator bytes before decoding.
+ */
+export const percentDecodeUrlPath = (value) => {
+    if (!/%[0-9a-f]{2}/iu.test(value))
+        return value;
+    const bytes = [];
+    for (let index = 0; index < value.length;) {
+        const escape = value.slice(index, index + 3);
+        if (/^%[0-9a-f]{2}$/iu.test(escape)) {
+            bytes.push(Number.parseInt(escape.slice(1), 16));
+            index += 3;
+            continue;
+        }
+        const character = String.fromCodePoint(value.codePointAt(index) ?? 0);
+        bytes.push(...UTF8_ENCODER.encode(character));
+        index += character.length;
+    }
+    try {
+        const decoded = UTF8.decode(new Uint8Array(bytes));
+        return decoded.includes("\0") ? null : decoded;
+    }
+    catch (cause) {
+        // Invalid UTF-8 cannot name an inventoried path.
+        void cause;
+        return null;
+    }
+};

package/dist/domain/binaryTarget.js

@@ -0,0 +1,233 @@
+import { err, ok } from "./result.js";
+import { mzWindowsHeaderOffset, parseDosMzHeader } from "./dosMz.js";
+import { decodePeMachine } from "./peMachine.js";
+/**
+ * Parse supported executable headers without I/O. The caller supplies the host
+ * architecture used for deterministic FAT Mach-O slice selection.
+ */
+export const parseExecutableHeader = (bytes, hostArchitecture, fileSize = bytes.length) => {
+    if (bytes.length >= 4 &&
+        bytes.subarray(0, 4).equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])))
+        return parseElf(bytes, fileSize);
+    if (bytes.length >= 2 && bytes[0] === 0x4d && bytes[1] === 0x5a)
+        return parseMz(bytes, fileSize);
+    if (bytes.length < 8)
+        return err("truncated or unsupported binary header");
+    const magic = bytes.readUInt32BE(0);
+    if ([0xfeedface, 0xfeedfacf, 0xcefaedfe, 0xcffaedfe].includes(magic))
+        return parseThinMachO(bytes, magic, fileSize);
+    if ([0xcafebabe, 0xbebafeca, 0xcafebabf, 0xbfbafeca].includes(magic))
+        return parseFatMachO(bytes, magic, hostArchitecture, fileSize);
+    return err("unsupported binary format");
+};
+const parseThinMachO = (bytes, magic, fileSize) => {
+    const is64 = magic === 0xfeedfacf || magic === 0xcffaedfe;
+    const headerSize = is64 ? 32 : 28;
+    if (bytes.length < headerSize)
+        return err(`truncated Mach-O header: a ${is64 ? 64 : 32}-bit header needs ${headerSize} bytes; the file has ${fileSize}`);
+    const little = magic === 0xcefaedfe || magic === 0xcffaedfe;
+    const read = (offset) => little ? bytes.readUInt32LE(offset) : bytes.readUInt32BE(offset);
+    const architecture = machArchitecture(read(4));
+    if (architecture === undefined)
+        return err("unsupported Mach-O architecture");
+    const commandBytes = read(20);
+    if (headerSize + commandBytes > fileSize)
+        return err(`truncated Mach-O load commands: the header declares ${commandBytes} bytes after its ${headerSize}-byte header; the file has ${fileSize}`);
+    return ok({
+        format: "mach-o",
+        architecture,
+        availableArchitectures: [architecture],
+    });
+};
+const parseFatMachO = (bytes, magic, host, fileSize) => {
+    const little = magic === 0xbebafeca || magic === 0xbfbafeca;
+    const is64 = magic === 0xcafebabf || magic === 0xbfbafeca;
+    if (bytes.length < 8)
+        return err("truncated FAT header");
+    const read = (offset) => little ? bytes.readUInt32LE(offset) : bytes.readUInt32BE(offset);
+    const count = read(4);
+    const entrySize = is64 ? 32 : 20;
+    if (count === 0 || count > 128 || bytes.length < 8 + count * entrySize)
+        return err("truncated or invalid FAT architecture table");
+    const architectures = [];
+    const slices = new Map();
+    for (let index = 0; index < count; index += 1) {
+        const entry = 8 + index * entrySize;
+        const architecture = machArchitecture(read(entry));
+        if (architecture === undefined || architectures.includes(architecture))
+            continue;
+        architectures.push(architecture);
+        const offset = is64
+            ? little
+                ? bytes.readBigUInt64LE(entry + 8)
+                : bytes.readBigUInt64BE(entry + 8)
+            : BigInt(read(entry + 8));
+        const size = is64
+            ? little
+                ? bytes.readBigUInt64LE(entry + 16)
+                : bytes.readBigUInt64BE(entry + 16)
+            : BigInt(read(entry + 12));
+        slices.set(architecture, { offset, size });
+    }
+    const preferred = host === "arm64"
+        ? "arm64"
+        : host === "x64"
+            ? "x86_64"
+            : host === "ia32"
+                ? "x86"
+                : host === "arm"
+                    ? "arm"
+                    : undefined;
+    const slice = preferred === undefined ? undefined : slices.get(preferred);
+    if (preferred === undefined || slice === undefined)
+        return err(`FAT binary has no host-compatible ${host} architecture`);
+    const tableEnd = BigInt(8 + count * entrySize);
+    if (slice.offset < tableEnd)
+        return err(`FAT slice for ${preferred} overlaps the architecture table`);
+    const minimumHeaderSize = preferred === "arm64" || preferred === "x86_64" ? 32n : 28n;
+    if (slice.size < minimumHeaderSize)
+        return err(`FAT slice for ${preferred} is shorter than its Mach-O header`);
+    const sliceEnd = slice.offset + slice.size;
+    if (sliceEnd > BigInt(fileSize))
+        return err(`truncated FAT slice: the ${preferred} slice ends at byte ${sliceEnd}; the file has ${fileSize}`);
+    return ok({
+        format: "mach-o-universal",
+        architecture: preferred,
+        availableArchitectures: architectures,
+    });
+};
+const parseElf = (bytes, fileSize) => {
+    if (bytes.length < 6)
+        return err("truncated ELF header");
+    if (bytes[4] !== 1 && bytes[4] !== 2)
+        return err("unsupported ELF class");
+    const little = bytes[5] === 1;
+    if (!little && bytes[5] !== 2)
+        return err("unsupported ELF endianness");
+    const headerSize = bytes[4] === 1 ? 52 : 64;
+    if (bytes.length < headerSize)
+        return err(`truncated ELF header: an ELF${bytes[4] === 1 ? 32 : 64} header needs ${headerSize} bytes; the file has ${fileSize}`);
+    const machine = little ? bytes.readUInt16LE(18) : bytes.readUInt16BE(18);
+    const architecture = elfArchitecture(machine);
+    if (architecture === undefined)
+        return err("unsupported ELF architecture");
+    if (architecture === "mips")
+        return ok({
+            format: "elf",
+            architecture,
+            availableArchitectures: [architecture],
+            mips: {
+                elfClass: bytes[4] === 1 ? 32 : 64,
+                byteOrder: little ? "little" : "big",
+                type: little ? bytes.readUInt16LE(16) : bytes.readUInt16BE(16),
+                flags: little
+                    ? bytes.readUInt32LE(bytes[4] === 1 ? 36 : 48)
+                    : bytes.readUInt32BE(bytes[4] === 1 ? 36 : 48),
+            },
+        });
+    return ok({
+        format: "elf",
+        architecture,
+        availableArchitectures: [architecture],
+    });
+};
+const parseMz = (bytes, fileSize) => {
+    const offset = mzWindowsHeaderOffset(bytes);
+    if (offset !== null) {
+        if (offset < 64 || offset > bytes.length - 24)
+            return err("invalid or truncated Windows executable header in MZ image");
+        const signature = bytes.toString("ascii", offset, offset + 2);
+        if (["NE", "LE", "LX"].includes(signature))
+            return err(`unsupported ${signature} executable in MZ image`);
+        return parsePeRecord(bytes.subarray(offset));
+    }
+    const parsed = parseDosMzHeader(bytes, fileSize);
+    return parsed.ok
+        ? ok({
+            format: "dos-mz",
+            architecture: "x86",
+            availableArchitectures: ["x86"],
+        })
+        : parsed;
+};
+/** Parse a bounded PE signature, COFF record, and optional header without I/O. */
+export const parsePeRecord = (record) => {
+    if (record.length < 24 ||
+        record.toString("binary", 0, 4) !== "PE\u0000\u0000")
+        return err("invalid or truncated PE header");
+    const machine = decodePeMachine(record.readUInt16LE(4));
+    if (machine === undefined)
+        return err("unsupported PE architecture");
+    const { architecture } = machine;
+    const optionalHeaderSize = record.readUInt16LE(20);
+    if (optionalHeaderSize > 4096 || record.length < 24 + optionalHeaderSize)
+        return err("invalid or truncated PE optional header");
+    const optionalHeader = record.subarray(24, 24 + optionalHeaderSize);
+    const managed = peManagedStatus(optionalHeader, architecture);
+    if (!managed.ok)
+        return managed;
+    if (machine.nativeOsOverride && !managed.value)
+        return err("unsupported PE architecture");
+    const characteristics = record.readUInt16LE(22);
+    return ok({
+        format: "pe",
+        architecture,
+        availableArchitectures: [architecture],
+        executableRole: (characteristics & 0x0002) === 0
+            ? "non-executable"
+            : (characteristics & 0x2000) === 0
+                ? "application"
+                : "shared-library",
+        managed: managed.value,
+    });
+};
+const peManagedStatus = (optionalHeader, architecture) => {
+    if (optionalHeader.length < 2)
+        return err("truncated PE optional header");
+    const magic = optionalHeader.readUInt16LE(0);
+    const expectedMagic = architecture === "x86_64" || architecture === "arm64" ? 0x20b : 0x10b;
+    if (magic !== expectedMagic)
+        return err("PE optional-header magic does not match its architecture");
+    const directoryOffset = magic === 0x20b ? 112 : 96;
+    const directoryCountOffset = directoryOffset - 4;
+    if (optionalHeader.length < directoryCountOffset + 4)
+        return err("truncated PE optional header");
+    const directoryCount = optionalHeader.readUInt32LE(directoryCountOffset);
+    const requiredBytes = directoryOffset + directoryCount * 8;
+    if (!Number.isSafeInteger(requiredBytes) ||
+        requiredBytes > optionalHeader.length)
+        return err("truncated PE data-directory table");
+    if (directoryCount <= 14)
+        return ok(false);
+    const cliDirectory = directoryOffset + 14 * 8;
+    return ok(optionalHeader.readUInt32LE(cliDirectory) !== 0 ||
+        optionalHeader.readUInt32LE(cliDirectory + 4) !== 0);
+};
+const machArchitecture = (cpu) => {
+    switch (cpu) {
+        case 7:
+            return "x86";
+        case 0x01000007:
+            return "x86_64";
+        case 12:
+            return "arm";
+        case 0x0100000c:
+            return "arm64";
+    }
+    return undefined;
+};
+const elfArchitecture = (machine) => {
+    switch (machine) {
+        case 3:
+            return "x86";
+        case 62:
+            return "x86_64";
+        case 8: // EM_MIPS: ISA, ABI and byte order remain separate ELF facts.
+            return "mips";
+        case 40:
+            return "arm";
+        case 183:
+            return "arm64";
+    }
+    return undefined;
+};

package/dist/domain/binaryTargetTypes.js

@@ -0,0 +1,10 @@
+/** Provider-neutral CPU families detected from supported executable headers. */
+export const BINARY_ARCHITECTURES = [
+    "x86",
+    "x86_64",
+    "arm",
+    "arm64",
+    "mips",
+];
+/** Whether an executable target contains a thin or universal Mach-O image. */
+export const isMachOFormat = (format) => format === "mach-o" || format === "mach-o-universal";

package/dist/domain/bridgeCandidateProjection.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+/** Coverage metadata for the bounded projection of candidate relationships. */
+export const bridgeCandidateCoverageSchema = z.strictObject({
+    status: z.enum(["complete", "partial"]),
+    total_candidates: z.number().int().nonnegative(),
+    emitted_candidates: z.number().int().nonnegative(),
+    omitted_candidates: z.number().int().nonnegative(),
+});
+// The serialized candidate array is the retained representation; accounting
+// its exact UTF-8 JSON size bounds both array objects and repeated path strings.
+/** Maximum UTF-8 JSON size of a retained candidate array. */
+export const MAX_BRIDGE_CANDIDATE_JSON_BYTES = 2 * 1024 * 1024;
+const jsonText = (value) => {
+    const serialized = JSON.stringify(value);
+    if (serialized === undefined)
+        throw new TypeError("Bridge candidate is not JSON serializable");
+    return serialized;
+};
+/** Retain a deterministic prefix of grouped Cartesian candidates within a byte budget. */
+export const projectCartesianCandidates = (input) => {
+    const total = input.groups.reduce((sum, group) => sum + group.left.length * group.right.length, 0);
+    const preparedGroups = input.groups.map((group) => ({
+        left: group.left.map((value) => ({
+            value,
+            pathBytes: Buffer.byteLength(jsonText(value.path)),
+        })),
+        right: group.right.map((value) => {
+            const emptyLeftCandidate = jsonText(input.createCandidate("", value));
+            return {
+                value,
+                rowOverhead: Buffer.byteLength(emptyLeftCandidate) - 2,
+            };
+        }),
+    }));
+    let estimatedFullBytes = 2 + Math.max(0, total - 1); // JSON array brackets and commas.
+    for (const group of preparedGroups) {
+        estimatedFullBytes +=
+            group.left.length *
+                group.right.reduce((sum, { rowOverhead }) => sum + rowOverhead, 0) +
+                group.right.length *
+                    group.left.reduce((sum, { pathBytes }) => sum + pathBytes, 0);
+    }
+    const shouldEmitAll = estimatedFullBytes <= MAX_BRIDGE_CANDIDATE_JSON_BYTES;
+    const candidates = [];
+    let estimatedRetainedBytes = 2;
+    candidateLoop: for (const group of preparedGroups) {
+        for (const left of group.left) {
+            for (const right of group.right) {
+                const candidateBytes = right.rowOverhead + left.pathBytes;
+                const additionalBytes = candidateBytes + (candidates.length > 0 ? 1 : 0);
+                if (!shouldEmitAll &&
+                    estimatedRetainedBytes + additionalBytes >
+                        MAX_BRIDGE_CANDIDATE_JSON_BYTES)
+                    break candidateLoop;
+                candidates.push(input.createCandidate(left.value.path, right.value));
+                estimatedRetainedBytes += additionalBytes;
+            }
+        }
+    }
+    return {
+        candidates,
+        coverage: {
+            status: candidates.length === total
+                ? "complete"
+                : "partial",
+            total_candidates: total,
+            emitted_candidates: candidates.length,
+            omitted_candidates: total - candidates.length,
+        },
+    };
+};

package/dist/domain/browserCaptureComparison.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { compareBrowserScenarios } from "./browserScenarioDiff.js";
+import { compareWebCaptures } from "./webCaptureDiff.js";
+import { browserScenarioDiffSchema, compareBrowserScenariosInputSchema, } from "./browserScenarioDiffValues.js";
+import { compareWebCapturesInputSchema, webCaptureDiffSchema, } from "./webCaptureDiffSchemas.js";
+/** Mutually exclusive passive and scenario capture comparison inputs. */
+export const browserCaptureComparisonInputSchema = z.union([compareWebCapturesInputSchema, compareBrowserScenariosInputSchema], {
+    // Standard Schema clients expose the union message, not its branch errors.
+    error: (issue) => issue.code === "invalid_union"
+        ? z.prettifyError(new z.ZodError(issue.errors.flat()))
+        : undefined,
+});
+/** Result from passive page or browser scenario comparison. */
+export const browserCaptureComparisonSchema = z.union([
+    browserScenarioDiffSchema,
+    webCaptureDiffSchema,
+]);
+/** Dispatch a parsed capture comparison to its pure domain comparator. */
+export const compareBrowserCaptures = (input) => "before_scenario" in input
+    ? compareBrowserScenarios(input)
+    : compareWebCaptures(input);