rea-agents 6.2.0 → 6.3.0

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,5 +1,5 @@
 import { artifactInventoryResultSchema, } from "./artifactGraph.js";
-import { compareCodePoints } from "./canonicalOrdering.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";
@@ -68,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) => compareCodePoints(left.artifact_id, right.artifact_id));
-    const occurrences = [...values.occurrences.values()].sort((left, right) => compareCodePoints(left.logical_path, right.logical_path));
-    const edges = [...values.edges.values()].sort((left, right) => compareCodePoints(left.edge_id, 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,
@@ -79,7 +79,7 @@ const orderedInventory = (first, pages, values) => {
         integrityContradictions: first.integrity_contradictions,
         limitations: [
             ...new Set(pages.flatMap(({ inventory }) => inventory.limitations)),
-        ].sort(compareCodePoints),
+        ].sort(compareUnicodeCodePoints),
         complete: nodes.length === first.manifest.node_count &&
             occurrences.length === first.manifest.occurrence_count &&
             edges.length === first.manifest.edge_count,

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/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/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,10 +1,11 @@
 import { z } from "zod";
+import { isAbsolute } from "node:path";
 import { IDENTIFIER_PATTERN } from "./stringPatterns.js";
-import { isAbsoluteLocalPath, localPathStringSchema } from "./localPath.js";
+import { localPathStringSchema } from "./localPath.js";
 import { browserNetworkContentSelectionSchema } from "./browserNetworkEvidence.js";
 import { browserEndpointSchema, browserOriginSchema, } from "./browserObservation.js";
 export const scenarioIdentifierSchema = z.string().regex(IDENTIFIER_PATTERN);
-const browserExecutablePathSchema = localPathStringSchema.refine(isAbsoluteLocalPath, {
+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

package/dist/domain/callPath.js

@@ -1,5 +1,6 @@
 import { callPathInputSchema, callPathResultSchema, parseCallPathAddress, } from "./callPathSchemas.js";
 import { parseFunctionEvidence, } from "./functionDossierEvidence.js";
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
 /** Minimal directed caller-to-callee adjacency for call-path search. */
 class CallGraph {
     successors = new Map();
@@ -76,7 +77,7 @@ export const buildCallPath = (input) => {
         goal: parsed.goal.address,
         explored: summarizeSearch(graph, search.reached),
         evidence_links: uniqueEvidence(snapshots.values()),
-        limitations: [...new Set(limitations)].sort((left, right) => left.localeCompare(right)),
+        limitations: [...new Set(limitations)].sort(compareUnicodeCodePoints),
     };
     const searchScope = { exhaustive };
     if (found)
@@ -111,9 +112,9 @@ const parseSnapshots = (groups) => {
     const snapshots = new Map();
     for (const group of groups) {
         const snapshot = parseFunctionEvidence(group);
-        const address = normalizeAddress(snapshot.dossier.procedure.address);
+        const address = parseCallPathAddress(snapshot.dossier.procedure.address);
         for (const callee of snapshot.dossier.callees)
-            normalizeAddress(callee.address);
+            parseCallPathAddress(callee.address);
         if (snapshots.has(address))
             throw new TypeError(`Duplicate function Evidence for ${address}`);
         snapshots.set(address, snapshot);
@@ -141,7 +142,7 @@ const createGraph = (snapshots) => {
     for (const [address, snapshot] of snapshots) {
         graph.mergeNode(address);
         for (const callee of snapshot.dossier.callees) {
-            const calleeAddress = normalizeAddress(callee.address);
+            const calleeAddress = parseCallPathAddress(callee.address);
             graph.mergeNode(calleeAddress);
             graph.mergeDirectedEdge(address, calleeAddress);
         }
@@ -174,9 +175,7 @@ const inspectSearch = ({ graph, snapshots, start, goal, }) => {
             limitations.push(`No analyze_function Evidence covers reachable function ${node}`);
             continue;
         }
-        const neighbors = graph
-            .outNeighbors(node)
-            .sort((left, right) => left.localeCompare(right));
+        const neighbors = graph.outNeighbors(node).sort(compareUnicodeCodePoints);
         for (const neighbor of neighbors)
             if (!reached.has(neighbor)) {
                 reached.set(neighbor, depth + 1);
@@ -203,7 +202,7 @@ const enumeratePaths = ({ graph, start, goal, goalDistances, }) => {
                 .outNeighbors(node)
                 .filter((neighbor) => distance !== undefined &&
                 goalDistances.get(neighbor) === distance - 1)
-                .sort((left, right) => left.localeCompare(right));
+                .sort(compareUnicodeCodePoints);
             neighbors.set(node, candidates);
         }
         return { neighbors: candidates, nextIndex: 0 };
@@ -270,5 +269,4 @@ const snapshotLinks = (snapshot) => {
 };
 const uniqueEvidence = (snapshots) => [
     ...new Set([...snapshots].flatMap((snapshot) => snapshotLinks(snapshot))),
-].sort((left, right) => left.localeCompare(right));
-const normalizeAddress = (input) => parseCallPathAddress(input);
+].sort(compareUnicodeCodePoints);

package/dist/domain/canonicalDigest.js

@@ -1,5 +1,10 @@
 import { createHash } from "node:crypto";
-/** Hash canonicalize-compatible JSON without assembling an aggregate string. */
+/**
+ * Streaming SHA-256 over canonical JSON. Hashing owner (avoids assembling
+ * aggregate strings); `comparisonSemantics.canonicalJson` (canonicalize lib)
+ * is the string-comparison owner. JSON object keys follow RFC 8785's UTF-16
+ * code-unit order in both; entity-list ordering is a separate concern.
+ */
 export const digestCanonicalValue = (value, context = "Comparison") => {
     const hash = createHash("sha256");
     // Batch small emitted parts to cut hash.update crossings.
@@ -54,6 +59,7 @@ const emitCanonical = (value, emit, ancestors) => {
         else {
             emit("{");
             let first = true;
+            // Match canonicalize/RFC 8785, including supplementary-plane keys.
             for (const key of Object.keys(value).sort()) {
                 if (Reflect.get(value, key) === undefined ||
                     typeof Reflect.get(value, key) === "symbol")

package/dist/domain/canonicalOrdering.js

@@ -1,15 +1,3 @@
 import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
-/**
- * Canonical code-point ordering shared across domain and application layers.
- *
- * Compares strings by Unicode code point so graph ordering, fingerprints, and
- * deterministic tie-breaks stay stable regardless of locale. Prefer this over
- * `String.prototype.localeCompare`, which is locale-dependent.
- *
- * Ordering by code point differs from ordering by UTF-16 code unit for astral
- * code points (above U+FFFF), whose lead surrogate is numerically below the
- * BMP tail U+E000-U+FFFF.
- */
-export const compareCodePoints = (left, right) => compareUnicodeCodePoints(left, right);
 /** Deduplicate and sort strings with canonical code-point ordering. */
-export const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);
+export const uniqueSorted = (values) => [...new Set(values)].sort(compareUnicodeCodePoints);

package/dist/domain/changedBehavior.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { artifactComparisonResultSchema } from "./artifactComparison.js";
 import { uniqueSorted } from "./canonicalOrdering.js";
+import { compositeKey, compareUnicodeCodePoints, } from "./unicodeCodePointOrder.js";
 import { comparisonSourceEvidenceIds } from "./comparisonSourceEvidence.js";
 import { evidenceSchema, parseEvidence } from "./evidence.js";
 import { functionComparisonResultSchema } from "./functionComparisonSchemas.js";
@@ -274,9 +275,7 @@ const behaviorStatus = (statuses) => {
 const isChange = (status) => status === "added" || status === "removed" || status === "changed";
 const count = (findings, classification) => findings.filter((finding) => finding.classification === classification)
     .length;
-const compareFindings = (left, right) => [left.scope, left.dimension, left.source_comparison_id]
-    .join("\0")
-    .localeCompare([right.scope, right.dimension, right.source_comparison_id].join("\0"), "en");
+const compareFindings = (left, right) => compareUnicodeCodePoints(compositeKey([left.scope, left.dimension, left.source_comparison_id]), compositeKey([right.scope, right.dimension, right.source_comparison_id]));
 const assertUnique = (values, label) => {
     if (new Set(values).size !== values.length)
         throw new TypeError(`Changed-behavior analysis rejects duplicate ${label}`);

package/dist/domain/comparisonSemantics.js

@@ -1,13 +1,8 @@
 import canonicalize from "canonicalize";
-import { digestCanonicalValue } from "./canonicalDigest.js";
 /** Whether an inventory can support a claim that an item is absent. */
 export const absenceClaimable = (coverage) => coverage.status === "complete" &&
     coverage.truncated !== true &&
     (coverage.omitted_count === undefined || coverage.omitted_count === 0);
-/** SHA-256 of canonical JSON for stable, provider-neutral comparison IDs. */
-export const canonicalDigest = (value, context = "Comparison") => {
-    return digestCanonicalValue(value, context);
-};
 /** Canonical JSON used for deterministic tie breaking and stable digests. */
 export const canonicalJson = (value, context = "Comparison") => {
     const encoded = canonicalize(value);

package/dist/domain/digests.js

@@ -25,6 +25,3 @@ export const prefixedDigestSchema = (prefix) => z
     .regex(new RegExp(`^${prefix}_[a-f0-9]{64}$`, "u"), `Expected a ${prefix}_ prefixed lowercase sha256 digest`);
 /** True when `value` is a bare digest. */
 export const isDigest = (value) => typeof value === "string" && SHA256_PATTERN.test(value);
-/** True when `value` is a digest carrying `prefix`. */
-export const isPrefixedDigest = (value, prefix) => typeof value === "string" &&
-    prefixedDigestSchema(prefix).safeParse(value).success;

package/dist/domain/evidence.js

@@ -108,6 +108,15 @@ export const validateAnalysisProfileProvider = (evidence, context) => {
 };
 /** Strict, provider-neutral record for one successful public observation. */
 export const evidenceSchema = evidenceBaseSchema.superRefine(validateAnalysisProfileProvider);
+const authenticatedEvidenceSchema = evidenceSchema.superRefine((evidence, context) => {
+    const { evidence_id: evidenceId, ...withoutId } = evidence;
+    if (computeEvidenceId(withoutId) !== evidenceId)
+        context.addIssue({
+            code: "custom",
+            path: ["evidence_id"],
+            message: "Evidence semantic identifier does not match its record",
+        });
+});
 const immutableEvidenceSnapshots = new WeakMap();
 const immutableResultSchema = z
     .custom(isImmutableJsonSnapshot)
@@ -147,11 +156,7 @@ export const parseEvidence = (input) => {
         : undefined;
     if (immutable !== undefined)
         return immutable;
-    const evidence = evidenceSchema.parse(input);
-    const { evidence_id: evidenceId, ...withoutId } = evidence;
-    if (computeEvidenceId(withoutId) !== evidenceId)
-        throw new TypeError("Evidence semantic identifier does not match its record");
-    return evidence;
+    return authenticatedEvidenceSchema.parse(input);
 };
 /** Authenticate and seal a ledger-owned snapshot; external mutable values are copied first. */
 export const immutableEvidence = (input) => rememberImmutableEvidence(parseEvidence(input));

package/dist/domain/evidenceBundle.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import canonicalize from "canonicalize";
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
 import { evidenceSchema, immutableEvidence, parseEvidence, providerSchema, } from "./evidence.js";
 import { residualUnknownSchema, } from "./residualUnknown.js";
 import { freezeJsonSnapshot } from "./immutableJson.js";
@@ -43,7 +44,7 @@ export const createImmutableEvidenceBundle = (records, unknowns = []) => {
 };
 /** Project records into a deterministic bundle whose order has no semantics. */
 export const createEvidenceBundle = (records, unknowns = []) => {
-    const sortedRecords = [...records].sort((left, right) => left.evidence_id.localeCompare(right.evidence_id));
+    const sortedRecords = [...records].sort((left, right) => compareUnicodeCodePoints(left.evidence_id, right.evidence_id));
     return {
         artifacts: uniqueSorted(sortedRecords.flatMap(({ subject }) => subject === null
             ? []
@@ -73,55 +74,60 @@ export const createEvidenceBundle = (records, unknowns = []) => {
                 },
             ]
             : []),
-        unknowns: [...unknowns].sort((left, right) => left.unknown_id.localeCompare(right.unknown_id) ||
+        unknowns: [...unknowns].sort((left, right) => compareUnicodeCodePoints(left.unknown_id, right.unknown_id) ||
             left.revision - right.revision),
         records: sortedRecords,
     };
 };
-/** Restrict a bundle to records and complete unknown histories for one artifact. */
+/** Retain target records and eligible complete unknown histories with their mutation evidence. */
 export const evidenceBundleForTarget = (bundle, sha256) => {
     const recordsById = new Map(bundle.records.map((record) => [record.evidence_id, record]));
-    const candidates = bundle.unknowns.filter(({ scope_digest: scopeDigest }) => scopeDigest === sha256);
+    const histories = new Map();
+    for (const unknown of bundle.unknowns) {
+        const history = histories.get(unknown.unknown_id) ?? [];
+        history.push(unknown);
+        histories.set(unknown.unknown_id, history);
+    }
     const retained = new Set();
-    const revisionsById = new Map();
     const dependents = new Map();
-    for (const unknown of candidates) {
-        const mutationEvidenceIds = new Set(unknown.mutation_evidence_ids);
-        const evidenceAvailable = referencedEvidenceIds(unknown).every((id) => {
-            const record = recordsById.get(id);
-            return (record?.subject?.digest.sha256 === sha256 ||
-                (mutationEvidenceIds.has(id) &&
-                    record?.subject === null &&
-                    record.predicate_type === "rea.residual-unknown-mutation"));
+    const relationships = new Map();
+    for (const [id, history] of histories) {
+        const eligible = history.every((unknown) => {
+            if (unknown.scope_digest !== sha256)
+                return false;
+            const mutationEvidenceIds = new Set(unknown.mutation_evidence_ids);
+            return referencedEvidenceIds(unknown).every((evidenceId) => {
+                const record = recordsById.get(evidenceId);
+                // Mutation subjects record the target active at the time of an edit,
+                // which need not be the question's immutable investigation scope.
+                return (record?.subject?.digest.sha256 === sha256 ||
+                    (mutationEvidenceIds.has(evidenceId) &&
+                        record?.predicate_type === "rea.residual-unknown-mutation"));
+            });
         });
-        if (!evidenceAvailable)
+        if (!eligible)
             continue;
-        retained.add(unknown);
-        revisionsById.set(unknown.unknown_id, (revisionsById.get(unknown.unknown_id) ?? 0) + 1);
-        for (const relatedId of new Set(unknown.relationships.map(({ unknown_id: id }) => id))) {
+        retained.add(id);
+        const relatedIds = new Set(history.flatMap((unknown) => unknown.relationships.map(({ unknown_id }) => unknown_id)));
+        relationships.set(id, relatedIds);
+        for (const relatedId of relatedIds) {
             const references = dependents.get(relatedId) ?? new Set();
-            references.add(unknown);
+            references.add(id);
             dependents.set(relatedId, references);
         }
     }
     const pending = [];
-    for (const unknown of retained)
-        if (unknown.relationships.some(({ unknown_id: id }) => !revisionsById.has(id)))
-            pending.push(unknown);
+    for (const [id, relatedIds] of relationships)
+        if ([...relatedIds].some((relatedId) => !retained.has(relatedId)))
+            pending.push(id);
     for (let index = 0; index < pending.length; index += 1) {
-        const unknown = pending[index];
-        if (unknown === undefined || !retained.delete(unknown))
+        const id = pending[index];
+        if (id === undefined || !retained.delete(id))
             continue;
-        const remaining = (revisionsById.get(unknown.unknown_id) ?? 1) - 1;
-        if (remaining > 0) {
-            revisionsById.set(unknown.unknown_id, remaining);
-            continue;
-        }
-        revisionsById.delete(unknown.unknown_id);
-        for (const dependent of dependents.get(unknown.unknown_id) ?? [])
+        for (const dependent of dependents.get(id) ?? [])
             pending.push(dependent);
     }
-    const unknowns = candidates.filter((unknown) => retained.has(unknown));
+    const unknowns = bundle.unknowns.filter((unknown) => retained.has(unknown.unknown_id));
     const mutationIds = new Set(unknowns.flatMap(({ mutation_evidence_ids: ids }) => ids));
     return createEvidenceBundle(bundle.records.filter((record) => record.subject?.digest.sha256 === sha256 ||
         mutationIds.has(record.evidence_id)), unknowns);
@@ -166,7 +172,19 @@ export const parseEvidenceBundle = (input) => {
     if (new Set(recordIds).size !== recordIds.length)
         throw new TypeError("Evidence bundle contains duplicate record IDs");
     validateUnknownGraph(parsed.unknowns, parsed.records);
-    const canonical = createEvidenceBundle(parsed.records.map(parseEvidence), parsed.unknowns);
+    const canonical = createEvidenceBundle(parsed.records.map((record, index) => {
+        try {
+            return parseEvidence(record);
+        }
+        catch (cause) {
+            if (cause instanceof z.ZodError)
+                throw new z.ZodError(cause.issues.map((issue) => ({
+                    ...issue,
+                    path: ["records", index, ...issue.path],
+                })));
+            throw cause;
+        }
+    }), parsed.unknowns);
     if (JSON.stringify(parsed) !== JSON.stringify(canonical))
         throw new TypeError("Evidence bundle manifests are not canonical");
     return canonical;
@@ -364,6 +382,6 @@ const uniqueSorted = (values) => {
     for (const value of values)
         unique.set(JSON.stringify(value), value);
     return [...unique.entries()]
-        .sort(([left], [right]) => left.localeCompare(right))
+        .sort(([left], [right]) => compareUnicodeCodePoints(left, right))
         .map(([, value]) => value);
 };

package/dist/domain/firmware/firmwareAnalysis.js

@@ -1,12 +1,13 @@
 import { z } from "zod";
+import { isAbsolute } from "node:path";
 import { digestSchema } from "../digests.js";
 import { jsonValueSchema } from "../jsonValue.js";
-import { isAbsoluteLocalPath, localPathStringSchema } from "../localPath.js";
+import { localPathStringSchema } from "../localPath.js";
 const bytes = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
 const range = z.strictObject({ offset: bytes, length: bytes.positive() });
 const target = {
     path: localPathStringSchema
-        .refine(isAbsoluteLocalPath, {
+        .refine(isAbsolute, {
         message: "path must be an absolute local filesystem path (for example /tmp/firmware.bin or C:\\firmware\\firmware.bin)",
     })
         .describe("Absolute local firmware file; never executed. Relative paths are rejected."),
@@ -17,7 +18,7 @@ export const firmwareInputSchemas = {
     extract_firmware: z.strictObject({
         ...target,
         output_directory: localPathStringSchema
-            .refine(isAbsoluteLocalPath, {
+            .refine(isAbsolute, {
             message: "output_directory must be an absolute local filesystem path",
         })
             .describe("Absolute, absent output directory; parent must exist"),

package/dist/domain/functionComparison.js

@@ -1,4 +1,5 @@
 import { canonicalJson } from "./comparisonSemantics.js";
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
 import { parseFunctionEvidence } from "./functionDossierEvidence.js";
 import { functionMatch } from "./functionComparisonNormalization.js";
 import { functionComparisonResultSchema, } from "./functionComparisonSchemas.js";
@@ -32,6 +33,6 @@ export const compareFunctions = (leftInput, rightInput) => {
                     ]
                     : []),
             ]),
-        ].sort((a, b) => a.localeCompare(b)),
+        ].sort((a, b) => compareUnicodeCodePoints(a, b)),
     });
 };

package/dist/domain/functionComparisonNormalization.js

@@ -1,5 +1,5 @@
 import { canonicalJson } from "./comparisonSemantics.js";
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
 export const identityProjection = (snapshot) => ({
     name: snapshot.dossier.procedure.name,
     signature: snapshot.dossier.procedure.signature,
@@ -136,9 +136,10 @@ export const sorted = (values) => values
     value,
     json: canonicalJson(value, "Function normalization"),
 }))
-    .sort((left, right) => compareCodePoints(left.json, right.json))
+    .sort((left, right) => compareUnicodeCodePoints(left.json, right.json))
     .map(({ value }) => value);
-export const isAutoName = (name) => /^(?:sub_[0-9a-f]+|fcn\.[0-9a-f]+)$/iu.test(name);
+/** Recognize address-derived procedure names without excluding named FUN_ symbols. */
+export const isAutoName = (name) => /^(?:sub_[0-9a-f]+|fcn\.[0-9a-f]+|FUN_[0-9a-f]+)$/iu.test(name);
 const parseAddress = (value) => /^0x[0-9a-f]+$/iu.test(value) ? BigInt(value) : null;
 const relativeAddress = (value, base) => {
     const parsed = parseAddress(value);

package/dist/domain/functionComparisonResults.js

@@ -1,4 +1,4 @@
-import { canonicalDigest } from "./comparisonSemantics.js";
+import { digestCanonicalValue } from "./canonicalDigest.js";
 export const dimensionResult = (input) => {
     const context = {
         dimension: input.dimension,
@@ -51,4 +51,4 @@ export const summarize = (dimensions) => ({
     changed: dimensions.filter(({ status }) => status === "changed").length,
     unknown: dimensions.filter(({ status }) => status === "unknown").length,
 });
-const digest = (value) => canonicalDigest(value, "Function comparison");
+const digest = (value) => digestCanonicalValue(value, "Function comparison");

package/dist/domain/functionDossierEvidence.js

@@ -1,4 +1,5 @@
 import { parseEvidence } from "./evidence.js";
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
 import { functionDossierSchema } from "./hopperValues.js";
 /** Parse one complete analyze_function Evidence record for comparison workflows. */
 export const parseFunctionEvidence = (input) => {
@@ -14,6 +15,6 @@ export const parseFunctionEvidence = (input) => {
         dossier,
         limitations: [
             ...new Set([...evidence.limitations, ...dossier.limitations]),
-        ].sort((left, right) => left.localeCompare(right)),
+        ].sort((left, right) => compareUnicodeCodePoints(left, right)),
     };
 };

package/dist/domain/hopperValues.js

@@ -29,12 +29,12 @@ const procedureMapSchema = z.record(z.string(), z.string());
 const addressedNamesSchema = z.array(z.object({ address: z.string(), name: z.string() }));
 const addressedNameMapSchema = z.record(z.string(), z.string());
 const segmentSchema = z.object({
-    name: z.string().default(""),
-    start: z.string().default(""),
-    end: z.string().default(""),
-    readable: z.boolean().nullable().default(null),
-    writable: z.boolean().nullable().default(null),
-    executable: z.boolean().nullable().default(null),
+    name: z.string(),
+    start: z.string(),
+    end: z.string(),
+    readable: z.boolean().nullable(),
+    writable: z.boolean().nullable(),
+    executable: z.boolean().nullable(),
 });
 const unavailableAnalysisFactSchema = z
     .object({ available: z.literal(false), reason: z.string() })
@@ -142,10 +142,6 @@ export const functionBodySchema = z.discriminatedUnion("available", [
             });
     }),
 ]);
-const unknownFunctionBody = () => functionBodySchema.default({
-    available: false,
-    reason: "The provider did not report complete function body ranges.",
-});
 /** Check the declared entry membership against complete, inclusive body ranges. */
 export const functionBodyEntryAgrees = (body, address) => {
     if (!body.available)
@@ -176,8 +172,8 @@ export const procedureIdentitySchema = z
     .object({
     address: z.string(),
     name: z.string(),
-    classification: procedureClassificationSchema.nullable().default(null),
-    body: unknownFunctionBody(),
+    classification: procedureClassificationSchema.nullable(),
+    body: functionBodySchema,
 })
     .strict()
     .superRefine((identity, context) => {
@@ -289,9 +285,9 @@ export const functionDossierSchema = z
         successors: z.array(z.string()),
     })
         .strict()),
-    native_api: nativeApiBoundarySchema.nullable().default(null),
-    native_value_flow: nativeValueFlowSchema.nullable().default(null),
-    limitations: z.array(z.string()).default([]),
+    native_api: nativeApiBoundarySchema.nullable(),
+    native_value_flow: nativeValueFlowSchema.nullable(),
+    limitations: z.array(z.string()),
 })
     .strict();
 /** Strictly parse a complete provider-neutral function dossier. */

package/dist/domain/javascript/electronActiveObservation.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
-import { isAbsoluteLocalPath, localPathStringSchema } from "../localPath.js";
-const pathInputSchema = localPathStringSchema.refine(isAbsoluteLocalPath, {
+import { isAbsolute } from "node:path";
+import { localPathStringSchema } from "../localPath.js";
+const pathInputSchema = localPathStringSchema.refine(isAbsolute, {
     message: "Electron executable, application, and root paths must be absolute local filesystem paths (for example /Applications/Electron.app/Contents/MacOS/Electron)",
 });
 const absolutePathSchema = z
@@ -63,7 +64,7 @@ export const electronActiveObservationInputSchema = z.strictObject({
     args: z
         .array(z
         .string()
-        .regex(/^[^\u0000]*$/u, "Electron arguments must not contain NUL"))
+        .regex(/^[^\x00]*$/u, "Electron arguments must not contain NUL"))
         .default([]),
     actions: z.array(actionSchema).default([]),
 });