rea-agents 6.1.0 → 6.3.0

package/dist/domain/artifactIdentity.js

@@ -1,29 +1,29 @@
-import { canonicalDigest } from "./comparisonSemantics.js";
+import { digestCanonicalValue } from "./canonicalDigest.js";
 /** Content-address an artifact independently of where it was observed. */
-export const artifactIdForContent = (sha256) => `art_${canonicalDigest({ sha256 }, "Artifact")}`;
+export const artifactIdForContent = (sha256) => `art_${digestCanonicalValue({ sha256 }, "Artifact")}`;
 /** Identify an occurrence by its root and exact logical location. */
 export const occurrenceIdForLocation = (input) => input.logicalPath === "."
-    ? `occ_${canonicalDigest({ root: input.rootArtifactId }, "Artifact")}`
-    : `occ_${canonicalDigest({
+    ? `occ_${digestCanonicalValue({ root: input.rootArtifactId }, "Artifact")}`
+    : `occ_${digestCanonicalValue({
         root_artifact_id: input.rootArtifactId,
         logical_path: input.logicalPath,
         entry_kind: input.entryKind,
     }, "Artifact")}`;
 /** Commit to graph members in the ordering established by the inventory owner. */
-export const artifactGraphDigest = (input) => canonicalDigest({
+export const artifactGraphDigest = (input) => digestCanonicalValue({
     nodes: input.nodes,
     occurrences: input.occurrences,
     edges: input.edges,
     integrity_contradictions: input.contradictions,
 }, "Artifact");
 /** Bind a root artifact to its graph commitment. */
-export const artifactManifestId = (rootArtifactId, graphSha256) => `agm_${canonicalDigest({ root_artifact_id: rootArtifactId, graph_sha256: graphSha256 }, "Artifact")}`;
+export const artifactManifestId = (rootArtifactId, graphSha256) => `agm_${digestCanonicalValue({ root_artifact_id: rootArtifactId, graph_sha256: graphSha256 }, "Artifact")}`;
 /** Identify one integrity disagreement at its observed logical path. */
-export const artifactContradictionId = (input) => `ic_${canonicalDigest({
+export const artifactContradictionId = (input) => `ic_${digestCanonicalValue({
     root_artifact_id: input.rootArtifactId,
     logical_path: input.logicalPath,
     declared_sha256: input.declaredSha256,
     observed_sha256: input.observedSha256,
 }, "Artifact")}`;
 /** Identify an edge by its semantic relationship and exact occurrence. */
-export const artifactEdgeId = (semantic) => `edge_${canonicalDigest(semantic, "Artifact")}`;
+export const artifactEdgeId = (semantic) => `edge_${digestCanonicalValue(semantic, "Artifact")}`;

package/dist/domain/artifactInspection.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { artifactInventoryResultSchema, } from "./artifactGraph.js";
-import { canonicalDigest } from "./comparisonSemantics.js";
+import { digestCanonicalValue } from "./canonicalDigest.js";
 import { uniqueSorted } from "./canonicalOrdering.js";
 import { evidenceSchema, parseEvidence } from "./evidence.js";
 import { jsonValueSchema } from "./jsonValue.js";
@@ -137,7 +137,7 @@ export const createArtifactInspection = (inventoryInput) => {
         },
         substeps: [
             {
-                substep_id: `ais_${canonicalDigest({
+                substep_id: `ais_${digestCanonicalValue({
                     operation: "inventory_artifact",
                     evidence_id: inventoryEvidence.evidence_id,
                 }, "Artifact inspection")}`,
@@ -175,7 +175,7 @@ export const createArtifactInspection = (inventoryInput) => {
     };
     return artifactInspectionResultSchema.parse({
         ...semantic,
-        inspection_id: `ai_${canonicalDigest(semantic, "Artifact inspection")}`,
+        inspection_id: `ai_${digestCanonicalValue(semantic, "Artifact inspection")}`,
     });
 };
 const parseInventoryEvidence = (input) => {
@@ -198,7 +198,7 @@ const observation = (kind, subject, value, evidenceId) => {
         evidence_id: evidenceId,
     };
     return {
-        observation_id: `aio_${canonicalDigest(semantic, "Artifact inspection")}`,
+        observation_id: `aio_${digestCanonicalValue(semantic, "Artifact inspection")}`,
         ...semantic,
     };
 };
@@ -212,7 +212,7 @@ const allRelationships = (inventory, evidenceId) => inventory.edges.map((edge) =
         evidence_id: evidenceId,
     };
     return {
-        relationship_id: `air_${canonicalDigest(semantic, "Artifact inspection")}`,
+        relationship_id: `air_${digestCanonicalValue(semantic, "Artifact inspection")}`,
         ...semantic,
     };
 });
@@ -234,7 +234,7 @@ const allHypotheses = (inventory, evidenceId) => {
             limitation: "Format classification proposes a bounded follow-up; it is not semantic proof.",
         };
         return {
-            hypothesis_id: `aih_${canonicalDigest(semantic, "Artifact inspection")}`,
+            hypothesis_id: `aih_${digestCanonicalValue(semantic, "Artifact inspection")}`,
             ...semantic,
         };
     });
@@ -248,7 +248,7 @@ const contradictions = (inventory, evidenceId) => inventory.integrity_contradict
         evidence_id: evidenceId,
     };
     return {
-        contradiction_id: `aic_${canonicalDigest(semantic, "Artifact inspection")}`,
+        contradiction_id: `aic_${digestCanonicalValue(semantic, "Artifact inspection")}`,
         ...semantic,
     };
 });
@@ -308,7 +308,7 @@ const branch = (reason, detail, nextProbe, evidenceId) => {
         evidence_id: evidenceId,
     };
     return {
-        branch_id: `aib_${canonicalDigest(semantic, "Artifact inspection")}`,
+        branch_id: `aib_${digestCanonicalValue(semantic, "Artifact inspection")}`,
         ...semantic,
     };
 };

package/dist/domain/artifactInventoryEvidence.js

@@ -1,9 +1,9 @@
 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";
-import { err, ok } from "./result.js";
 /** Parse, merge, and verify inventory Evidence pages. */
 export const parseArtifactInventoryEvidence = (input) => assembleInventorySet((Array.isArray(input) ? input : [input]).map((value) => {
     const evidence = parseEvidence(value);
@@ -33,17 +33,6 @@ const validateInventoryPage = (inventory) => {
         if (node.artifact_id !== artifactIdForContent(node.sha256))
             throw new TypeError("Artifact node ID is not content-addressed");
 };
-/**
- * Result-returning seam for the empty-pages leaf. Other assembly failures
- * still throw TypeError (migration in progress); parseArtifactInventoryEvidence
- * keeps its throwing contract until callers switch.
- */
-export const tryAssembleInventorySet = (pages) => pages.length === 0
-    ? err({
-        code: "empty",
-        message: "Artifact inventory requires Evidence pages",
-    })
-    : ok(assembleInventorySet(pages));
 const assembleInventorySet = (pages) => {
     const first = pages[0];
     if (first === undefined)
@@ -79,9 +68,9 @@ const assembleInventorySet = (pages) => {
     return { evidence: pages.map(({ evidence }) => evidence), inventory };
 };
 const orderedInventory = (first, pages, values) => {
-    const nodes = [...values.nodes.values()].sort((left, right) => left.artifact_id.localeCompare(right.artifact_id));
-    const occurrences = [...values.occurrences.values()].sort((left, right) => left.logical_path.localeCompare(right.logical_path, "en"));
-    const edges = [...values.edges.values()].sort((left, right) => left.edge_id.localeCompare(right.edge_id));
+    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,
@@ -90,7 +79,7 @@ const orderedInventory = (first, pages, values) => {
         integrityContradictions: first.integrity_contradictions,
         limitations: [
             ...new Set(pages.flatMap(({ inventory }) => inventory.limitations)),
-        ].sort((left, right) => left.localeCompare(right)),
+        ].sort(compareUnicodeCodePoints),
         complete: nodes.length === first.manifest.node_count &&
             occurrences.length === first.manifest.occurrence_count &&
             edges.length === first.manifest.edge_count,
@@ -102,6 +91,10 @@ const validateCompleteInventory = (inventory) => {
     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);
     for (const edge of inventory.edges)

package/dist/domain/artifactOperationError.js

@@ -1,4 +1,4 @@
-import { AnalysisError } from "./analysisErrorBase.js";
+import { AnalysisError, } from "./analysisErrorBase.js";
 /** Artifact inventory or extraction failed a typed safety boundary. */
 export class ArtifactOperationError extends AnalysisError {
     operation;
@@ -8,10 +8,10 @@ export class ArtifactOperationError extends AnalysisError {
     _tag = "ArtifactOperationError";
     constructor(operation, reason, artifactDetails, 
     /** The specific constraint that failed, such as the colliding path. */
-    detail) {
+    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)})`);
+            : `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;

package/dist/domain/artifactPartialObservation.js

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

package/dist/domain/artifactPathSyntax.js

@@ -24,3 +24,52 @@ export const stripQueryAndFragment = (value) => value.split("#", 1)[0]?.split("?
 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

@@ -7,32 +7,38 @@ import { mzWindowsHeaderOffset, parseDosMzHeader } from "./dosMz.js";
 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);
+        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);
+        return parseThinMachO(bytes, magic, fileSize);
     if ([0xcafebabe, 0xbebafeca, 0xcafebabf, 0xbfbafeca].includes(magic))
-        return parseFatMachO(bytes, magic, hostArchitecture);
+        return parseFatMachO(bytes, magic, hostArchitecture, fileSize);
     return err("unsupported binary format");
 };
-const parseThinMachO = (bytes, magic) => {
-    if (bytes.length < 8)
-        return err("truncated Mach-O header");
+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 architecture = machArchitecture(little ? bytes.readUInt32LE(4) : bytes.readUInt32BE(4));
+    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) => {
+const parseFatMachO = (bytes, magic, host, fileSize) => {
     const little = magic === 0xbebafeca || magic === 0xbfbafeca;
     const is64 = magic === 0xcafebabf || magic === 0xbfbafeca;
     if (bytes.length < 8)
@@ -43,10 +49,24 @@ const parseFatMachO = (bytes, magic, host) => {
     if (count === 0 || count > 128 || bytes.length < 8 + count * entrySize)
         return err("truncated or invalid FAT architecture table");
     const architectures = [];
+    const sliceEnds = new Map();
     for (let index = 0; index < count; index += 1) {
-        const architecture = machArchitecture(read(8 + index * entrySize));
-        if (architecture !== undefined && !architectures.includes(architecture))
-            architectures.push(architecture);
+        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));
+        sliceEnds.set(architecture, offset + size);
     }
     const preferred = host === "arm64"
         ? "arm64"
@@ -59,20 +79,26 @@ const parseFatMachO = (bytes, magic, host) => {
                     : undefined;
     if (preferred === undefined || !architectures.includes(preferred))
         return err(`FAT binary has no host-compatible ${host} architecture`);
+    const sliceEnd = sliceEnds.get(preferred) ?? 0n;
+    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",
         architecture: preferred,
         availableArchitectures: architectures,
     });
 };
-const parseElf = (bytes) => {
-    if (bytes.length < 20)
+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)

package/dist/domain/browserCaptureComparison.js

@@ -1,41 +1,14 @@
 import { z } from "zod";
-import { browserScenarioDiffSchema, compareBrowserScenarios, compareBrowserScenariosInputSchema, } from "./browserScenarioDiff.js";
-import { compareWebCaptures, captureSnapshotSchema, webCaptureDiffSchema, } from "./webCaptureDiff.js";
-/** Caller-visible object schema for passive and scenario capture comparisons. */
-export const browserCaptureComparisonInputSchema = z
-    .strictObject({
-    before: captureSnapshotSchema
-        .optional()
-        .describe("Earlier passive web-page capture."),
-    after: captureSnapshotSchema
-        .optional()
-        .describe("Later passive web-page capture."),
-    before_scenario: compareBrowserScenariosInputSchema.shape.before_scenario
-        .optional()
-        .describe("Earlier browser scenario capture."),
-    after_scenario: compareBrowserScenariosInputSchema.shape.after_scenario
-        .optional()
-        .describe("Later browser scenario capture."),
-    normalization: compareBrowserScenariosInputSchema.shape.normalization
-        .unwrap()
-        .optional()
-        .describe("Exact-literal normalization policy."),
-})
-    .superRefine((input, context) => {
-    const passive = input.before !== undefined && input.after !== undefined;
-    const scenario = input.before_scenario !== undefined && input.after_scenario !== undefined;
-    const passiveFieldsPresent = input.before !== undefined || input.after !== undefined;
-    const scenarioFieldsPresent = input.before_scenario !== undefined ||
-        input.after_scenario !== undefined ||
-        input.normalization !== undefined;
-    if (passive && !scenarioFieldsPresent)
-        return;
-    if (scenario && !passiveFieldsPresent)
-        return;
-    context.addIssue({
-        code: "custom",
-        message: "Provide before and after passive captures, or before_scenario, after_scenario, and normalization; do not mix comparison types.",
-    });
+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([
@@ -43,15 +16,6 @@ export const browserCaptureComparisonSchema = z.union([
     webCaptureDiffSchema,
 ]);
 /** Dispatch a parsed capture comparison to its pure domain comparator. */
-export const compareBrowserCaptures = (input) => isScenarioComparison(input)
-    ? compareBrowserScenarios({
-        ...input,
-        normalization: input.normalization ?? { rules: [] },
-    })
-    : compareWebCaptures(toPassiveComparison(input));
-const isScenarioComparison = (input) => input.before_scenario !== undefined && input.after_scenario !== undefined;
-const toPassiveComparison = (input) => {
-    if (input.before === undefined || input.after === undefined)
-        throw new Error("Validated passive comparison is missing a capture");
-    return { before: input.before, after: input.after };
-};
+export const compareBrowserCaptures = (input) => "before_scenario" in input
+    ? compareBrowserScenarios(input)
+    : compareWebCaptures(input);

package/dist/domain/browserCompleteness.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
 /** Stable browser sections used by coverage and omission accounting. */
 const browserSectionSchema = z.enum([
     "frames",
@@ -98,5 +99,5 @@ export const classifyBrowserCompleteness = (input) => {
     });
 };
 const sortedSections = (sections) => [...sections].sort();
-const canonicalExclusions = (exclusions) => [...exclusions].sort((left, right) => left.section.localeCompare(right.section) ||
-    left.reason.localeCompare(right.reason));
+const canonicalExclusions = (exclusions) => [...exclusions].sort((left, right) => compareUnicodeCodePoints(left.section, right.section) ||
+    compareUnicodeCodePoints(left.reason, right.reason));

package/dist/domain/browserNetworkEvidence.js

@@ -1,13 +1,19 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
-/** Caller-selected network content; omission retains metadata alone. */
+/** Resolved network content selection recorded by a capture. */
 export const browserNetworkContentSelectionValuesSchema = z.strictObject({
+    request_body: z.boolean(),
+    response_body: z.boolean(),
+    header_values: z.boolean(),
+});
+/** Caller omission selects metadata alone; individual content facets remain optional. */
+export const browserNetworkContentSelectionSchema = browserNetworkContentSelectionValuesSchema
+    .extend({
     request_body: z.boolean().default(false),
     response_body: z.boolean().default(false),
     header_values: z.boolean().default(false),
-});
-/** Input omission selects metadata without defaulting legacy capture coverage. */
-export const browserNetworkContentSelectionSchema = browserNetworkContentSelectionValuesSchema.default({
+})
+    .default({
     request_body: false,
     response_body: false,
     header_values: false,

package/dist/domain/browserObservation.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-export { browserTargetListSchema, webPageInspectionSchema, } from "./browserObservationSchemas.js";
 const parseExactOrigin = (value) => {
     let url;
     try {

package/dist/domain/browserObservationSchemas.js

@@ -81,9 +81,20 @@ const browserScriptSchema = z.object({
     frame_id: z.string().nullable().default(null),
     url: z.string(),
     origin: z.string().nullable(),
-    cdp_hash: z.string(),
-    length: z.number().int().min(0),
-    is_module: z.boolean(),
+    cdp_hash: z
+        .string()
+        .nullable()
+        .describe("Producer-reported script hash; null when unavailable."),
+    length: z
+        .number()
+        .int()
+        .min(0)
+        .nullable()
+        .describe("Producer-reported script length; null when unavailable."),
+    is_module: z
+        .boolean()
+        .nullable()
+        .describe("Producer-reported module classification; null when unavailable."),
     language: z.string().nullable(),
     source_map_url: z.string().nullable(),
     resource_reconciliation: browserResourceReconciliationSchema,

package/dist/domain/browserScenario.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { browserScenarioActionSchema, browserScenarioBrowserSchema, browserScenarioCaptureSchema, browserScenarioEnvironmentSchema, browserScenarioSecretSchema, browserScenarioStorageSchema, browserScenarioUrlSchema, } from "./browserScenarioValues.js";
-export {} from "./browserScenarioValues.js";
 export const browserScenarioInputSchema = z.strictObject({
     browser: browserScenarioBrowserSchema.describe("Required launch/connect selection. Launch uses the selected executable and an owned temporary profile; connect uses one loopback CDP endpoint and target."),
     start_url: browserScenarioUrlSchema.describe("Required initial HTTP(S) URL. Query values must be declared separately as public literals or secret references."),

package/dist/domain/browserScenarioCapture.js

@@ -1,7 +1,6 @@
 import { z } from "zod";
 import { browserNetworkContentSelectionValuesSchema } from "./browserNetworkEvidence.js";
 import { browserScenarioCompletenessSchema, browserScenarioEventSchema, browserScenarioStepSchema, } from "./browserScenarioCaptureValues.js";
-export { classifyBrowserScenarioCompleteness, browserScenarioEventSchema, browserScenarioStepSchema, browserStepArtifactsSchema, } from "./browserScenarioCaptureValues.js";
 /** Step-indexed browser scenario observation. */
 export const browserScenarioCaptureSchema = z
     .strictObject({
@@ -16,7 +15,7 @@ export const browserScenarioCaptureSchema = z
         start_origin: z.string().min(1),
         action_count: z.number().int().min(1),
         secret_references: z.array(z.string().min(1)),
-        network_content: browserNetworkContentSelectionValuesSchema.optional(),
+        network_content: browserNetworkContentSelectionValuesSchema,
     }),
     duration_ms: z.number().int().min(0),
     steps: z.array(browserScenarioStepSchema).min(1),

package/dist/domain/browserScenarioCaptureValues.js

@@ -103,8 +103,8 @@ const eventBase = {
 const eventUrl = sanitizedBrowserUrlSchema.nullable();
 const networkEventShape = {
     ...eventBase,
-    transaction_id: z.string().min(1).optional(),
-    redirected_from_transaction_id: z.string().min(1).nullable().optional(),
+    transaction_id: z.string().min(1),
+    redirected_from_transaction_id: z.string().min(1).nullable(),
     method: z.string().min(1),
     url: sanitizedBrowserUrlSchema,
     resource_type: z.string().min(1),

package/dist/domain/browserScenarioDiff.js

@@ -1,8 +1,6 @@
-import {} from "./browserScenarioCapture.js";
 import { actionState, artifactEvidenceState, captured, eventEvidenceState, eventsFor, networkContentCoverageReason, screenshotProjection, } from "./browserScenarioDiffEvidence.js";
 import { browserScenarioDiffSchema, } from "./browserScenarioDiffValues.js";
 import { commitBrowserScenarioNormalization, digestNormalizedScenarioValue, } from "./browserScenarioNormalization.js";
-export { browserScenarioDiffSchema, compareBrowserScenariosInputSchema, } from "./browserScenarioDiffValues.js";
 /** Compare scenario steps by stable step ID and apply only committed literal rules. */
 export const compareBrowserScenarios = (input) => {
     const normalization = commitBrowserScenarioNormalization(input.normalization);

package/dist/domain/browserScenarioDiffEvidence.js

@@ -54,18 +54,6 @@ export const eventsFor = (capture, stepIndex) => {
 export const networkContentCoverageReason = (before, after) => {
     const left = before.scenario.network_content;
     const right = after.scenario.network_content;
-    if (left === undefined || right === undefined) {
-        const events = [...before.events.items, ...after.events.items];
-        if (events.some((event) => event.kind === "network-content") ||
-            ((left === undefined) !== (right === undefined) &&
-                events.some((event) => event.kind === "request" ||
-                    event.kind === "response" ||
-                    event.kind === "request-failed" ||
-                    event.kind === "request-finished" ||
-                    event.kind === "request-unfinished")))
-            return "Network content selection is unknown in a legacy capture; capture both sides with matching content selection.";
-        return undefined;
-    }
     return left.request_body !== right.request_body ||
         left.response_body !== right.response_body ||
         left.header_values !== right.header_values

package/dist/domain/browserScenarioDiffValues.js

@@ -62,8 +62,8 @@ const normalizationInputSchema = z
 });
 /** Input for step-aligned comparison of two browser scenario captures. */
 export const compareBrowserScenariosInputSchema = z.strictObject({
-    before_scenario: browserScenarioCaptureSchema.describe("Earlier complete capture_browser_scenario result."),
-    after_scenario: browserScenarioCaptureSchema.describe("Later complete capture_browser_scenario result."),
+    before_scenario: browserScenarioCaptureSchema.describe("Earlier complete normalized_result from capture_browser_scenario."),
+    after_scenario: browserScenarioCaptureSchema.describe("Later complete normalized_result from capture_browser_scenario."),
     normalization: normalizationInputSchema
         .default({ rules: [] })
         .describe("Exact-literal rules committed in the comparison result."),

package/dist/domain/browserScenarioNormalization.js

@@ -1,4 +1,4 @@
-import { canonicalDigest } from "./comparisonSemantics.js";
+import { digestCanonicalValue } from "./canonicalDigest.js";
 const BUILT_IN_RULES = [
     "ignore_step_elapsed_ms",
     "ignore_event_sequence",
@@ -17,11 +17,11 @@ export const commitBrowserScenarioNormalization = (input) => {
     const commitment = { built_in_rules: [...BUILT_IN_RULES], rules };
     return {
         ...commitment,
-        sha256: canonicalDigest(commitment, "Browser scenario"),
+        sha256: digestCanonicalValue(commitment, "Browser scenario"),
     };
 };
 /** Digest one artifact after applying committed exact-literal rules. */
-export const digestNormalizedScenarioValue = (value, artifact, rules) => canonicalDigest(normalize(value, artifact, rules), "Browser scenario");
+export const digestNormalizedScenarioValue = (value, artifact, rules) => digestCanonicalValue(normalize(value, artifact, rules), "Browser scenario");
 const normalize = (value, artifact, rules) => {
     if (artifact === "screenshot")
         return value;

package/dist/domain/browserScenarioValues.js

@@ -1,11 +1,11 @@
 import { z } from "zod";
-import { isAbsoluteLocalPath, localPathStringSchema } from "./localPath.js";
+import { isAbsolute } from "node:path";
+import { IDENTIFIER_PATTERN } from "./stringPatterns.js";
+import { localPathStringSchema } from "./localPath.js";
 import { browserNetworkContentSelectionSchema } from "./browserNetworkEvidence.js";
 import { browserEndpointSchema, browserOriginSchema, } from "./browserObservation.js";
-export const scenarioIdentifierSchema = z
-    .string()
-    .regex(/^[A-Za-z][A-Za-z0-9._-]*$/u);
-const browserExecutablePathSchema = localPathStringSchema.refine(isAbsoluteLocalPath, {
+export const scenarioIdentifierSchema = z.string().regex(IDENTIFIER_PATTERN);
+const browserExecutablePathSchema = localPathStringSchema.refine(isAbsolute, {
     message: "executable_path must be an absolute local filesystem path (for example /opt/chromium/chrome or C:\\chromium\\chrome.exe)",
 });
 const browserScenarioBaseUrlSchema = z
@@ -84,7 +84,7 @@ export const browserScenarioEnvironmentSchema = z
     timezone: z
         .string()
         .min(1)
-        .regex(/^[A-Za-z0-9_+-]+(?:\/[A-Za-z0-9_+-]+)*$/u)
+        .regex(/^[A-Za-z0-9_+\x2d]+(?:\x2f[A-Za-z0-9_+\x2d]+)*$/u)
         .default("UTC"),
     color_scheme: z.enum(["light", "dark", "no-preference"]).default("light"),
     reduced_motion: z.enum(["reduce", "no-preference"]).default("reduce"),