@velum-labs/routekit-eval-setup 1.3.2 → 1.5.0

package/dist/repository-specification-contract-facts-protocol.d.ts

@@ -0,0 +1,224 @@
+import { Schema } from "effect";
+import { type RepositorySpecificationReferenceScopeV1 } from "./repository-specification-critique-protocol.js";
+export declare const REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_FACTS = 64;
+export declare const REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_MEMBERS = 128;
+export declare const REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_QUESTIONS = 16;
+export declare const REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_PUBLIC_BYTES: number;
+export declare const RepositorySpecificationPublicContractFactV1: Schema.Union<readonly [Schema.Struct<{
+    kind: Schema.Literal<"behavior">;
+    statement: Schema.String;
+    id: Schema.String;
+    scopeId: Schema.String;
+}>, Schema.Struct<{
+    kind: Schema.Literal<"closed-set">;
+    subject: Schema.String;
+    appliesWhen: Schema.String;
+    members: Schema.$Array<Schema.String>;
+    outsideBehavior: Schema.String;
+    id: Schema.String;
+    scopeId: Schema.String;
+}>, Schema.Struct<{
+    kind: Schema.Literal<"eligibility">;
+    condition: Schema.String;
+    whenEligible: Schema.String;
+    whenIneligible: Schema.String;
+    id: Schema.String;
+    scopeId: Schema.String;
+}>]>;
+export type RepositorySpecificationPublicContractFactV1 = typeof RepositorySpecificationPublicContractFactV1.Type;
+export declare const RepositorySpecificationPrivateContractFactV1: Schema.Union<readonly [Schema.Struct<{
+    readonly evidence: Schema.$Array<Schema.Struct<{
+        readonly sourceId: Schema.String;
+        readonly startLine: Schema.Finite;
+        readonly endLine: Schema.Finite;
+    }>>;
+    readonly kind: Schema.Literal<"behavior">;
+    readonly statement: Schema.String;
+    readonly id: Schema.String;
+    readonly scopeId: Schema.String;
+}>, Schema.Struct<{
+    readonly evidence: Schema.$Array<Schema.Struct<{
+        readonly sourceId: Schema.String;
+        readonly startLine: Schema.Finite;
+        readonly endLine: Schema.Finite;
+    }>>;
+    readonly kind: Schema.Literal<"closed-set">;
+    readonly subject: Schema.String;
+    readonly appliesWhen: Schema.String;
+    readonly members: Schema.$Array<Schema.String>;
+    readonly outsideBehavior: Schema.String;
+    readonly id: Schema.String;
+    readonly scopeId: Schema.String;
+}>, Schema.Struct<{
+    readonly evidence: Schema.$Array<Schema.Struct<{
+        readonly sourceId: Schema.String;
+        readonly startLine: Schema.Finite;
+        readonly endLine: Schema.Finite;
+    }>>;
+    readonly kind: Schema.Literal<"eligibility">;
+    readonly condition: Schema.String;
+    readonly whenEligible: Schema.String;
+    readonly whenIneligible: Schema.String;
+    readonly id: Schema.String;
+    readonly scopeId: Schema.String;
+}>]>;
+export type RepositorySpecificationPrivateContractFactV1 = typeof RepositorySpecificationPrivateContractFactV1.Type;
+/** A model proposal, never an assertion of independent verification. */
+export declare const RepositorySpecificationContractFactsProposalV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly facts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            readonly sourceId: Schema.String;
+            readonly startLine: Schema.Finite;
+            readonly endLine: Schema.Finite;
+        }>>;
+        readonly kind: Schema.Literal<"behavior">;
+        readonly statement: Schema.String;
+        readonly id: Schema.String;
+        readonly scopeId: Schema.String;
+    }>, Schema.Struct<{
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            readonly sourceId: Schema.String;
+            readonly startLine: Schema.Finite;
+            readonly endLine: Schema.Finite;
+        }>>;
+        readonly kind: Schema.Literal<"closed-set">;
+        readonly subject: Schema.String;
+        readonly appliesWhen: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+        readonly outsideBehavior: Schema.String;
+        readonly id: Schema.String;
+        readonly scopeId: Schema.String;
+    }>, Schema.Struct<{
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            readonly sourceId: Schema.String;
+            readonly startLine: Schema.Finite;
+            readonly endLine: Schema.Finite;
+        }>>;
+        readonly kind: Schema.Literal<"eligibility">;
+        readonly condition: Schema.String;
+        readonly whenEligible: Schema.String;
+        readonly whenIneligible: Schema.String;
+        readonly id: Schema.String;
+        readonly scopeId: Schema.String;
+    }>]>>;
+}>;
+export type RepositorySpecificationContractFactsProposalV1 = typeof RepositorySpecificationContractFactsProposalV1.Type;
+export declare const RepositorySpecificationContractFactQuestionV1: Schema.Struct<{
+    readonly scopeId: Schema.String;
+    readonly factIds: Schema.$Array<Schema.String>;
+    readonly reason: Schema.Literals<readonly ["missing-boundary", "incomplete-set", "contradictory-fact", "unavailable-context"]>;
+    readonly question: Schema.String;
+}>;
+export type RepositorySpecificationContractFactQuestionV1 = typeof RepositorySpecificationContractFactQuestionV1.Type;
+export type RepositorySpecificationContractFactClarificationRequestV1 = RepositorySpecificationContractFactQuestionV1 & {
+    readonly requestId: string;
+};
+export declare const RepositorySpecificationContractFactClarificationV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly facts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            readonly sourceId: Schema.String;
+            readonly startLine: Schema.Finite;
+            readonly endLine: Schema.Finite;
+        }>>;
+        readonly kind: Schema.Literal<"behavior">;
+        readonly statement: Schema.String;
+        readonly id: Schema.String;
+        readonly scopeId: Schema.String;
+    }>, Schema.Struct<{
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            readonly sourceId: Schema.String;
+            readonly startLine: Schema.Finite;
+            readonly endLine: Schema.Finite;
+        }>>;
+        readonly kind: Schema.Literal<"closed-set">;
+        readonly subject: Schema.String;
+        readonly appliesWhen: Schema.String;
+        readonly members: Schema.$Array<Schema.String>;
+        readonly outsideBehavior: Schema.String;
+        readonly id: Schema.String;
+        readonly scopeId: Schema.String;
+    }>, Schema.Struct<{
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            readonly sourceId: Schema.String;
+            readonly startLine: Schema.Finite;
+            readonly endLine: Schema.Finite;
+        }>>;
+        readonly kind: Schema.Literal<"eligibility">;
+        readonly condition: Schema.String;
+        readonly whenEligible: Schema.String;
+        readonly whenIneligible: Schema.String;
+        readonly id: Schema.String;
+        readonly scopeId: Schema.String;
+    }>]>>;
+    readonly resolutions: Schema.$Array<Schema.Struct<{
+        readonly requestId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["answered", "unresolved"]>;
+        readonly factIds: Schema.$Array<Schema.String>;
+        readonly detail: Schema.String;
+    }>>;
+}>;
+export type RepositorySpecificationContractFactClarificationV1 = typeof RepositorySpecificationContractFactClarificationV1.Type;
+/**
+ * A uses empty evidence arrays and judges solver-visible sufficiency. B derives
+ * the necessary distinctions independently from private evidence and checks
+ * completeness, including omitted alternatives and outside-set behavior.
+ */
+export declare const RepositorySpecificationContractFactReviewV1: Schema.Struct<{
+    readonly packetDigest: Schema.String;
+    readonly scopeChecks: Schema.$Array<Schema.Struct<{
+        readonly scopeId: Schema.String;
+        readonly factIds: Schema.$Array<Schema.String>;
+        readonly outcome: Schema.Literals<readonly ["complete", "missing-facts", "contradictory", "uncertain"]>;
+        readonly detail: Schema.String;
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            readonly sourceId: Schema.String;
+            readonly startLine: Schema.Finite;
+            readonly endLine: Schema.Finite;
+        }>>;
+    }>>;
+    readonly clarificationRequests: Schema.$Array<Schema.Struct<{
+        readonly scopeId: Schema.String;
+        readonly factIds: Schema.$Array<Schema.String>;
+        readonly reason: Schema.Literals<readonly ["missing-boundary", "incomplete-set", "contradictory-fact", "unavailable-context"]>;
+        readonly question: Schema.String;
+    }>>;
+}>;
+export type RepositorySpecificationContractFactReviewV1 = typeof RepositorySpecificationContractFactReviewV1.Type;
+export type RepositorySpecificationContractFactsPacketV1 = {
+    readonly version: 1;
+    readonly scopeDigest: string;
+    readonly digest: string;
+    readonly facts: readonly RepositorySpecificationPublicContractFactV1[];
+};
+export type RepositorySpecificationContractFactsHistoryEntryV1 = {
+    readonly sequence: number;
+    readonly packetDigest: string;
+    readonly analystOperationId: string;
+    readonly clarificationRequestIds: readonly string[];
+};
+/**
+ * Returned only after two fresh reviews of the exact assembled visible task.
+ * This is specification evidence, not a benchmark admission.
+ */
+export type RepositorySpecificationAcceptedContractFactsV1 = {
+    readonly version: 1;
+    readonly packet: RepositorySpecificationContractFactsPacketV1;
+    readonly independentlyReviewed: true;
+    readonly reviewerOperationIds: readonly [string, string];
+    readonly history: readonly RepositorySpecificationContractFactsHistoryEntryV1[];
+};
+export declare const parseRepositorySpecificationContractFactsProposalV1: (value: unknown) => RepositorySpecificationContractFactsProposalV1;
+/** Positive projection: no provenance, arbitrary metadata, or model status survives. */
+export declare const repositorySpecificationPublicContractFactV1: (fact: RepositorySpecificationPrivateContractFactV1) => RepositorySpecificationPublicContractFactV1;
+export declare const renderRepositorySpecificationContractFactV1: (fact: RepositorySpecificationPublicContractFactV1) => string;
+/** Same scope identities and seed obligations; clarification cannot select another task. */
+export declare const repositorySpecificationContractFactsScopeV1: (scope: RepositorySpecificationReferenceScopeV1, proposal: RepositorySpecificationContractFactsProposalV1) => RepositorySpecificationReferenceScopeV1;
+export declare const repositorySpecificationContractFactsPacketV1: (scope: RepositorySpecificationReferenceScopeV1, proposal: RepositorySpecificationContractFactsProposalV1) => RepositorySpecificationContractFactsPacketV1;
+/**
+ * Structural and exact-digest revalidation for generation/finalization. The
+ * supplied scope is the FINAL scope containing rendered facts, not the original
+ * analyst prose. This does not replace either independent semantic review.
+ */
+export declare const parseRepositorySpecificationContractFactsPacketV1: (value: unknown, scope: RepositorySpecificationReferenceScopeV1) => RepositorySpecificationContractFactsPacketV1;

package/dist/repository-specification-contract-facts-protocol.js

@@ -0,0 +1,276 @@
+import { createHash } from "node:crypto";
+import { Schema } from "effect";
+import { RepositorySpecificationReferenceEvidenceV1 } from "./repository-specification-critique-protocol.js";
+export const REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_FACTS = 64;
+export const REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_MEMBERS = 128;
+export const REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_QUESTIONS = 16;
+export const REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_PUBLIC_BYTES = 32 * 1024;
+const identity = { id: Schema.String, scopeId: Schema.String };
+const behavior = { ...identity, kind: Schema.Literal("behavior"), statement: Schema.String };
+const closedSet = {
+    ...identity,
+    kind: Schema.Literal("closed-set"),
+    subject: Schema.String,
+    appliesWhen: Schema.String,
+    members: Schema.Array(Schema.String),
+    outsideBehavior: Schema.String
+};
+const eligibility = {
+    ...identity,
+    kind: Schema.Literal("eligibility"),
+    condition: Schema.String,
+    whenEligible: Schema.String,
+    whenIneligible: Schema.String
+};
+const evidence = Schema.Array(RepositorySpecificationReferenceEvidenceV1.annotate({
+    parseOptions: { onExcessProperty: "error" }
+}));
+export const RepositorySpecificationPublicContractFactV1 = Schema.Union([
+    Schema.Struct(behavior).annotate({ parseOptions: { onExcessProperty: "error" } }),
+    Schema.Struct(closedSet).annotate({ parseOptions: { onExcessProperty: "error" } }),
+    Schema.Struct(eligibility).annotate({ parseOptions: { onExcessProperty: "error" } })
+]);
+export const RepositorySpecificationPrivateContractFactV1 = Schema.Union([
+    Schema.Struct({ ...behavior, evidence }).annotate({
+        parseOptions: { onExcessProperty: "error" }
+    }),
+    Schema.Struct({ ...closedSet, evidence }).annotate({
+        parseOptions: { onExcessProperty: "error" }
+    }),
+    Schema.Struct({ ...eligibility, evidence }).annotate({
+        parseOptions: { onExcessProperty: "error" }
+    })
+]);
+/** A model proposal, never an assertion of independent verification. */
+export const RepositorySpecificationContractFactsProposalV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    facts: Schema.Array(RepositorySpecificationPrivateContractFactV1)
+}).annotate({ parseOptions: { onExcessProperty: "error" } });
+export const RepositorySpecificationContractFactQuestionV1 = Schema.Struct({
+    scopeId: Schema.String,
+    factIds: Schema.Array(Schema.String),
+    reason: Schema.Literals([
+        "missing-boundary",
+        "incomplete-set",
+        "contradictory-fact",
+        "unavailable-context"
+    ]),
+    question: Schema.String
+}).annotate({ parseOptions: { onExcessProperty: "error" } });
+export const RepositorySpecificationContractFactClarificationV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    facts: Schema.Array(RepositorySpecificationPrivateContractFactV1),
+    resolutions: Schema.Array(Schema.Struct({
+        requestId: Schema.String,
+        outcome: Schema.Literals(["answered", "unresolved"]),
+        factIds: Schema.Array(Schema.String),
+        detail: Schema.String
+    }).annotate({ parseOptions: { onExcessProperty: "error" } }))
+}).annotate({ parseOptions: { onExcessProperty: "error" } });
+/**
+ * A uses empty evidence arrays and judges solver-visible sufficiency. B derives
+ * the necessary distinctions independently from private evidence and checks
+ * completeness, including omitted alternatives and outside-set behavior.
+ */
+export const RepositorySpecificationContractFactReviewV1 = Schema.Struct({
+    packetDigest: Schema.String,
+    scopeChecks: Schema.Array(Schema.Struct({
+        scopeId: Schema.String,
+        factIds: Schema.Array(Schema.String),
+        outcome: Schema.Literals(["complete", "missing-facts", "contradictory", "uncertain"]),
+        detail: Schema.String,
+        evidence
+    }).annotate({ parseOptions: { onExcessProperty: "error" } })),
+    clarificationRequests: Schema.Array(RepositorySpecificationContractFactQuestionV1)
+}).annotate({ parseOptions: { onExcessProperty: "error" } });
+const identifier = (value) => /^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/u.test(value);
+const text = (value, maximum = 2_000) => value.length > 0 &&
+    value.length <= maximum &&
+    value === value.trim() &&
+    !value.includes("\0") &&
+    !value.includes("private-contract-fact-question-");
+const unique = (values) => new Set(values).size === values.length;
+const fail = (condition, detail) => {
+    if (!condition)
+        throw new Error(`specification contract facts: ${detail}`);
+};
+const assertPublicFact = (fact) => {
+    fail(identifier(fact.id) && identifier(fact.scopeId), "fact or scope identity is invalid");
+    switch (fact.kind) {
+        case "behavior":
+            fail(text(fact.statement), "behavior statement is invalid");
+            break;
+        case "closed-set":
+            fail(text(fact.subject) &&
+                text(fact.appliesWhen) &&
+                text(fact.outsideBehavior) &&
+                fact.members.length > 0 &&
+                fact.members.length <= REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_MEMBERS &&
+                fact.members.every((member) => text(member, 256)) &&
+                unique(fact.members), "closed set must name its applicability, complete members, and outside behavior");
+            break;
+        case "eligibility":
+            fail(text(fact.condition) && text(fact.whenEligible) && text(fact.whenIneligible), "eligibility must state both sides of its boundary");
+            break;
+    }
+};
+export const parseRepositorySpecificationContractFactsProposalV1 = (value) => {
+    const proposal = Schema.decodeUnknownSync(RepositorySpecificationContractFactsProposalV1, {
+        onExcessProperty: "error"
+    })(value);
+    fail(proposal.facts.length > 0 &&
+        proposal.facts.length <= REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_FACTS &&
+        unique(proposal.facts.map((fact) => fact.id)), "fact identities or count are invalid");
+    for (const fact of proposal.facts) {
+        assertPublicFact(fact);
+        fail(fact.evidence.length > 0 &&
+            fact.evidence.length <= 8 &&
+            fact.evidence.every((entry) => identifier(entry.sourceId) &&
+                Number.isSafeInteger(entry.startLine) &&
+                Number.isSafeInteger(entry.endLine) &&
+                entry.startLine > 0 &&
+                entry.endLine >= entry.startLine), "fact requires bounded source evidence");
+    }
+    return proposal;
+};
+/** Positive projection: no provenance, arbitrary metadata, or model status survives. */
+export const repositorySpecificationPublicContractFactV1 = (fact) => {
+    switch (fact.kind) {
+        case "behavior":
+            return { id: fact.id, scopeId: fact.scopeId, kind: fact.kind, statement: fact.statement };
+        case "closed-set":
+            return {
+                id: fact.id,
+                scopeId: fact.scopeId,
+                kind: fact.kind,
+                subject: fact.subject,
+                appliesWhen: fact.appliesWhen,
+                members: [...fact.members],
+                outsideBehavior: fact.outsideBehavior
+            };
+        case "eligibility":
+            return {
+                id: fact.id,
+                scopeId: fact.scopeId,
+                kind: fact.kind,
+                condition: fact.condition,
+                whenEligible: fact.whenEligible,
+                whenIneligible: fact.whenIneligible
+            };
+    }
+};
+export const renderRepositorySpecificationContractFactV1 = (fact) => {
+    switch (fact.kind) {
+        case "behavior":
+            return `For this task: ${fact.statement}`;
+        case "closed-set":
+            return `For this task, ${fact.subject}. Applicability: ${fact.appliesWhen}. The complete set is: ${fact.members.map((member) => JSON.stringify(member)).join(", ")}. Outside this set: ${fact.outsideBehavior}`;
+        case "eligibility":
+            return `For this task, eligibility is: ${fact.condition}. When eligible: ${fact.whenEligible}. When ineligible: ${fact.whenIneligible}`;
+    }
+};
+/** Same scope identities and seed obligations; clarification cannot select another task. */
+export const repositorySpecificationContractFactsScopeV1 = (scope, proposal) => {
+    const scopeIds = scope.clauses.map((clause) => clause.id);
+    fail(scopeIds.length > 0 &&
+        scopeIds.length <= 32 &&
+        unique(scopeIds) &&
+        proposal.facts.every((fact) => scopeIds.includes(fact.scopeId)) &&
+        scopeIds.every((id) => proposal.facts.some((fact) => fact.scopeId === id)), "every frozen scope requires facts and unknown scopes are forbidden");
+    return {
+        clauses: scope.clauses.map((clause) => {
+            const facts = proposal.facts.filter((fact) => fact.scopeId === clause.id);
+            const references = [...clause.evidence, ...facts.flatMap((fact) => fact.evidence)];
+            return {
+                id: clause.id,
+                kind: clause.kind,
+                behaviorIds: [...clause.behaviorIds],
+                description: [
+                    clause.description,
+                    ...facts.map((fact) => renderRepositorySpecificationContractFactV1(repositorySpecificationPublicContractFactV1(fact)))
+                ].join("\n"),
+                evidence: references.filter((entry, index) => references.findIndex((other) => other.sourceId === entry.sourceId &&
+                    other.startLine === entry.startLine &&
+                    other.endLine === entry.endLine) === index)
+            };
+        }),
+        unresolvedQuestions: [...scope.unresolvedQuestions]
+    };
+};
+const canonicalJson = (value) => {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
+            .join(",")}}`;
+    }
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined)
+        throw new Error("specification contract facts require JSON data");
+    return encoded;
+};
+const digest = (value) => createHash("sha256").update(canonicalJson(value)).digest("hex");
+const freeze = (value) => {
+    if (value !== null && typeof value === "object") {
+        for (const child of Object.values(value))
+            freeze(child);
+        Object.freeze(value);
+    }
+    return value;
+};
+export const repositorySpecificationContractFactsPacketV1 = (scope, proposal) => {
+    const facts = proposal.facts.map(repositorySpecificationPublicContractFactV1);
+    const publicScope = scope.clauses.map((clause) => ({
+        id: clause.id,
+        kind: clause.kind,
+        behaviorIds: [...clause.behaviorIds],
+        description: clause.description
+    }));
+    const unsigned = { version: 1, scopeDigest: digest(publicScope), facts };
+    const packet = { ...unsigned, digest: digest(unsigned) };
+    fail(Buffer.byteLength(JSON.stringify({ packet, behavioralScope: publicScope })) <=
+        REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_PUBLIC_BYTES, "complete public facts and scope exceed 32768 bytes; no facts were truncated");
+    return freeze(packet);
+};
+/**
+ * Structural and exact-digest revalidation for generation/finalization. The
+ * supplied scope is the FINAL scope containing rendered facts, not the original
+ * analyst prose. This does not replace either independent semantic review.
+ */
+export const parseRepositorySpecificationContractFactsPacketV1 = (value, scope) => {
+    const parsed = Schema.decodeUnknownSync(Schema.Struct({
+        version: Schema.Literal(1),
+        scopeDigest: Schema.String,
+        digest: Schema.String,
+        facts: Schema.Array(RepositorySpecificationPublicContractFactV1)
+    }), { onExcessProperty: "error" })(value);
+    fail(parsed.facts.length > 0 &&
+        parsed.facts.length <= REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_FACTS &&
+        unique(parsed.facts.map((fact) => fact.id)), "public fact identities or count are invalid");
+    parsed.facts.forEach(assertPublicFact);
+    const publicScope = scope.clauses.map((clause) => ({
+        id: clause.id,
+        kind: clause.kind,
+        behaviorIds: [...clause.behaviorIds],
+        description: clause.description
+    }));
+    fail(publicScope.length > 0 &&
+        publicScope.length <= 32 &&
+        unique(publicScope.map((clause) => clause.id)) &&
+        publicScope.every((clause) => parsed.facts.some((fact) => fact.scopeId === clause.id)) &&
+        parsed.facts.every((fact) => publicScope.some((clause) => clause.id === fact.scopeId &&
+            clause.description.includes(renderRepositorySpecificationContractFactV1(fact)))), "public facts do not cover the exact rendered scope");
+    const unsigned = {
+        version: 1,
+        scopeDigest: digest(publicScope),
+        facts: parsed.facts
+    };
+    fail(parsed.scopeDigest === unsigned.scopeDigest &&
+        parsed.digest === digest(unsigned) &&
+        Buffer.byteLength(JSON.stringify({ packet: parsed, behavioralScope: publicScope })) <=
+            REPOSITORY_SPECIFICATION_CONTRACT_FACTS_MAXIMUM_PUBLIC_BYTES, "public fact packet digest, final scope, or size is invalid");
+    return freeze(parsed);
+};