@davesheffer/hunch 1.19.0 → 1.20.0-rc.2

package/dist/core/landscapeAdoption.js

@@ -0,0 +1,271 @@
+import { compareCodeUnits } from "./canonicalOrder.js";
+import { EdgeSchema, ResourceSchema, isCredentialFreeText, } from "./types.js";
+import { LANDSCAPE_CANDIDATE_SCHEMA_VERSION, LANDSCAPE_DISCOVERY_SCHEMA_VERSION, landscapeContentHash, } from "../extractors/landscapeDiscovery.js";
+export const LANDSCAPE_REVIEW_SCHEMA_VERSION = "hunch.landscape-review/1";
+export const LANDSCAPE_ADOPTION_RECEIPT_SCHEMA_VERSION = "hunch.landscape-adoption-receipt/1";
+const SHA256 = /^sha256:[a-f0-9]{64}$/;
+const MAX_SELECTIONS = 4_096;
+function sortedUnique(values, label) {
+    if (values.length > MAX_SELECTIONS)
+        throw new Error(`landscape ${label} exceeds the bounded selection limit`);
+    const ordered = [...values].sort(compareCodeUnits);
+    for (let index = 1; index < ordered.length; index += 1) {
+        if (ordered[index] === ordered[index - 1])
+            throw new Error(`landscape ${label} contains a duplicate: ${ordered[index]}`);
+    }
+    return ordered;
+}
+function candidateUnsigned(candidate) {
+    return {
+        schema: candidate.schema,
+        authority: candidate.authority,
+        record: candidate.record,
+        evidence: candidate.evidence,
+    };
+}
+/** Refuse a result that was changed after exact-revision discovery. */
+export function assertLandscapeDiscoveryIntegrity(discovery) {
+    if (discovery.schema !== LANDSCAPE_DISCOVERY_SCHEMA_VERSION || discovery.authority !== "candidate") {
+        throw new Error("landscape adoption requires a candidate discovery result");
+    }
+    if (!/^[a-f0-9]{40,64}$/.test(discovery.sourceRevision)) {
+        throw new Error("landscape discovery source revision is not an exact Git commit");
+    }
+    if (!discovery.repositoryRootIdentity || discovery.repositoryRootIdentity.length > 2_048
+        || !isCredentialFreeText(discovery.repositoryRootIdentity)) {
+        throw new Error("landscape discovery repository identity is invalid");
+    }
+    for (const candidate of discovery.resources)
+        ResourceSchema.parse(candidate.record);
+    for (const candidate of discovery.relationships)
+        EdgeSchema.parse(candidate.record);
+    const allCandidates = [...discovery.resources, ...discovery.relationships];
+    const seenHashes = new Set();
+    const seenIds = new Set();
+    for (const candidate of allCandidates) {
+        if (candidate.schema !== LANDSCAPE_CANDIDATE_SCHEMA_VERSION || candidate.authority !== "candidate") {
+            throw new Error("landscape discovery contains a non-candidate record");
+        }
+        if (candidate.record.metadata.discovery_authority !== "candidate") {
+            throw new Error(`landscape candidate ${candidate.record.id} does not retain candidate authority`);
+        }
+        if (candidate.record.currentness?.status !== "unverified"
+            || candidate.record.currentness.source_revision !== discovery.sourceRevision) {
+            throw new Error(`landscape candidate ${candidate.record.id} is not bound to the discovery revision`);
+        }
+        if (!candidate.evidence.length || candidate.evidence.length > 64
+            || candidate.evidence.some((evidence) => evidence.sourceRevision !== discovery.sourceRevision)) {
+            throw new Error(`landscape candidate ${candidate.record.id} has invalid revision evidence`);
+        }
+        const expected = landscapeContentHash(candidateUnsigned(candidate));
+        if (candidate.candidateHash !== expected || !SHA256.test(candidate.candidateHash)) {
+            throw new Error(`landscape candidate ${candidate.record.id} failed its content hash`);
+        }
+        if (seenHashes.has(candidate.candidateHash))
+            throw new Error(`landscape candidate hash is duplicated: ${candidate.candidateHash}`);
+        if (seenIds.has(candidate.record.id))
+            throw new Error(`landscape candidate id is duplicated: ${candidate.record.id}`);
+        seenHashes.add(candidate.candidateHash);
+        seenIds.add(candidate.record.id);
+    }
+    const unsigned = {
+        schema: discovery.schema,
+        authority: discovery.authority,
+        sourceRevision: discovery.sourceRevision,
+        repositoryRootIdentity: discovery.repositoryRootIdentity,
+        resources: discovery.resources,
+        relationships: discovery.relationships,
+        issues: discovery.issues,
+    };
+    if (discovery.discoveryHash !== landscapeContentHash(unsigned) || !SHA256.test(discovery.discoveryHash)) {
+        throw new Error("landscape discovery failed its content hash");
+    }
+}
+function reviewFor(input, selectedCandidateHashes) {
+    const reviewer = input.reviewer.trim();
+    if (!reviewer || reviewer.length > 128 || !isCredentialFreeText(reviewer)) {
+        throw new Error("landscape reviewer must be a credential-free label of 1-128 characters");
+    }
+    const reviewedAt = input.reviewedAt ?? new Date().toISOString();
+    if (reviewedAt.length > 64 || !Number.isFinite(Date.parse(reviewedAt))) {
+        throw new Error("landscape review timestamp must be ISO-compatible");
+    }
+    const acknowledgedIssueCodes = input.acknowledgeIssues
+        ? [...new Set(input.discovery.issues.map((issue) => issue.code))].sort(compareCodeUnits)
+        : [];
+    const unsigned = {
+        schema: LANDSCAPE_REVIEW_SCHEMA_VERSION,
+        authority: "human_confirmed",
+        reviewer,
+        reviewedAt,
+        discoveryHash: input.discovery.discoveryHash,
+        sourceRevision: input.discovery.sourceRevision,
+        repositoryRootIdentity: input.discovery.repositoryRootIdentity,
+        selectedCandidateHashes,
+        acknowledgedIssueCodes,
+    };
+    return { ...unsigned, reviewId: `lr_${landscapeContentHash(unsigned).slice("sha256:".length, "sha256:".length + 24)}` };
+}
+function acceptedMetadata(metadata, candidateHash, discoveryHash, review) {
+    return {
+        ...metadata,
+        discovery_authority: "human_confirmed",
+        landscape_candidate_hash: candidateHash,
+        landscape_discovery_hash: discoveryHash,
+        landscape_review_id: review.reviewId,
+        landscape_reviewed_by: review.reviewer,
+        landscape_reviewed_at: review.reviewedAt,
+    };
+}
+function acceptedResource(candidate, discoveryHash, review) {
+    return ResourceSchema.parse({
+        ...candidate.record,
+        provenance: {
+            ...candidate.record.provenance,
+            source: `${candidate.record.provenance.source}+human_confirmed`,
+            confidence: Math.max(candidate.record.provenance.confidence, 0.95),
+            last_verified: review.reviewedAt,
+        },
+        metadata: acceptedMetadata(candidate.record.metadata, candidate.candidateHash, discoveryHash, review),
+        currentness: {
+            ...candidate.record.currentness,
+            status: "current",
+            verified_at: review.reviewedAt,
+        },
+        updated_at: review.reviewedAt,
+    });
+}
+function acceptedRelationship(candidate, discoveryHash, review) {
+    return EdgeSchema.parse({
+        ...candidate.record,
+        provenance: {
+            ...candidate.record.provenance,
+            source: `${candidate.record.provenance.source}+human_confirmed`,
+            confidence: Math.max(candidate.record.provenance.confidence, 0.95),
+            last_verified: review.reviewedAt,
+        },
+        metadata: acceptedMetadata(candidate.record.metadata, candidate.candidateHash, discoveryHash, review),
+        currentness: {
+            ...candidate.record.currentness,
+            status: "current",
+            verified_at: review.reviewedAt,
+        },
+    });
+}
+function sameAcceptedCandidate(record, candidate, discoveryHash) {
+    const reviewId = record.metadata.landscape_review_id;
+    const reviewer = record.metadata.landscape_reviewed_by;
+    const reviewedAt = record.metadata.landscape_reviewed_at;
+    if (typeof reviewId !== "string" || !/^lr_[a-f0-9]{24}$/.test(reviewId)
+        || typeof reviewer !== "string" || !reviewer || reviewer.length > 128 || !isCredentialFreeText(reviewer)
+        || typeof reviewedAt !== "string" || !Number.isFinite(Date.parse(reviewedAt)))
+        return false;
+    const review = { reviewId, reviewer, reviewedAt };
+    const expected = record.schema === "hunch.resource/1"
+        ? acceptedResource(candidate, discoveryHash, review)
+        : acceptedRelationship(candidate, discoveryHash, review);
+    // Metadata hashes are evidence, not self-authenticating proof. Reuse only
+    // when the entire reviewed record still equals the candidate-derived value.
+    return landscapeContentHash(record) === landscapeContentHash(expected);
+}
+/**
+ * Convert an exact candidate discovery into a prevalidated write plan.
+ *
+ * Planning has no side effects. The caller persists only `resourcesToWrite` and
+ * `relationshipsToWrite` through the ordinary Hunch capture boundary after this
+ * function has proved every selection, endpoint and existing-record conflict.
+ */
+export function planLandscapeAdoption(input) {
+    assertLandscapeDiscoveryIntegrity(input.discovery);
+    if (input.expectedDiscoveryHash !== input.discovery.discoveryHash) {
+        throw new Error("landscape discovery changed after review; review the current candidate set again");
+    }
+    if (input.discovery.issues.length > 0 && input.acknowledgeIssues !== true) {
+        throw new Error(`landscape discovery has ${input.discovery.issues.length} issue(s); inspect them and explicitly acknowledge them before adoption`);
+    }
+    const allCandidates = [
+        ...input.discovery.resources,
+        ...input.discovery.relationships,
+    ];
+    const allHashes = allCandidates.map((candidate) => candidate.candidateHash);
+    const selectedCandidateHashes = input.candidateHashes === "all"
+        ? [...allHashes].sort(compareCodeUnits)
+        : sortedUnique(input.candidateHashes, "candidate selection");
+    if (selectedCandidateHashes.length === 0)
+        throw new Error("landscape adoption requires at least one selected candidate");
+    const candidatesByHash = new Map(allCandidates.map((candidate) => [candidate.candidateHash, candidate]));
+    for (const hash of selectedCandidateHashes) {
+        if (!SHA256.test(hash) || !candidatesByHash.has(hash))
+            throw new Error(`landscape selection names an unknown candidate: ${hash}`);
+    }
+    const selected = new Set(selectedCandidateHashes);
+    const selectedResources = input.discovery.resources.filter((candidate) => selected.has(candidate.candidateHash));
+    const selectedRelationships = input.discovery.relationships.filter((candidate) => selected.has(candidate.candidateHash));
+    const selectedResourceIds = new Set(selectedResources.map((candidate) => candidate.record.id));
+    for (const candidate of selectedRelationships) {
+        if (!selectedResourceIds.has(candidate.record.from) || !selectedResourceIds.has(candidate.record.to)) {
+            throw new Error(`landscape relationship ${candidate.record.id} requires both endpoint resource candidates to be selected`);
+        }
+    }
+    const review = reviewFor(input, selectedCandidateHashes);
+    const existingResources = new Map();
+    for (const value of input.existingResources ?? []) {
+        const record = ResourceSchema.parse(value);
+        if (existingResources.has(record.id))
+            throw new Error(`landscape existing resources contain duplicate id: ${record.id}`);
+        existingResources.set(record.id, record);
+    }
+    const existingRelationships = new Map();
+    for (const value of input.existingRelationships ?? []) {
+        const record = EdgeSchema.parse(value);
+        if (existingRelationships.has(record.id))
+            throw new Error(`landscape existing relationships contain duplicate id: ${record.id}`);
+        existingRelationships.set(record.id, record);
+    }
+    const resourcesToWrite = [];
+    const relationshipsToWrite = [];
+    const reusedResourceIds = [];
+    const reusedRelationshipIds = [];
+    for (const candidate of selectedResources) {
+        const existing = existingResources.get(candidate.record.id);
+        if (existing) {
+            if (!sameAcceptedCandidate(existing, candidate, input.discovery.discoveryHash)) {
+                throw new Error(`landscape resource ${candidate.record.id} already exists with different reviewed content`);
+            }
+            reusedResourceIds.push(existing.id);
+        }
+        else {
+            resourcesToWrite.push(acceptedResource(candidate, input.discovery.discoveryHash, review));
+        }
+    }
+    for (const candidate of selectedRelationships) {
+        const existing = existingRelationships.get(candidate.record.id);
+        if (existing) {
+            if (!sameAcceptedCandidate(existing, candidate, input.discovery.discoveryHash)) {
+                throw new Error(`landscape relationship ${candidate.record.id} already exists with different reviewed content`);
+            }
+            reusedRelationshipIds.push(existing.id);
+        }
+        else {
+            relationshipsToWrite.push(acceptedRelationship(candidate, input.discovery.discoveryHash, review));
+        }
+    }
+    const receiptUnsigned = {
+        schema: LANDSCAPE_ADOPTION_RECEIPT_SCHEMA_VERSION,
+        authority: "human_confirmed",
+        review,
+        acceptedResourceIds: selectedResources.map((candidate) => candidate.record.id).sort(compareCodeUnits),
+        acceptedRelationshipIds: selectedRelationships.map((candidate) => candidate.record.id).sort(compareCodeUnits),
+        writtenResourceIds: resourcesToWrite.map((record) => record.id).sort(compareCodeUnits),
+        writtenRelationshipIds: relationshipsToWrite.map((record) => record.id).sort(compareCodeUnits),
+        reusedResourceIds: reusedResourceIds.sort(compareCodeUnits),
+        reusedRelationshipIds: reusedRelationshipIds.sort(compareCodeUnits),
+    };
+    const receiptId = `la_${landscapeContentHash(receiptUnsigned).slice("sha256:".length, "sha256:".length + 24)}`;
+    return {
+        receipt: { ...receiptUnsigned, receiptId },
+        resourcesToWrite,
+        relationshipsToWrite,
+    };
+}
+//# sourceMappingURL=landscapeAdoption.js.map

package/dist/core/landscapeDelivery.js

@@ -0,0 +1,281 @@
+import { createHash } from "node:crypto";
+import { compareCodeUnits } from "./canonicalOrder.js";
+import { EdgeSchema, ResourceSchema, } from "./types.js";
+export const LANDSCAPE_FRAGMENT_SCHEMA_VERSION = "hunch.landscape-fragment/1";
+const SHA256 = /^sha256:[a-f0-9]{64}$/;
+const REVIEW_ID = /^lr_[a-f0-9]{24}$/;
+const DEFAULT_FRAGMENT_ITEMS = 8;
+const MAX_FRAGMENT_ITEMS = 24;
+const MAX_FRAGMENT_OMISSIONS = 16;
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (value && typeof value === "object") {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => compareCodeUnits(left, right))
+            .map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "undefined";
+}
+export function landscapeFragmentHash(value) {
+    return `sha256:${createHash("sha256").update(canonical(value)).digest("hex")}`;
+}
+function reviewedCurrent(record) {
+    return record.metadata.discovery_authority === "human_confirmed"
+        && typeof record.metadata.landscape_candidate_hash === "string"
+        && SHA256.test(record.metadata.landscape_candidate_hash)
+        && typeof record.metadata.landscape_discovery_hash === "string"
+        && SHA256.test(record.metadata.landscape_discovery_hash)
+        && typeof record.metadata.landscape_review_id === "string"
+        && REVIEW_ID.test(record.metadata.landscape_review_id)
+        && record.currentness?.status === "current"
+        && typeof record.currentness.source_revision === "string"
+        && /^[a-f0-9]{40,64}$/.test(record.currentness.source_revision)
+        && record.provenance.source.split("+").includes("human_confirmed");
+}
+function tokens(value) {
+    return new Set((value.toLowerCase().match(/[a-z0-9][a-z0-9._/-]{2,}/g) ?? [])
+        .map((token) => token.replace(/^\/+|\/+$/g, ""))
+        .filter(Boolean));
+}
+function relevance(resource, target, targetTokens) {
+    const normalized = target.trim().toLowerCase();
+    const fields = [resource.id, resource.name, resource.locator ?? "", ...resource.scope];
+    if (fields.some((field) => field.toLowerCase() === normalized))
+        return { score: 1_000, reason: "exact-target" };
+    const recordTokens = tokens(fields.join(" "));
+    let overlap = 0;
+    for (const token of targetTokens)
+        if (recordTokens.has(token))
+            overlap++;
+    if (overlap > 0)
+        return { score: 700 + overlap * 20, reason: "task-match" };
+    if (resource.kind === "repository" && resource.scope.length === 0)
+        return { score: 500, reason: "orientation-root" };
+    return null;
+}
+/**
+ * Select a small orientation fragment from durable graph records.
+ *
+ * Candidate/unreviewed/stale records are excluded before ranking, so neither a
+ * good lexical match nor a graph edge can accidentally upgrade their authority.
+ */
+export function selectReviewedLandscape(resources, relationships, target, maxItems = DEFAULT_FRAGMENT_ITEMS) {
+    const boundedItems = Number.isFinite(maxItems)
+        ? Math.max(1, Math.min(MAX_FRAGMENT_ITEMS, Math.floor(maxItems)))
+        : DEFAULT_FRAGMENT_ITEMS;
+    const currentResources = resources
+        .map((record) => ResourceSchema.parse(record))
+        .filter(reviewedCurrent)
+        .sort((left, right) => compareCodeUnits(left.id, right.id));
+    const currentIds = new Set(currentResources.map((record) => record.id));
+    const currentRelationships = relationships
+        .filter((record) => record.schema === "hunch.resource-relationship/1")
+        .map((record) => EdgeSchema.parse(record))
+        .filter((record) => reviewedCurrent(record) && currentIds.has(record.from) && currentIds.has(record.to))
+        .sort((left, right) => compareCodeUnits(left.id, right.id));
+    const targetTokens = tokens(target);
+    const scores = new Map();
+    for (const resource of currentResources) {
+        const match = relevance(resource, target, targetTokens);
+        if (match)
+            scores.set(resource.id, match);
+    }
+    // A matched/root node brings only its immediate reviewed neighbors into the
+    // candidate pool. This is orientation, not an unbounded organization crawl.
+    const initialIds = new Set(scores.keys());
+    for (const relationship of currentRelationships) {
+        const fromSelected = initialIds.has(relationship.from);
+        const toSelected = initialIds.has(relationship.to);
+        if (fromSelected === toSelected)
+            continue;
+        const neighborId = fromSelected ? relationship.to : relationship.from;
+        const existing = scores.get(neighborId);
+        if (!existing || existing.score < 350)
+            scores.set(neighborId, { score: 350, reason: "graph-neighbor" });
+    }
+    const rankedResources = currentResources
+        .filter((record) => scores.has(record.id))
+        .sort((left, right) => {
+        const leftScore = scores.get(left.id).score;
+        const rightScore = scores.get(right.id).score;
+        return rightScore - leftScore || compareCodeUnits(left.id, right.id);
+    });
+    // Reserve room for connections whenever the selected graph has any. Five
+    // nodes + three relationships is the default eight-headline orientation cap.
+    const resourceCap = Math.min(rankedResources.length, Math.max(1, Math.ceil(boundedItems * 0.625)));
+    const initiallyChosen = rankedResources.slice(0, resourceCap);
+    const orientationRoot = rankedResources.find((record) => record.kind === "repository" && record.scope.length === 0);
+    const chosenResources = orientationRoot && !initiallyChosen.some((record) => record.id === orientationRoot.id)
+        ? [...initiallyChosen.slice(0, Math.max(0, resourceCap - 1)), orientationRoot]
+            .sort((left, right) => rankedResources.indexOf(left) - rankedResources.indexOf(right))
+        : initiallyChosen;
+    const chosenIds = new Set(chosenResources.map((record) => record.id));
+    const connectable = currentRelationships.filter((record) => chosenIds.has(record.from) && chosenIds.has(record.to));
+    const relationshipCap = Math.max(0, boundedItems - chosenResources.length);
+    const chosenRelationships = connectable.slice(0, relationshipCap);
+    const omitted = [];
+    for (const record of rankedResources.filter((candidate) => !chosenIds.has(candidate.id))) {
+        if (omitted.length >= MAX_FRAGMENT_OMISSIONS)
+            break;
+        omitted.push({
+            kind: "resources",
+            recordId: record.id,
+            reason: "landscape-cap",
+            detail: `reviewed resource fell below the bounded ${boundedItems}-item landscape orientation cap`,
+        });
+    }
+    for (const record of connectable.slice(relationshipCap)) {
+        if (omitted.length >= MAX_FRAGMENT_OMISSIONS)
+            break;
+        omitted.push({
+            kind: "relationships",
+            recordId: record.id,
+            reason: "landscape-cap",
+            detail: `reviewed relationship fell below the bounded ${boundedItems}-item landscape orientation cap`,
+        });
+    }
+    return {
+        schema: LANDSCAPE_FRAGMENT_SCHEMA_VERSION,
+        authority: "human_confirmed",
+        target,
+        resources: chosenResources.map((record, index) => ({
+            record,
+            selectionReason: scores.get(record.id).reason,
+            selectionRank: index + 1,
+        })),
+        relationships: chosenRelationships.map((record, index) => ({
+            record,
+            selectionReason: "graph-connection",
+            selectionRank: chosenResources.length + index + 1,
+        })),
+        omitted,
+    };
+}
+function stringsFromMetadata(records, key) {
+    return [...new Set(records
+            .map((record) => record.metadata[key])
+            .filter((value) => typeof value === "string"))]
+        .sort(compareCodeUnits);
+}
+export function createLandscapeDeliveryFragment(input) {
+    const deliveredRecords = [
+        ...input.resources.map((item) => item.record),
+        ...input.relationships.map((item) => item.record),
+    ];
+    const unsigned = {
+        schema: LANDSCAPE_FRAGMENT_SCHEMA_VERSION,
+        authority: "human_confirmed",
+        target: input.selection.target,
+        resources: input.resources,
+        relationships: input.relationships,
+        omitted: [...input.omitted].sort((left, right) => compareCodeUnits(left.recordId, right.recordId) || compareCodeUnits(left.reason, right.reason)),
+        reviewIds: stringsFromMetadata(deliveredRecords, "landscape_review_id"),
+        discoveryHashes: stringsFromMetadata(deliveredRecords, "landscape_discovery_hash"),
+        sourceRevisions: [...new Set(deliveredRecords
+                .map((record) => record.currentness?.source_revision)
+                .filter((value) => typeof value === "string"))]
+            .sort(compareCodeUnits),
+    };
+    const fragment = { ...unsigned, fragmentHash: landscapeFragmentHash(unsigned) };
+    assertLandscapeDeliveryFragment(fragment);
+    return fragment;
+}
+export function assertLandscapeDeliveryFragment(value) {
+    if (value.schema !== LANDSCAPE_FRAGMENT_SCHEMA_VERSION || value.authority !== "human_confirmed") {
+        throw new Error("landscape delivery fragment schema or authority is invalid");
+    }
+    if (!value.target || value.target.length > 100_000)
+        throw new Error("landscape delivery target is invalid");
+    if (value.resources.length + value.relationships.length > MAX_FRAGMENT_ITEMS) {
+        throw new Error("landscape delivery fragment exceeds its item cap");
+    }
+    const resourceIds = new Set();
+    const ranks = new Set();
+    const selectionRanks = new Set();
+    for (const item of value.resources) {
+        ResourceSchema.parse(item.record);
+        if (!reviewedCurrent(item.record)) {
+            throw new Error("landscape delivery contains a non-reviewed resource");
+        }
+        if (resourceIds.has(item.record.id))
+            throw new Error("landscape delivery resource is duplicated");
+        resourceIds.add(item.record.id);
+        if (!Number.isSafeInteger(item.rank) || item.rank < 1 || ranks.has(item.rank))
+            throw new Error("landscape delivery rank is invalid");
+        ranks.add(item.rank);
+        if (!Number.isSafeInteger(item.selectionRank) || item.selectionRank < 1 || selectionRanks.has(item.selectionRank)
+            || !["exact-target", "task-match", "orientation-root", "graph-neighbor"].includes(item.selectionReason)) {
+            throw new Error("landscape delivery resource selection receipt is invalid");
+        }
+        selectionRanks.add(item.selectionRank);
+        if (item.deliveryReason !== "ranked" || item.required !== false || item.blocking !== false
+            || item.provenanceStatus !== "current" || !Number.isSafeInteger(item.tokenCost) || item.tokenCost < 1) {
+            throw new Error("landscape delivery resource receipt is invalid");
+        }
+    }
+    const relationshipIds = new Set();
+    for (const item of value.relationships) {
+        EdgeSchema.parse(item.record);
+        if (!reviewedCurrent(item.record) || !resourceIds.has(item.record.from) || !resourceIds.has(item.record.to)) {
+            throw new Error("landscape delivery relationship lacks reviewed delivered endpoints");
+        }
+        if (relationshipIds.has(item.record.id))
+            throw new Error("landscape delivery relationship is duplicated");
+        relationshipIds.add(item.record.id);
+        if (!Number.isSafeInteger(item.rank) || item.rank < 1 || ranks.has(item.rank))
+            throw new Error("landscape delivery rank is invalid");
+        ranks.add(item.rank);
+        if (!Number.isSafeInteger(item.selectionRank) || item.selectionRank < 1 || selectionRanks.has(item.selectionRank)
+            || item.selectionReason !== "graph-connection") {
+            throw new Error("landscape delivery relationship selection receipt is invalid");
+        }
+        selectionRanks.add(item.selectionRank);
+        if (item.deliveryReason !== "ranked" || item.required !== false || item.blocking !== false
+            || item.provenanceStatus !== "current" || !Number.isSafeInteger(item.tokenCost) || item.tokenCost < 1) {
+            throw new Error("landscape delivery relationship receipt is invalid");
+        }
+    }
+    if (value.omitted.length > MAX_FRAGMENT_OMISSIONS + MAX_FRAGMENT_ITEMS) {
+        throw new Error("landscape delivery omission evidence is unbounded");
+    }
+    const omissionKeys = new Set();
+    for (const item of value.omitted) {
+        const key = `${item.kind}:${item.recordId}:${item.reason}`;
+        if (!item.recordId || !item.detail || omissionKeys.has(key)
+            || !["budget", "stale-provenance", "endpoint-not-delivered", "landscape-cap"].includes(item.reason)) {
+            throw new Error("landscape delivery omission receipt is invalid");
+        }
+        omissionKeys.add(key);
+    }
+    for (const reviewId of value.reviewIds)
+        if (!REVIEW_ID.test(reviewId))
+            throw new Error("landscape delivery review id is invalid");
+    for (const discoveryHash of value.discoveryHashes)
+        if (!SHA256.test(discoveryHash))
+            throw new Error("landscape delivery discovery hash is invalid");
+    for (const revision of value.sourceRevisions)
+        if (!/^[a-f0-9]{40,64}$/.test(revision))
+            throw new Error("landscape delivery revision is invalid");
+    const deliveredRecords = [
+        ...value.resources.map((item) => item.record),
+        ...value.relationships.map((item) => item.record),
+    ];
+    const expectedReviewIds = stringsFromMetadata(deliveredRecords, "landscape_review_id");
+    const expectedDiscoveryHashes = stringsFromMetadata(deliveredRecords, "landscape_discovery_hash");
+    const expectedSourceRevisions = [...new Set(deliveredRecords
+            .map((record) => record.currentness?.source_revision)
+            .filter((revision) => typeof revision === "string"))]
+        .sort(compareCodeUnits);
+    if (canonical(value.reviewIds) !== canonical(expectedReviewIds)
+        || canonical(value.discoveryHashes) !== canonical(expectedDiscoveryHashes)
+        || canonical(value.sourceRevisions) !== canonical(expectedSourceRevisions)) {
+        throw new Error("landscape delivery evidence summary does not match its delivered records");
+    }
+    const { fragmentHash, ...unsigned } = value;
+    if (!SHA256.test(fragmentHash) || fragmentHash !== landscapeFragmentHash(unsigned)) {
+        throw new Error("landscape delivery fragment failed its content hash");
+    }
+}
+//# sourceMappingURL=landscapeDelivery.js.map