rea-agents 6.4.0 → 6.5.0

package/dist/application/ProviderOperationExecution.js

@@ -10,7 +10,7 @@ import { err, ok } from "../domain/result.js";
  * assembly once instead of per provider.
  */
 export const executeProviderOperation = async (operation, input, options, schema, provider, confidence) => {
-    if (options?.signal?.aborted === true)
+    if (options?.signal?.aborted)
         return err(new AnalysisCancelledError(operation));
     const request = schema.safeParse({ operation, input });
     if (!request.success)
@@ -19,7 +19,7 @@ export const executeProviderOperation = async (operation, input, options, schema
     if (!executed.ok)
         return executed;
     const execution = executed.value;
-    return ok(createEvidence(execution.subject ?? undefined, execution.provider, {
+    const evidence = createEvidence(execution.subject ?? undefined, execution.provider, {
         operation,
         parameters: jsonObjectSchema.parse(request.data.input),
         result: execution.result,
@@ -27,5 +27,13 @@ export const executeProviderOperation = async (operation, input, options, schema
         limitations: execution.limitations,
         locations: execution.locations,
         confidence,
-    }));
+    });
+    // A provider that cannot observe the signal may finish its work after the
+    // caller cancelled, so re-check rather than reporting a completed operation
+    // the caller no longer wants. The observation it completed is still this
+    // provider's Evidence, so the cancellation carries it as the partial
+    // observation instead of discarding a finished result.
+    if (options?.signal?.aborted)
+        return err(new AnalysisCancelledError(operation, { partialObservation: evidence }));
+    return ok(evidence);
 };

package/dist/application/ReconstructionCoverageService.js

@@ -1,7 +1,6 @@
 import { z } from "zod";
 import { reconstructionCoverageEvaluationInputSchema } from "../domain/reconstructionCoverageInput.js";
 import { AnalysisInputError } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
 import { evaluateReconstructionClosure } from "../domain/reconstructionCoverage.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";

package/dist/application/ReconstructionObligationCandidates.js

@@ -4,6 +4,7 @@ import { parseEvidenceBundle, } from "../domain/evidenceBundle.js";
 import { parseProcessCapture } from "../domain/process/processCaptureParsing.js";
 import { parseApplicationGraphEvidence } from "./javascript/JavaScriptApplicationEvidenceGraph.js";
 import { applicationObligationPolicy, semanticObligationPolicy, } from "./ReconstructionObligationPolicies.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 /** Derive conservative candidates from graph, process, and reviewed inputs. */
 export const deriveReconstructionObligationCandidates = (bundleInput, reviewed) => {
     const bundle = parseEvidenceBundle(bundleInput);
@@ -17,7 +18,7 @@ export const deriveReconstructionObligationCandidates = (bundleInput, reviewed)
     for (const obligation of reviewed)
         addCandidate(candidates, reviewedCandidate(obligation, records));
     return {
-        candidates: [...candidates.values()].sort((left, right) => left.obligation_id.localeCompare(right.obligation_id)),
+        candidates: [...candidates.values()].sort((left, right) => compareUnicodeCodePoints(left.obligation_id, right.obligation_id)),
         limitations: [...limitations].sort(),
     };
 };
@@ -274,7 +275,7 @@ const sourceState = (references) => {
         return "reviewed";
     return "unknown";
 };
-const uniqueBy = (values, key) => [...new Map(values.map((value) => [key(value), value])).values()].sort((left, right) => key(left).localeCompare(key(right)));
+const uniqueBy = (values, key) => [...new Map(values.map((value) => [key(value), value])).values()].sort((left, right) => compareUnicodeCodePoints(key(left), key(right)));
 const obligationId = (key) => `obl_${digest({ schema: "ReconstructionObligation", key })}`;
 const digest = (value) => {
     const encoded = canonicalize(value);

package/dist/application/ReconstructionObligationLedgerDiagnostics.js

@@ -1,3 +1,4 @@
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 export const groupManifestBindings = (manifest) => {
     const grouped = new Map();
     for (const binding of manifest.bindings)
@@ -24,8 +25,7 @@ export const uniqueObligationDiagnostics = (diagnostics) => [
         `${diagnostic.code}:${diagnostic.detail}`,
         diagnostic,
     ])).values(),
-].sort((left, right) => `${left.code}:${left.detail}`.localeCompare(`${right.code}:${right.detail}`));
-export const hasObligationDiagnostic = (diagnostics, code) => diagnostics.some((diagnostic) => diagnostic.code === code);
+].sort((left, right) => compareUnicodeCodePoints(`${left.code}:${left.detail}`, `${right.code}:${right.detail}`));
 export const contradictionDiagnostics = (obligationId, contradictions, evidenceById) => {
     const evidenceIds = contradictions.get(obligationId) ?? [];
     if (evidenceIds.length === 0)

package/dist/application/ReconstructionObligationLedgerEvaluation.js

@@ -1,65 +1,47 @@
 import { parseEvidenceBundle, } from "../domain/evidenceBundle.js";
 import { reconstructionObligationLedgerSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
+import { digestCanonicalValue } from "../domain/canonicalDigest.js";
+import { reconstructionObligationCoverage, reconstructionObligationDependencyGraph, reconstructionObligationLedgerClosureDigest, reconstructionObligationLedgerStatus, hasReconstructionObligationDiagnostic as hasDiagnostic, reconstructionObligationOwnershipGraph, reconstructionObligationReports, summarizeReconstructionObligations, } from "../domain/reconstructionObligationLedgerIntegrity.js";
 import { evidenceAuthoritySupportsProof, evidenceSupportsOriginalAuthority, proofAuthoritySatisfies, } from "./ReconstructionObligationAuthority.js";
-import { addObligationDiagnostic as addDiagnostic, contradictionDiagnostics, groupManifestBindings, groupManifestContradictions, hasObligationDiagnostic as hasDiagnostic, uniqueObligationDiagnostics as uniqueDiagnostics, } from "./ReconstructionObligationLedgerDiagnostics.js";
+import { addObligationDiagnostic as addDiagnostic, contradictionDiagnostics, groupManifestBindings, groupManifestContradictions, uniqueObligationDiagnostics as uniqueDiagnostics, } from "./ReconstructionObligationLedgerDiagnostics.js";
 import { originalCaseDiagnostics, originalCasesFor, } from "./ReconstructionObligationOriginalCases.js";
-import { digestObligationLedgerValue, obligationLedgerCoverage, obligationEdgeOrder, obligationLedgerEvidenceLinks, obligationLedgerStatus, obligationReports, summarizeObligations, } from "./ReconstructionObligationLedgerProjection.js";
+import { obligationLedgerEvidenceLinks } from "./ReconstructionObligationLedgerProjection.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 export const evaluateReconstructionObligationLedger = ({ candidates: candidatesInput, bundle: bundleInput, manifest, generationLimitations, }) => {
     const bundle = parseEvidenceBundle(bundleInput);
-    const allCandidates = [...candidatesInput].sort((left, right) => left.obligation_id.localeCompare(right.obligation_id));
+    const allCandidates = [...candidatesInput].sort((left, right) => compareUnicodeCodePoints(left.obligation_id, right.obligation_id));
     const orphanManifestIds = findOrphanManifestIds(allCandidates, manifest);
     const candidates = allCandidates;
     const context = createEvaluationContext(candidates, bundle, manifest);
     const obligations = applyDependencyDiagnostics(candidates.map((candidate) => evaluateObligation(candidate, context)), context);
-    const ownershipGraph = obligations
-        .flatMap((obligation) => obligation.binding === null
-        ? []
-        : [
-            {
-                obligation_id: obligation.obligation_id,
-                module_path: obligation.binding.owner.module_path,
-                symbol: obligation.binding.owner.symbol,
-            },
-        ])
-        .sort(obligationEdgeOrder);
-    const dependencyGraph = obligations
-        .flatMap((obligation) => obligation.dependency_obligation_ids.map((dependencyId) => ({
-        obligation_id: obligation.obligation_id,
-        depends_on_obligation_id: dependencyId,
-    })))
-        .sort(obligationEdgeOrder);
+    const ownershipGraph = reconstructionObligationOwnershipGraph(obligations);
+    const dependencyGraph = reconstructionObligationDependencyGraph(obligations);
     const evidenceLinks = obligationLedgerEvidenceLinks(obligations, manifest);
     const limitations = ledgerLimitations(generationLimitations, allCandidates.length, orphanManifestIds);
-    const coverage = obligationLedgerCoverage(limitations.length > 0);
+    const coverage = reconstructionObligationCoverage(limitations);
     const semantic = {
         coverage,
-        summary: summarizeObligations(obligations),
-        reports: obligationReports(obligations),
+        summary: summarizeReconstructionObligations(obligations),
+        reports: reconstructionObligationReports(obligations),
         ownership_graph: ownershipGraph,
         dependency_graph: dependencyGraph,
         obligations,
         evidence_links: evidenceLinks,
         limitations,
     };
-    const evaluatedStatus = obligationLedgerStatus(obligations);
-    const status = evaluatedStatus === "failed"
-        ? evaluatedStatus
-        : limitations.length > 0
-            ? "unknown"
-            : evaluatedStatus;
-    const closureDigest = digestObligationLedgerValue({
-        schema: "ReconstructionObligationClosure",
+    const status = reconstructionObligationLedgerStatus(obligations, limitations);
+    const closureDigest = reconstructionObligationLedgerClosureDigest({
         status,
         ...semantic,
     });
     return reconstructionObligationLedgerSchema.parse({
         schema: "ReconstructionObligationLedger",
-        ledger_id: `rol_${digestObligationLedgerValue({
+        ledger_id: `rol_${digestCanonicalValue({
             schema: "ReconstructionObligationLedger",
             evidence_ids: bundle.records.map(({ evidence_id: id }) => id),
             obligation_ids: obligations.map(({ obligation_id: id }) => id),
             closure_digest: closureDigest,
-        })}`,
+        }, "Reconstruction obligation ledger")}`,
         closure_digest: closureDigest,
         status,
         ...semantic,

package/dist/application/ReconstructionObligationLedgerProjection.js

@@ -1,50 +1,8 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
-import { canonicalJson } from "../domain/comparisonSemantics.js";
+import { reconstructionObligationEvidenceIds } from "../domain/reconstructionObligationLedgerIntegrity.js";
 import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
-export const obligationLedgerCoverage = (incomplete) => ({
-    status: incomplete ? "partial" : "complete",
-});
-export const summarizeObligations = (obligations) => ({
-    total: obligations.length,
-    required: obligations.filter(({ required }) => required).length,
-    verified: obligations.filter(({ status }) => status === "verified").length,
-    required_open: obligations.filter(({ required, status }) => required && status !== "verified").length,
-    by_status: countBy(obligations, [
-        "unowned",
-        "characterized",
-        "implemented",
-        "verified",
-        "contradicted",
-        "blocked",
-        "out-of-scope",
-        "unknown",
-    ], ({ status }) => status),
-    by_application_layer: countBy(obligations, [
-        "cli",
-        "protocol",
-        "electron",
-        "persistence",
-        "process",
-        "runtime",
-        "packaging",
-        "native-abi",
-        "application",
-        "other",
-    ], ({ application_layer: layer }) => layer),
-    by_evidence_authority: countBy(obligations, ["candidate", "observed", "reviewed", "unknown"], ({ source_state: state }) => state),
-});
-export const obligationReports = (obligations) => ({
-    missing_owner_obligation_ids: obligationIdsWith(obligations, "missing-owner"),
-    missing_verifier_obligation_ids: obligationIdsWith(obligations, "missing-verifier"),
-    contradicted_obligation_ids: obligationIdsWith(obligations, "contradiction"),
-    residual_unknown_ids: [
-        ...new Set(obligations.flatMap(({ residual_unknown_ids: ids }) => ids)),
-    ].sort(),
-});
 export const obligationLedgerEvidenceLinks = (obligations, manifest) => [
     ...new Set([
-        ...obligations.flatMap(({ authority_references: references }) => references.map(({ evidence_id: id }) => id)),
+        ...reconstructionObligationEvidenceIds(obligations),
         ...manifest.bindings.flatMap((binding) => [
             ...binding.original_cases.map(({ evidence_id: id }) => id),
             ...binding.fixtures.flatMap(({ evidence_ids: ids }) => ids),
@@ -54,31 +12,4 @@ export const obligationLedgerEvidenceLinks = (obligations, manifest) => [
         ]),
         ...manifest.contradictions.flatMap(({ evidence_ids: ids }) => ids),
     ]),
-].sort();
-export const obligationLedgerStatus = (obligations) => {
-    if (obligations.length === 0)
-        return "unknown";
-    const requiredOpen = obligations.filter(({ required, status }) => required && status !== "verified");
-    if (requiredOpen.some(({ status, diagnostics }) => status === "contradicted" ||
-        hasDiagnostic(diagnostics, "verifier-failed")))
-        return "failed";
-    if (requiredOpen.some(({ status }) => status === "unknown"))
-        return "unknown";
-    return requiredOpen.length === 0 ? "ready" : "open";
-};
-export const obligationEdgeOrder = (left, right) => compareUnicodeCodePoints(canonicalJson(left), canonicalJson(right));
-export const digestObligationLedgerValue = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Reconstruction obligation ledger is not canonical JSON");
-    return createHash("sha256").update(encoded).digest("hex");
-};
-const countBy = (items, values, valueFor) => values.map((value) => ({
-    key: value,
-    count: items.filter((item) => valueFor(item) === value).length,
-}));
-const obligationIdsWith = (obligations, code) => obligations
-    .filter(({ diagnostics }) => hasDiagnostic(diagnostics, code))
-    .map(({ obligation_id: id }) => id)
-    .sort();
-const hasDiagnostic = (diagnostics, code) => diagnostics.some((diagnostic) => diagnostic.code === code);
+].sort(compareUnicodeCodePoints);

package/dist/application/ReconstructionObligationLedgerService.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { AnalysisProtocolError } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
+import { NonCanonicalEvidenceBundleError } from "../domain/evidenceBundle.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
 import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
@@ -30,6 +30,8 @@ export const buildReconstructionObligationLedgerEvidenceValidated = (input) => {
         return ok(createLedgerEvidence(input, ledger));
     }
     catch (cause) {
+        if (cause instanceof NonCanonicalEvidenceBundleError)
+            return err(workflowInputError(OPERATION, cause));
         if (cause instanceof z.ZodError)
             return err(workflowInputError(OPERATION, cause));
         return err(new AnalysisProtocolError("Reconstruction obligation ledger generation failed", { cause }));

package/dist/application/ReconstructionObligationOriginalCases.js

@@ -1,11 +1,12 @@
 import { evidenceSupportsOriginalAuthority } from "./ReconstructionObligationAuthority.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 /** Merge generated and manifest-supplied original observations canonically. */
 export const originalCasesFor = (candidate, binding) => [
     ...new Map([...candidate.observed_cases, ...(binding?.original_cases ?? [])].map((observed) => [
         `${observed.kind}:${observed.evidence_id}:${observed.location}`,
         observed,
     ])).values(),
-].sort((left, right) => `${left.kind}:${left.evidence_id}:${left.location}`.localeCompare(`${right.kind}:${right.evidence_id}:${right.location}`));
+].sort((left, right) => compareUnicodeCodePoints(`${left.kind}:${left.evidence_id}:${left.location}`, `${right.kind}:${right.evidence_id}:${right.location}`));
 /** Report original cases that are absent or lack comparable Evidence authority. */
 export const originalCaseDiagnostics = (candidate, binding, evidenceById) => {
     const diagnostics = [];

package/dist/application/ReferenceSourceImport.js

@@ -4,7 +4,6 @@ import { err, ok } from "../domain/result.js";
 import { readReferenceSource } from "../reference/ReferenceSourceReader.js";
 import { parseReferenceSourceEntries } from "./ReferenceSourceImportEntries.js";
 import { readReferenceSourceVcs } from "./ReferenceSourceVcsAdapter.js";
-import {} from "./ReferenceSourceImportTypes.js";
 import { prepareReferenceSourceImport, } from "./ReferenceSourceImportPolicy.js";
 const failure = (code, message) => ({
     tag: "reference-source-import",
@@ -55,7 +54,8 @@ const deriveInventoryState = (input) => {
     const partialEntry = input.entries.some((entry) => entry.limitations.length > 0 ||
         (entry.kind === "file" && entry.content_state !== "hashed") ||
         (entry.kind === "directory" && entry.tree_state !== "enumerated") ||
-        (entry.kind === "symlink" && entry.target_state !== "internal"));
+        (entry.kind === "symlink" && entry.target_state !== "internal") ||
+        entry.kind === "unknown");
     if (partialEntry)
         return "partial";
     const partialRelationship = input.relationships.some(({ parse_state, resolution }) => parse_state !== "parsed" ||
@@ -74,20 +74,31 @@ const sortExclusions = (exclusions) => [...exclusions].sort((left, right) => {
     return compareUnicodeCodePoints("pattern" in left ? left.pattern : "", "pattern" in right ? right.pattern : "");
 });
 const createShouldExclude = (exclusions, secrets, ignored) => (path, kind) => {
-    const patternPath = kind === "directory" ? `${path}/` : path;
-    const secretMatch = secrets.test(patternPath);
-    if (secretMatch.ignored) {
+    // An entry of unknown kind may be a directory, so directory-only rules
+    // must still exclude it; this fails closed for caller-marked secrets.
+    const patternPaths = kind === "directory"
+        ? [`${path}/`]
+        : kind === "unknown"
+            ? [path, `${path}/`]
+            : [path];
+    const firstMatch = (matcher) => {
+        const results = patternPaths.map((patternPath) => matcher.test(patternPath));
+        return results.find(({ ignored }) => ignored) ?? results[0];
+    };
+    const secretMatch = firstMatch(secrets);
+    if (secretMatch?.ignored === true) {
         if (!secretMatch.rule)
             throw new Error(`Ignored secret path has no matching rule: ${path}`);
         exclusions.push({
             path,
+            entry_kind: kind,
             reason: "configured-secret",
             pattern: secretMatch.rule.pattern,
         });
         return true;
     }
-    const match = ignored.test(patternPath);
-    if (!match.ignored)
+    const match = firstMatch(ignored);
+    if (match?.ignored !== true)
         return false;
     if (!match.rule)
         throw new Error(`Ignored path has no matching rule: ${path}`);
@@ -96,7 +107,12 @@ const createShouldExclude = (exclusions, secrets, ignored) => (path, kind) => {
         reason !== "default-ignored" &&
         reason !== "caller-excluded")
         throw new Error(`Ignored path has unknown rule origin: ${path}`);
-    exclusions.push({ path, reason, pattern: match.rule.pattern });
+    exclusions.push({
+        path,
+        entry_kind: kind,
+        reason,
+        pattern: match.rule.pattern,
+    });
     return true;
 };
 /**

package/dist/application/ReferenceSourceImportEntries.js

@@ -3,8 +3,8 @@ import { posix } from "node:path";
 import { logicalPathEscapesRoot } from "../domain/artifactIdentity.js";
 import { createReferenceSourcePathLookup, isPortableAbsoluteReferenceTarget, } from "../domain/referenceSourcePathIdentity.js";
 import { classifyReferenceSourcePath, detectReferenceSourceLanguage, } from "../domain/referenceSourceClassification.js";
-import { parseReferenceSourceImports } from "../domain/referenceSourceImportParsing.js";
-import { PARSEABLE_REFERENCE_SOURCE_LANGUAGES } from "./ReferenceSourceImportTypes.js";
+import { parseReferenceSourceImports, PARSEABLE_REFERENCE_SOURCE_LANGUAGES, } from "../domain/referenceSourceImportParsing.js";
+import { typescriptEmittedSourceCandidates } from "./TypeScriptEmittedSourceCandidates.js";
 /** Preserve the observed reader failure and add entry-specific recovery guidance. */
 export const projectReferenceSourceEntryFailure = (entry) => `${entry.message} ${entryRecoveryGuidance(entry)}`;
 const entryRecoveryGuidance = (entry) => {
@@ -16,6 +16,8 @@ const entryRecoveryGuidance = (entry) => {
         return "This directory could not be read. Check its permissions, then try again.";
     if (entry.kind === "symlink")
         return "This symbolic link could not be read safely. Check the link and its permissions, then try again.";
+    if (entry.kind === "unknown")
+        return "This entry's type could not be determined. Check the parent directory and try again.";
     return "This file could not be read. Check its permissions, then try again.";
 };
 const hashBytes = (bytes) => createHash("sha256").update(bytes).digest("hex");
@@ -39,6 +41,13 @@ const failedEntry = (entry) => {
             classifications,
             limitations: [limitation],
         };
+    if (entry.kind === "unknown" || entry.kind === "other")
+        return {
+            path: entry.path,
+            kind: "unknown",
+            classifications: ["unknown"],
+            limitations: [limitation],
+        };
     return {
         path: entry.path,
         kind: "file",
@@ -56,27 +65,17 @@ const resolveInternalSpecifier = (fromPath, specifier, lookupPath) => {
     const normalized = posix.normalize(posix.join(posix.dirname(fromPath), specifier));
     if (logicalPathEscapesRoot(normalized))
         return { to: normalized, resolution: "unresolved" };
+    // Preserve directory intent before normalization removes terminal dot segments.
+    const directoryReference = specifier.endsWith("/") || [".", ".."].includes(posix.basename(specifier));
     const suffixes = ["", ".ts", ".js", ".mjs", ".cjs", ".tsx", ".jsx"];
     const candidates = suffixes.flatMap((suffix) => [
-        `${normalized}${suffix}`,
-        `${normalized}/index${suffix}`,
+        ...(directoryReference ? [] : [`${normalized}${suffix}`]),
+        posix.join(normalized, `index${suffix}`),
     ]);
-    // TypeScript source commonly names the extension emitted for NodeNext.
     // Retain present runtime files first; substitute only a missing counterpart.
     // Counterparts cover explicit filenames, not directory/index resolution.
-    if (/\.(?:ts|tsx|mts|cts)$/u.test(fromPath)) {
-        const sourceSuffixes = normalized.endsWith(".js")
-            ? [".ts", ".tsx", ".d.ts"]
-            : normalized.endsWith(".mjs")
-                ? [".mts", ".d.mts"]
-                : normalized.endsWith(".cjs")
-                    ? [".cts", ".d.cts"]
-                    : normalized.endsWith(".jsx")
-                        ? [".tsx", ".d.ts"]
-                        : [];
-        const stem = normalized.slice(0, -posix.extname(normalized).length);
-        candidates.push(...sourceSuffixes.map((suffix) => `${stem}${suffix}`));
-    }
+    if (!directoryReference)
+        candidates.push(...typescriptEmittedSourceCandidates(fromPath, normalized).map(({ path }) => path));
     const match = lookupPath.resolveCandidates(candidates);
     return match === undefined
         ? { to: normalized, resolution: "unresolved" }
@@ -84,6 +83,9 @@ const resolveInternalSpecifier = (fromPath, specifier, lookupPath) => {
 };
 const appendFile = (entry, lookupPath, output) => {
     const language = detectReferenceSourceLanguage(entry.path);
+    const parsed = language === null || !PARSEABLE_REFERENCE_SOURCE_LANGUAGES.has(language)
+        ? undefined
+        : parseReferenceSourceImports(entry.path, entry.bytes, language);
     output.entries.push({
         path: entry.path,
         kind: "file",
@@ -92,11 +94,10 @@ const appendFile = (entry, lookupPath, output) => {
         language,
         classifications: classifyReferenceSourcePath(entry.path),
         content_state: "hashed",
-        limitations: [],
+        limitations: [...(parsed?.limitations ?? [])],
     });
-    if (language === null || !PARSEABLE_REFERENCE_SOURCE_LANGUAGES.has(language))
+    if (parsed === undefined)
         return;
-    const parsed = parseReferenceSourceImports(entry.path, entry.bytes, language);
     for (const relationship of parsed.relationships) {
         if (relationship.resolution !== "internal") {
             output.relationships.push(relationship);

package/dist/application/ReferenceSourceImportTypes.js

@@ -44,4 +44,3 @@ export const DEFAULT_REFERENCE_SOURCE_IGNORE_PATTERNS = [
     ".coverage",
     "*.log",
 ];
-export const PARSEABLE_REFERENCE_SOURCE_LANGUAGES = new Set(["JavaScript", "TypeScript", "JSX", "TSX"]);

package/dist/application/ReferenceSourceVcsAdapter.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import { lstat } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { err, ok } from "../domain/result.js";
 import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
 import { readRegularFile, RegularFileCleanupFailure, retryRegularFileCleanup, } from "./RegularFileRead.js";
@@ -12,18 +12,27 @@ import { readRegularFile, RegularFileCleanupFailure, retryRegularFileCleanup, }
 export const readReferenceSourceVcs = async (root, resources, signal) => {
     try {
         return await resources.run(async () => {
-            if (isAborted(signal))
-                return ok(unknownVcs());
-            try {
-                await lstat(join(root, ".git"));
-            }
-            catch (cause) {
-                return ok(errorCode(cause) === "ENOENT"
-                    ? { kind: "none", head: null, dirty: null }
-                    : unknownVcs());
+            // Like Git, a subdirectory belongs to its nearest enclosing repository;
+            // only a missing `.git` at every ancestor means no version control.
+            let repository = resolve(root);
+            for (;;) {
+                if (isAborted(signal))
+                    return ok(unknownVcs());
+                try {
+                    await lstat(join(repository, ".git"));
+                    break;
+                }
+                catch (cause) {
+                    if (errorCode(cause) !== "ENOENT")
+                        return ok(unknownVcs());
+                }
+                const parent = dirname(repository);
+                if (parent === repository)
+                    return ok({ kind: "none", head: null, dirty: null });
+                repository = parent;
             }
             try {
-                const head = await resolveSourceHead(root, resources, signal);
+                const head = await resolveSourceHead(repository, resources, signal);
                 if (isAborted(signal))
                     return ok(unknownVcs());
                 return ok({ kind: "git", head, dirty: null });
@@ -109,13 +118,21 @@ const resolveSourceHead = async (root, resources, signal) => {
                 // The library probes readFile() without a path to detect promise APIs.
                 // Reject that invocation without attributing it to a source read.
                 if (path === undefined)
-                    throw new TypeError("Git filesystem read requires a path");
+                    throw new TypeError("Git metadata path is required");
                 try {
                     const bytes = await readMetadataBytes(path);
-                    const encoding = typeof options === "string" ? options : options?.encoding;
-                    return encoding === undefined || encoding === null
-                        ? bytes
-                        : bytes.toString(encoding);
+                    const encoding = typeof options === "string"
+                        ? options
+                        : typeof options === "object" &&
+                            options !== null &&
+                            "encoding" in options
+                            ? options.encoding
+                            : undefined;
+                    if (encoding === undefined || encoding === null)
+                        return bytes;
+                    if (typeof encoding !== "string" || !Buffer.isEncoding(encoding))
+                        throw new TypeError("Unsupported Git metadata text encoding");
+                    return bytes.toString(encoding);
                 }
                 catch (cause) {
                     if (cause instanceof ArtifactReaderFailure) {

package/dist/application/RegularFileRead.js

@@ -2,6 +2,15 @@ import { lstat, stat } from "node:fs/promises";
 import { RegularFileAdmissionFailure, openRegularFile, sameRegularFileState, RegularFileChangedError, } from "../filesystem/RegularFile.js";
 import { OwnedFileHandle } from "../filesystem/OwnedFileHandle.js";
 import { readBoundedFileBytes } from "../process/BoundedFileBytes.js";
+export class InvalidUtf8FileError extends TypeError {
+    path;
+    _tag = "InvalidUtf8FileError";
+    constructor(path, cause) {
+        super(`File is not valid UTF-8: ${path}`, { cause });
+        this.path = path;
+        this.name = this._tag;
+    }
+}
 /** A close failed after reading; this error transfers the exact handle owner. */
 export class RegularFileCleanupFailure extends Error {
     path;
@@ -38,7 +47,10 @@ export const retryRegularFileCleanup = async (failure, resources) => {
 };
 const failureMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
 /** Admit one regular-file handle, retain it through the consumer, and always close it. */
-export const withRegularFile = async (path, read, options = {}) => {
+export const withRegularFile = async (path, read, options = {}) => options.resources === undefined
+    ? withRegularFileOwned(path, read, options)
+    : options.resources.run(() => withRegularFileOwned(path, read, options));
+const withRegularFileOwned = async (path, read, options) => {
     const { signal } = options;
     let handle;
     try {
@@ -50,7 +62,13 @@ export const withRegularFile = async (path, read, options = {}) => {
     catch (cause) {
         if (!(cause instanceof RegularFileAdmissionFailure))
             throw cause;
-        throw new RegularFileCleanupFailure(path, cause.owner, { kind: "failed", cause: cause.cause }, cause.cleanupCause);
+        const failure = new RegularFileCleanupFailure(path, cause.owner, { kind: "failed", cause: cause.cause }, cause.cleanupCause);
+        if (options.resources === undefined)
+            throw failure;
+        const retry = await retryRegularFileCleanup(failure, options.resources);
+        if (retry.cleanup !== undefined)
+            throw failure;
+        throw cause.cause;
     }
     const owner = new OwnedFileHandle(handle);
     let outcome;
@@ -75,29 +93,39 @@ export const withRegularFile = async (path, read, options = {}) => {
         await owner.close();
     }
     catch (cleanupCause) {
-        throw new RegularFileCleanupFailure(path, owner, outcome, cleanupCause);
+        const failure = new RegularFileCleanupFailure(path, owner, outcome, cleanupCause);
+        if (options.resources === undefined)
+            throw failure;
+        const retry = await retryRegularFileCleanup(failure, options.resources);
+        if (retry.cleanup !== undefined)
+            throw failure;
+        if (retry.outcome.kind === "failed")
+            throw retry.outcome.cause;
+        return retry.outcome.value;
     }
     if (outcome.kind === "failed")
         throw outcome.cause;
     return outcome.value;
 };
 /** Admit a regular file without waiting for a pipe, then read its verified handle. */
-export const readRegularFile = (path, options = {}) => withRegularFile(path, async (handle, stats) => {
-    const bytes = await readBoundedFileBytes(handle, stats.size, options.signal);
-    if (bytes === undefined || bytes.length !== stats.size)
-        throw new RegularFileChangedError(path);
-    return bytes;
-}, options);
-/** Read one admitted regular file as UTF-8 without waiting on a pipe. */
-export const readRegularFileText = async (path, options = {}) => {
+export const readRegularFile = (path, options = {}) => readRegularFileContent(path, (bytes) => bytes, options);
+/** Read valid UTF-8 without replacing source bytes or stripping an initial BOM. */
+export const readRegularFileText = (path, options = {}) => readRegularFileContent(path, (bytes) => {
     try {
-        return (await readRegularFile(path, options)).toString("utf8");
+        return new TextDecoder("utf-8", {
+            fatal: true,
+            ignoreBOM: true,
+        }).decode(bytes);
     }
     catch (cause) {
-        if (cause instanceof RegularFileCleanupFailure &&
-            cause.outcome.kind === "completed" &&
-            Buffer.isBuffer(cause.outcome.value))
-            throw new RegularFileCleanupFailure(cause.path, cause.owner, { kind: "completed", value: cause.outcome.value.toString("utf8") }, cause.cleanupCause);
-        throw cause;
+        if (!(cause instanceof TypeError))
+            throw cause;
+        throw new InvalidUtf8FileError(path, cause);
     }
-};
+}, options);
+const readRegularFileContent = (path, decode, options) => withRegularFile(path, async (handle, stats) => {
+    const bytes = await readBoundedFileBytes(handle, stats.size, options.signal);
+    if (bytes === undefined || bytes.length !== stats.size)
+        throw new RegularFileChangedError(path);
+    return decode(bytes);
+}, options);