rea-agents 3.1.0 → 3.2.1

package/dist/application/RealHopperAssertions.js

@@ -1,28 +1,14 @@
 import { z } from "zod";
 const addressSchema = z.string().regex(/^0x[0-9a-f]+$/iu);
 const identitySchema = z.object({ address: addressSchema, name: z.string() });
-const collectionSchema = z.object({
-    items: z.array(z.unknown()),
-    total: z.number().int().min(0).nullable(),
-    returned: z.number().int().min(0),
-    truncated: z.boolean(),
-    next_offset: z.number().int().min(0).nullable(),
-});
-/** Extract a real address from the provider's exact procedure page. */
+/** Extract one real procedure address from the complete inline inventory. */
 export const firstProcedureAddress = (input) => {
-    const page = z
-        .object({
-        items: z.array(z.object({ address: addressSchema })).min(1),
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1),
-        total: z.number().int().min(1),
-        next_offset: z.number().int().min(0).nullable(),
-        has_more: z.boolean(),
-    })
-        .parse(input);
-    const first = page.items[0];
+    const first = z
+        .array(z.object({ address: addressSchema }))
+        .min(1)
+        .parse(input)[0];
     if (first === undefined)
-        throw new TypeError("Procedure page was empty");
+        throw new TypeError("Procedure inventory was empty");
     return first.address;
 };
 /** Reject two target paths that resolve to the same binary content. */
@@ -44,7 +30,7 @@ export const requirePseudocode = (input, operation) => {
         throw new TypeError(`${operation} returned an embedded failure: ${input}`);
     return input;
 };
-/** Validate an exact bounded Hopper function dossier semantically. */
+/** Validate a complete Hopper function dossier semantically. */
 export const requireFunctionDossier = (input, expectedAddress) => {
     const value = objectValue(input, "analyze_function returned no function dossier");
     const procedure = identitySchema.parse(value.procedure);
@@ -52,22 +38,19 @@ export const requireFunctionDossier = (input, expectedAddress) => {
         throw new TypeError("analyze_function returned the wrong procedure");
     if (procedure.name.trim().length === 0)
         throw new TypeError("analyze_function omitted the procedure name");
-    validatePseudocodeBounds(value.pseudocode);
+    requirePseudocode(value.pseudocode, "analyze_function");
     for (const field of COLLECTION_FIELDS)
-        validateCollection(value[field], field);
+        list(value, field);
     for (const field of ["callers", "callees"])
-        z.array(identitySchema).parse(collectionSchema.parse(value[field]).items);
-    validateBlocks(collectionSchema.parse(value.basic_blocks).items);
-    validateInstructionScan(value.instruction_scan);
+        z.array(identitySchema).parse(list(value, field));
+    validateBlocks(list(value, "basic_blocks"));
     return value;
 };
 /** Reject a structurally valid dossier that omits fixture-proven semantics. */
 export const requireFunctionDossierOracle = (input, oracle) => {
     const value = requireFunctionDossier(input, oracle.procedure_address);
     if (oracle.callee_address !== undefined) {
-        const callees = z
-            .array(identitySchema)
-            .parse(collectionSchema.parse(value.callees).items);
+        const callees = z.array(identitySchema).parse(list(value, "callees"));
         if (!callees.some(({ address }) => address === oracle.callee_address))
             throw new TypeError("analyze_function omitted the expected fixture callee");
         const references = z
@@ -75,14 +58,12 @@ export const requireFunctionDossierOracle = (input, oracle) => {
             source_address: addressSchema,
             target_address: addressSchema,
         }))
-            .parse(collectionSchema.parse(value.outgoing_references).items);
+            .parse(list(value, "outgoing_references"));
         if (!references.some(({ target_address }) => target_address === oracle.callee_address))
             throw new TypeError("analyze_function omitted the expected fixture reference");
     }
     if (oracle.caller_address !== undefined) {
-        const callers = z
-            .array(identitySchema)
-            .parse(collectionSchema.parse(value.callers).items);
+        const callers = z.array(identitySchema).parse(list(value, "callers"));
         if (!callers.some(({ address }) => address === oracle.caller_address))
             throw new TypeError("analyze_function omitted the expected fixture caller");
     }
@@ -97,19 +78,18 @@ export const requireFunctionDossierOracle = (input, oracle) => {
             kind: z.enum(["comment", "inline"]),
             text: z.string(),
         }))
-            .parse(collectionSchema.parse(value.comments).items);
+            .parse(list(value, "comments"));
         if (!comments.some(({ address, kind, text }) => address === oracle.procedure_address &&
             kind === "comment" &&
             text === oracle.comment))
             throw new TypeError("analyze_function omitted the verifier comment");
     }
-    if (oracle.require_assembly === true &&
-        collectionSchema.parse(value.assembly).items.length === 0)
+    if (oracle.require_assembly === true && list(value, "assembly").length === 0)
         throw new TypeError("analyze_function omitted fixture assembly");
     if (oracle.require_cfg_successor) {
         const blocks = z
             .array(z.object({ successors: z.array(addressSchema) }))
-            .parse(collectionSchema.parse(value.basic_blocks).items);
+            .parse(list(value, "basic_blocks"));
         if (!blocks.some(({ successors }) => successors.length > 0))
             throw new TypeError("analyze_function omitted a real CFG successor");
     }
@@ -125,12 +105,10 @@ const referenceEdgeSchema = z.object({
     target_address: addressSchema,
 });
 const requireReferencedValue = (dossier, field, expected, normalize) => {
-    const values = z
-        .array(referencedValueSchema)
-        .parse(collectionSchema.parse(dossier[field]).items);
+    const values = z.array(referencedValueSchema).parse(list(dossier, field));
     const references = z
         .array(referenceEdgeSchema)
-        .parse(collectionSchema.parse(dossier.outgoing_references).items);
+        .parse(list(dossier, "outgoing_references"));
     const found = values.some(({ address, value, source_address: sourceAddress }) => normalize(value) === expected &&
         references.some(({ source_address, target_address }) => source_address === sourceAddress && target_address === address));
     if (!found)
@@ -154,36 +132,12 @@ const COLLECTION_FIELDS = [
     "referenced_names",
     "basic_blocks",
 ];
-const validatePseudocodeBounds = (input) => {
-    const pseudocode = z
-        .object({
-        text: z.string(),
-        returned_chars: z.number().int().min(0),
-        total_chars: z.number().int().min(0),
-    })
-        .parse(input);
-    const text = requirePseudocode(pseudocode.text, "analyze_function");
-    if (pseudocode.returned_chars !== [...text].length ||
-        pseudocode.total_chars < pseudocode.returned_chars)
-        throw new TypeError("analyze_function returned inconsistent pseudocode bounds");
-};
-const validateCollection = (input, field) => {
-    const collection = collectionSchema.parse(input);
-    if (collection.returned !== collection.items.length)
-        throw new TypeError(`analyze_function returned an invalid ${field} result`);
-};
+const list = (value, field) => z.array(z.unknown()).parse(value[field]);
 const validateBlocks = (items) => {
     for (const block of items)
         if (!Array.isArray(objectValue(block, "Invalid basic block").successors))
             throw new TypeError("analyze_function omitted CFG successor evidence");
 };
-const validateInstructionScan = (input) => {
-    const scan = z
-        .object({ scanned: z.number().int().min(0), truncated: z.boolean() })
-        .parse(input);
-    if (scan.scanned === 0 && !scan.truncated)
-        throw new TypeError("analyze_function omitted instruction scan limitations");
-};
 const objectValue = (input, message) => {
     const parsed = z.record(z.string(), z.unknown()).safeParse(input);
     if (!parsed.success)

package/dist/application/ReconstructionCoverageService.js

@@ -1,69 +1,23 @@
 import { z } from "zod";
-import { AnalysisCancelledError, AnalysisInputError, } from "../domain/errors.js";
+import { AnalysisInputError } from "../domain/errors.js";
+import { evaluateReconstructionClosure, reconstructionCoverageDataSchema, } from "../domain/reconstructionCoverage.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { evaluateReconstructionClosure, reconstructionCoverageWorkspaceSchema, } from "../domain/reconstructionCoverage.js";
 import { err, ok } from "../domain/result.js";
-import { readReconstructionCoverageWorkspace, writeReconstructionCoverageWorkspace, } from "./ReconstructionCoverageWorkspaceStore.js";
-const COMMIT_OPERATION = "commit_reconstruction_coverage";
-const QUERY_OPERATION = "query_reconstruction_coverage";
-const isAborted = (signal) => signal?.aborted === true;
-export const reconstructionCoverageCommitInputSchema = z.strictObject({
-    approved: z.literal(true),
-    workspace_path: z.string().min(1).max(4_096),
-    expected_revision: z.number().int().min(1).nullable(),
-    workspace: reconstructionCoverageWorkspaceSchema,
+export const reconstructionCoverageEvaluationInputSchema = z.strictObject({
+    coverage: reconstructionCoverageDataSchema,
+    boundary_id: z.string().min(1),
 });
-export const reconstructionCoverageQueryInputSchema = z.strictObject({
-    workspace_path: z.string().min(1).max(4_096),
-    boundary_id: z.string().min(1).max(200),
-});
-export const reconstructionCoverageCommitOutputSchema = z.strictObject({
-    workspace_path: z.string(),
-    bytes: z.number().int().min(0),
-    workspace_id: z.string().regex(/^rcw_[a-f0-9]{64}$/u),
-    revision: z.number().int().min(1),
-    revision_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-    evidence_records: z.number().int().min(0),
-});
-/** Commit one caller-approved canonical reconstruction coverage CAS revision. */
-export const commitReconstructionCoverage = async (rawInput, policy, options = {}) => {
-    const parsed = reconstructionCoverageCommitInputSchema.safeParse(rawInput);
-    if (!parsed.success)
-        return err(new AnalysisInputError(COMMIT_OPERATION, { cause: parsed.error }));
-    if (isAborted(options.signal))
-        return err(new AnalysisCancelledError(COMMIT_OPERATION));
-    const written = await writeReconstructionCoverageWorkspace(parsed.data.workspace, parsed.data.workspace_path, parsed.data.expected_revision, policy);
-    if (!written.ok)
-        return written;
-    return ok(jsonValueSchema.parse({
-        workspace_path: written.value.path,
-        bytes: written.value.bytes,
-        workspace_id: parsed.data.workspace.workspace_id,
-        revision: parsed.data.workspace.revision,
-        revision_sha256: parsed.data.workspace.revision_sha256,
-        evidence_records: parsed.data.workspace.evidence_bundle.records.length,
-    }));
-};
-/** Read one coverage revision and evaluate a named fail-closed boundary. */
-export const queryReconstructionCoverage = async (rawInput, policy, nowEpochMs, options = {}) => {
-    const parsed = reconstructionCoverageQueryInputSchema.safeParse(rawInput);
+/** Evaluate inline reconstruction coverage against a named boundary. */
+export const evaluateReconstructionCoverage = (rawInput, nowEpochMs = Date.now()) => {
+    const parsed = reconstructionCoverageEvaluationInputSchema.safeParse(rawInput);
     if (!parsed.success)
-        return err(new AnalysisInputError(QUERY_OPERATION, { cause: parsed.error }));
-    if (isAborted(options.signal))
-        return err(new AnalysisCancelledError(QUERY_OPERATION));
-    const loaded = await readReconstructionCoverageWorkspace(parsed.data.workspace_path, policy);
-    if (!loaded.ok)
-        return loaded;
-    if (loaded.value === null)
-        return err(new AnalysisInputError(QUERY_OPERATION, {
-            cause: new TypeError("Reconstruction coverage workspace does not exist"),
+        return err(new AnalysisInputError("evaluate_reconstruction_coverage", {
+            cause: parsed.error,
         }));
-    if (isAborted(options.signal))
-        return err(new AnalysisCancelledError(QUERY_OPERATION));
     try {
-        return ok(jsonValueSchema.parse(evaluateReconstructionClosure(loaded.value, parsed.data.boundary_id, nowEpochMs)));
+        return ok(jsonValueSchema.parse(evaluateReconstructionClosure(parsed.data.coverage, parsed.data.boundary_id, nowEpochMs)));
     }
     catch (cause) {
-        return err(new AnalysisInputError(QUERY_OPERATION, { cause }));
+        return err(new AnalysisInputError("evaluate_reconstruction_coverage", { cause }));
     }
 };

package/dist/application/ReconstructionObligationAuthority.js

@@ -42,7 +42,7 @@ export const proofAuthoritySatisfies = (actual, required) => {
 export const evidenceAuthoritySupportsProof = (evidence, authority, expected) => {
     if (evidence.confidence !== "observed" ||
         !proofEvidenceAuthorities[authority].includes(evidence.authority) ||
-        evidence.predicate_type !== "rea.reconstruction-proof/v1" ||
+        evidence.predicate_type !== "rea.reconstruction-proof" ||
         evidence.operation !== "verify_reconstruction_obligations")
         return false;
     const result = evidence.normalized_result;
@@ -67,6 +67,6 @@ export const evidenceSupportsOriginalAuthority = (evidence, authority) => {
         return ["controlled-replay", "external-service"].includes(evidence.authority);
     if (authority === "process")
         return (evidence.operation === "capture_process_scenario" &&
-            evidence.predicate_type === "rea.process-capture/v4");
+            evidence.predicate_type === "rea.process-capture");
     return evidence.authority === "external-service";
 };

package/dist/application/ReconstructionObligationCandidates.js

@@ -73,7 +73,7 @@ const deriveApplicationCandidates = (evidence, records, candidates, limitations)
 };
 const deriveProcessCandidate = (evidence, candidates, limitations) => {
     if (evidence.operation !== "capture_process_scenario" ||
-        evidence.predicate_type !== "rea.process-capture/v4")
+        evidence.predicate_type !== "rea.process-capture")
         return;
     try {
         const capture = parseProcessCapture(evidence.normalized_result);
@@ -146,7 +146,7 @@ const deriveProcessCandidate = (evidence, candidates, limitations) => {
 const generatedCandidate = ({ key, title, policy: candidatePolicy, artifactSha256, applicationNodeId, semanticNodeId, location, authorityReferences, }) => ({
     obligation_id: obligationId(key),
     obligation_version: 1,
-    title: title.slice(0, 500),
+    title,
     origin: "generated",
     application_layer: candidatePolicy.applicationLayer,
     family: candidatePolicy.family,
@@ -218,7 +218,7 @@ const graphReference = (envelope, records, graphEvidence, location) => {
 };
 const reviewedEvidenceState = (evidence) => {
     if (evidence.operation === "capture_process_scenario" &&
-        evidence.predicate_type === "rea.process-capture/v4" &&
+        evidence.predicate_type === "rea.process-capture" &&
         evidence.confidence === "observed")
         return "observed";
     if (evidence.authority === "external-service" &&
@@ -255,7 +255,7 @@ const sourceState = (references) => {
     return "unknown";
 };
 const uniqueBy = (values, key) => [...new Map(values.map((value) => [key(value), value])).values()].sort((left, right) => key(left).localeCompare(key(right)));
-const obligationId = (key) => `obl_${digest({ schema: "rea.reconstruction-obligation/v1", key })}`;
+const obligationId = (key) => `obl_${digest({ schema: "ReconstructionObligation", key })}`;
 const digest = (value) => {
     const encoded = canonicalize(value);
     if (encoded === undefined)

package/dist/application/ReconstructionObligationLedgerEvaluation.js

@@ -4,12 +4,11 @@ import { evidenceAuthoritySupportsProof, evidenceSupportsOriginalAuthority, proo
 import { addObligationDiagnostic as addDiagnostic, contradictionDiagnostics, groupManifestBindings, groupManifestContradictions, hasObligationDiagnostic as hasDiagnostic, uniqueObligationDiagnostics as uniqueDiagnostics, } from "./ReconstructionObligationLedgerDiagnostics.js";
 import { originalCaseDiagnostics, originalCasesFor, } from "./ReconstructionObligationOriginalCases.js";
 import { digestObligationLedgerValue, obligationLedgerCoverage, obligationEdgeOrder, obligationLedgerEvidenceLinks, obligationLedgerStatus, obligationReports, summarizeObligations, } from "./ReconstructionObligationLedgerProjection.js";
-export const evaluateReconstructionObligationLedger = ({ candidates: candidatesInput, bundle: bundleInput, manifest, maxObligations, generationLimitations, }) => {
+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 orphanManifestIds = findOrphanManifestIds(allCandidates, manifest);
-    const candidates = allCandidates.slice(0, maxObligations);
-    const omittedCount = allCandidates.length - candidates.length;
+    const candidates = allCandidates;
     const context = createEvaluationContext(candidates, bundle, manifest);
     const obligations = applyDependencyDiagnostics(candidates.map((candidate) => evaluateObligation(candidate, context)), context);
     const ownershipGraph = obligations
@@ -30,8 +29,8 @@ export const evaluateReconstructionObligationLedger = ({ candidates: candidatesI
     })))
         .sort(obligationEdgeOrder);
     const evidenceLinks = obligationLedgerEvidenceLinks(obligations, manifest);
-    const limitations = ledgerLimitations(generationLimitations, allCandidates.length, omittedCount, orphanManifestIds);
-    const coverage = obligationLedgerCoverage(omittedCount, maxObligations, limitations.length > 0);
+    const limitations = ledgerLimitations(generationLimitations, allCandidates.length, orphanManifestIds);
+    const coverage = obligationLedgerCoverage(limitations.length > 0);
     const semantic = {
         coverage,
         summary: summarizeObligations(obligations),
@@ -42,22 +41,21 @@ export const evaluateReconstructionObligationLedger = ({ candidates: candidatesI
         evidence_links: evidenceLinks,
         limitations,
     };
-    const evaluatedStatus = obligationLedgerStatus(obligations, omittedCount);
+    const evaluatedStatus = obligationLedgerStatus(obligations);
     const status = evaluatedStatus === "failed"
         ? evaluatedStatus
         : limitations.length > 0
             ? "unknown"
             : evaluatedStatus;
     const closureDigest = digestObligationLedgerValue({
-        schema: "rea.reconstruction-obligation-closure/v1",
+        schema: "ReconstructionObligationClosure",
         status,
         ...semantic,
     });
     return reconstructionObligationLedgerSchema.parse({
         schema: "ReconstructionObligationLedger",
-        schema_version: 1,
         ledger_id: `rol_${digestObligationLedgerValue({
-            schema: "rea.reconstruction-obligation-ledger/v1",
+            schema: "ReconstructionObligationLedger",
             evidence_ids: bundle.records.map(({ evidence_id: id }) => id),
             obligation_ids: obligations.map(({ obligation_id: id }) => id),
             closure_digest: closureDigest,
@@ -82,7 +80,7 @@ const findOrphanManifestIds = (candidates, manifest) => {
         ].filter((obligationId) => !candidateIds.has(obligationId))),
     ].sort();
 };
-const ledgerLimitations = (generationLimitations, candidateCount, omittedCount, orphanManifestIds) => [
+const ledgerLimitations = (generationLimitations, candidateCount, orphanManifestIds) => [
     ...new Set([
         ...generationLimitations,
         ...(candidateCount === 0
@@ -90,11 +88,6 @@ const ledgerLimitations = (generationLimitations, candidateCount, omittedCount,
                 "No reconstruction obligations were derived; closure cannot be claimed.",
             ]
             : []),
-        ...(omittedCount > 0
-            ? [
-                `${String(omittedCount)} obligation candidates were omitted by max_obligations; closure is unknown.`,
-            ]
-            : []),
         ...(orphanManifestIds.length > 0
             ? [
                 `Manifest entries reference unknown obligations: ${orphanManifestIds.join(", ")}.`,

package/dist/application/ReconstructionObligationLedgerProjection.js

@@ -1,10 +1,7 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-export const obligationLedgerCoverage = (omittedCount, maxObligations, incomplete) => ({
+export const obligationLedgerCoverage = (incomplete) => ({
     status: incomplete ? "partial" : "complete",
-    truncated: omittedCount > 0,
-    omitted_count: omittedCount,
-    max_obligations: maxObligations,
 });
 export const summarizeObligations = (obligations) => ({
     total: obligations.length,
@@ -56,15 +53,14 @@ export const obligationLedgerEvidenceLinks = (obligations, manifest) => [
         ...manifest.contradictions.flatMap(({ evidence_ids: ids }) => ids),
     ]),
 ].sort();
-export const obligationLedgerStatus = (obligations, omittedCount) => {
+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 (omittedCount > 0 ||
-        requiredOpen.some(({ status }) => status === "unknown"))
+    if (requiredOpen.some(({ status }) => status === "unknown"))
         return "unknown";
     return requiredOpen.length === 0 ? "ready" : "open";
 };

package/dist/application/ReconstructionObligationLedgerService.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
-import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerPageSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
+import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
 import { err, ok } from "../domain/result.js";
 import { JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
 import { deriveReconstructionObligationCandidates } from "./ReconstructionObligationCandidates.js";
@@ -15,7 +15,7 @@ export const resolveReconstructionObligationLedgerRequest = (input) => {
         ? ok(parsed.data)
         : err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
 };
-/** Build one deterministic ledger page and wrap it in portable Evidence v2. */
+/** Build the complete deterministic ledger and wrap it in portable Evidence. */
 export const buildReconstructionObligationLedgerEvidenceValidated = (input) => {
     try {
         const generated = deriveReconstructionObligationCandidates(input.evidence_bundle, input.reviewed_obligations);
@@ -23,11 +23,9 @@ export const buildReconstructionObligationLedgerEvidenceValidated = (input) => {
             candidates: generated.candidates,
             bundle: input.evidence_bundle,
             manifest: input.manifest,
-            maxObligations: input.limits.max_obligations,
             generationLimitations: generated.limitations,
         });
-        const page = pageLedger(ledger, input.page.offset, input.page.limit);
-        return ok(createLedgerEvidence(input, page));
+        return ok(createLedgerEvidence(input, ledger));
     }
     catch (cause) {
         if (cause instanceof z.ZodError)
@@ -35,38 +33,21 @@ export const buildReconstructionObligationLedgerEvidenceValidated = (input) => {
         return err(new AnalysisProtocolError("Reconstruction obligation ledger generation failed", { cause }));
     }
 };
-const pageLedger = (ledger, offset, limit) => {
-    const obligations = ledger.obligations.slice(offset, offset + limit);
-    const nextOffset = offset + obligations.length < ledger.obligations.length
-        ? offset + obligations.length
-        : null;
-    const { obligations: _allObligations, ...summary } = ledger;
-    return reconstructionObligationLedgerPageSchema.parse({
-        ...summary,
-        page: {
-            offset,
-            limit,
-            total: ledger.obligations.length,
-            returned: obligations.length,
-            next_offset: nextOffset,
-        },
-        obligations,
+const createLedgerEvidence = (input, ledger) => {
+    const completeLedger = reconstructionObligationLedgerSchema.parse(ledger);
+    return createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
+        predicateType: "rea.reconstruction-obligation-ledger",
+        operation: OPERATION,
+        parameters: jsonObjectSchema.parse({
+            ledger_id: completeLedger.ledger_id,
+            closure_digest: completeLedger.closure_digest,
+        }),
+        result: jsonValueSchema.parse(completeLedger),
+        rawResult: null,
+        confidence: "inferred",
+        authority: "analyst-inference",
+        environment: null,
+        limitations: completeLedger.limitations,
+        evidenceLinks: completeLedger.evidence_links,
     });
 };
-const createLedgerEvidence = (input, page) => createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
-    predicateType: "rea.reconstruction-obligation-ledger/v1",
-    operation: OPERATION,
-    parameters: jsonObjectSchema.parse({
-        ledger_id: page.ledger_id,
-        closure_digest: page.closure_digest,
-        limits: input.limits,
-        page: input.page,
-    }),
-    result: jsonValueSchema.parse(page),
-    rawResult: null,
-    confidence: "inferred",
-    authority: "analyst-inference",
-    environment: null,
-    limitations: page.limitations,
-    evidenceLinks: page.evidence_links,
-});

package/dist/application/ReferenceSourceImport.js

@@ -1,23 +1,12 @@
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 import { isSecretLikePath } from "../domain/referenceSourceClassification.js";
-import { createHistoricalSourceGraph, historicalSourceParseFailureKey, } from "../domain/referenceSourceGraph.js";
+import { createHistoricalSourceGraph, historicalSourceLanguages, historicalSourceManifests, historicalSourceParseFailureKey, } from "../domain/referenceSourceGraph.js";
 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 compareCodePoints = (left, right) => {
-    const leftPoints = [...left].map((value) => value.codePointAt(0) ?? 0);
-    const rightPoints = [...right].map((value) => value.codePointAt(0) ?? 0);
-    const length = Math.min(leftPoints.length, rightPoints.length);
-    for (let index = 0; index < length; index += 1) {
-        const difference = (leftPoints[index] ?? 0) - (rightPoints[index] ?? 0);
-        if (difference !== 0)
-            return difference;
-    }
-    return leftPoints.length - rightPoints.length;
-};
-const byCodePoint = (left, right) => compareCodePoints(left, right);
 const failure = (code, message) => ({
     tag: "reference-source-import",
     code,
@@ -40,7 +29,7 @@ const deduplicateRelationships = (relationships) => {
 };
 /** Sort parse failures deterministically while retaining distinct reasons. */
 export const normalizeHistoricalSourceParseFailures = (failures) => [...failures]
-    .sort((left, right) => byCodePoint(historicalSourceParseFailureKey(left), historicalSourceParseFailureKey(right)))
+    .sort((left, right) => compareUnicodeCodePoints(historicalSourceParseFailureKey(left), historicalSourceParseFailureKey(right)))
     .filter((value, index, array) => {
     if (index === 0)
         return true;
@@ -54,16 +43,6 @@ const buildProvenance = (options) => ({
     importer_version: options.importerVersion ?? null,
     caller: options.caller,
 });
-const deriveLanguages = (entries) => [
-    ...new Set(entries.flatMap((entry) => entry.kind === "file" && entry.language !== null
-        ? [entry.language]
-        : [])),
-].sort(byCodePoint);
-const deriveManifests = (entries) => entries
-    .flatMap((entry) => entry.kind === "file" && entry.classifications.includes("manifest")
-    ? [entry.path]
-    : [])
-    .sort(byCodePoint);
 const deriveInventoryState = (input) => {
     if (input.limitations.length > 0)
         return "partial";
@@ -83,17 +62,12 @@ const deriveInventoryState = (input) => {
         return "partial";
     return "complete";
 };
-const sortAndLimit = (exclusions, maxExclusions) => {
-    const sorted = [...exclusions].sort((left, right) => {
-        const byPath = byCodePoint(left.path, right.path);
-        if (byPath !== 0)
-            return byPath;
-        return byCodePoint(left.reason, right.reason);
-    });
-    if (sorted.length <= maxExclusions)
-        return sorted;
-    return sorted.slice(0, maxExclusions);
-};
+const sortExclusions = (exclusions) => [...exclusions].sort((left, right) => {
+    const byPath = compareUnicodeCodePoints(left.path, right.path);
+    if (byPath !== 0)
+        return byPath;
+    return compareUnicodeCodePoints(left.reason, right.reason);
+});
 /**
  * Import a reference source directory into a committed historical source graph.
  *
@@ -107,7 +81,7 @@ export const importReferenceSource = async (options) => {
     const prepared = await prepareReferenceSourceImport(options);
     if (!prepared.ok)
         return prepared;
-    const { ignored, limits, root, secrets } = prepared.value;
+    const { ignored, root, secrets } = prepared.value;
     if (isAborted(options.signal))
         return err(cancelled());
     const exclusions = [];
@@ -123,7 +97,7 @@ export const importReferenceSource = async (options) => {
         return false;
     };
     const [readResult, vcs] = await Promise.all([
-        readReferenceSource(root, limits, {
+        readReferenceSource(root, {
             ...(options.signal === undefined ? {} : { signal: options.signal }),
             shouldExclude,
         }),
@@ -133,7 +107,7 @@ export const importReferenceSource = async (options) => {
         const error = readResult.error;
         if (error.code === "cancelled")
             return err(cancelled());
-        return err(failure(error.code === "invalid-limits" ? "invalid-limits" : "io", error.message));
+        return err(failure("io", error.message));
     }
     if (isAborted(options.signal))
         return err(cancelled());
@@ -146,11 +120,11 @@ export const importReferenceSource = async (options) => {
         return err(cancelled());
     const uniqueRelationships = deduplicateRelationships(relationships);
     const uniqueFailures = normalizeHistoricalSourceParseFailures(parseFailures);
-    const sortedEntries = [...entries].sort((left, right) => byCodePoint(left.path, right.path));
-    const sortedExclusions = sortAndLimit(exclusions, limits.maxEntries);
-    const sortedLimitations = [...limitations].sort(byCodePoint);
+    const sortedEntries = [...entries].sort((left, right) => compareUnicodeCodePoints(left.path, right.path));
+    const sortedExclusions = sortExclusions(exclusions);
+    const sortedLimitations = [...limitations].sort(compareUnicodeCodePoints);
     const input = {
-        schema: "HistoricalSourceGraph/v1",
+        schema: "HistoricalSourceGraph",
         authority: "historical-reference",
         root_alias: "$REFERENCE_ROOT",
         inventory_state: deriveInventoryState({
@@ -161,11 +135,11 @@ export const importReferenceSource = async (options) => {
             limitations: sortedLimitations,
         }),
         entries: sortedEntries,
-        relationships: uniqueRelationships.sort((left, right) => byCodePoint(relationshipKey(left), relationshipKey(right))),
+        relationships: uniqueRelationships.sort((left, right) => compareUnicodeCodePoints(relationshipKey(left), relationshipKey(right))),
         parse_failures: uniqueFailures,
         exclusions: sortedExclusions,
-        languages: deriveLanguages(sortedEntries),
-        manifests: deriveManifests(sortedEntries),
+        languages: historicalSourceLanguages(sortedEntries),
+        manifests: historicalSourceManifests(sortedEntries),
         vcs,
         provenance: buildProvenance(options),
         limitations: sortedLimitations,

package/dist/application/ReferenceSourceImportEntries.js

@@ -7,8 +7,6 @@ import { PARSEABLE_REFERENCE_SOURCE_LANGUAGES } from "./ReferenceSourceImportTyp
 export const projectReferenceSourceEntryFailure = (entry) => {
     if (entry.code === "cancelled")
         return "This entry was not read because the import was cancelled. Start the import again when ready.";
-    if (entry.code === "limit")
-        return "This entry was not read because an import limit was reached. Import a smaller directory or raise the configured limits.";
     if (entry.code === "unsupported")
         return "This entry cannot be read safely on this system. Exclude it or import the directory on a supported system.";
     if (entry.kind === "directory")
@@ -26,7 +24,7 @@ const failedEntry = (entry) => {
             path: entry.path,
             kind: "directory",
             classifications,
-            tree_state: entry.code === "limit" ? "partial" : "unreadable",
+            tree_state: "unreadable",
             limitations: [limitation],
         };
     if (entry.kind === "symlink")
@@ -45,7 +43,7 @@ const failedEntry = (entry) => {
         size: entry.size ?? null,
         language: null,
         classifications: entry.kind === "file" ? classifications : ["unknown"],
-        content_state: entry.code === "limit" ? "too-large" : "unreadable",
+        content_state: "unreadable",
         limitations: [limitation],
     };
 };