niceeval 0.12.2-canary.31 → 0.13.1

package/dist/assertions/record/model.d.mts

@@ -1,37 +1,38 @@
 import type { AssertionEntryId } from "../identity.mjs";
+import type { Sha256Digest } from "../../record/model/identifiers.mjs";
 /**
  * `entryId` is only stable inside one Assertions Attachment. It is not an
  * authoring key and deliberately has no cross-Attempt meaning.
  */
 export { ASSERTION_ENTRY_ID_BRAND, } from "../identity.mjs";
 export type { AssertionEntryId } from "../identity.mjs";
-export type BoundedJsonPrimitiveV1 = null | boolean | number | string;
-export interface BoundedJsonObjectV1 {
-    readonly [key: string]: BoundedJsonValueV1;
+export type BoundedJsonPrimitive = null | boolean | number | string;
+export interface BoundedJsonObject {
+    readonly [key: string]: BoundedJsonValue;
 }
 /** JSON-only material that is bounded by the Assertions v1 decoder. */
-export type BoundedJsonValueV1 = BoundedJsonPrimitiveV1 | readonly BoundedJsonValueV1[] | BoundedJsonObjectV1;
-export interface AssertionDisplayV1 {
+export type BoundedJsonValue = BoundedJsonPrimitive | readonly BoundedJsonValue[] | BoundedJsonObject;
+export interface AssertionDisplay {
     readonly key?: string;
     readonly label?: string;
     readonly groupPath: readonly string[];
 }
 /** The outer builtin shape deliberately preserves an unknown future id. */
-export interface BuiltInCriterionEnvelopeV1 {
+export interface BuiltInCriterionEnvelope {
     readonly kind: "builtin";
     readonly id: string;
-    readonly data: BoundedJsonValueV1;
+    readonly data: BoundedJsonValue;
 }
 /** Third-party data is exact JSON owned by the named third-party schema. */
-export interface ThirdPartyCriterionV1 {
+export interface ThirdPartyCriterion {
     readonly name: string;
     readonly schemaId: string;
-    readonly data: BoundedJsonValueV1;
+    readonly data: BoundedJsonValue;
 }
 /** Raw identity envelope used by the reader's second decode phase. */
-export type CriterionEnvelopeV1 = BuiltInCriterionEnvelopeV1 | ThirdPartyCriterionV1;
-export type CriterionOuterEnvelopeV1 = CriterionEnvelopeV1;
-export type BuiltInCriterionV1 = {
+export type CriterionEnvelope = BuiltInCriterionEnvelope | ThirdPartyCriterion;
+export type CriterionOuterEnvelope = CriterionEnvelope;
+export type BuiltInCriterion = {
     readonly kind: "builtin";
     readonly id: "value-match/v1";
     readonly data: {
@@ -115,29 +116,20 @@ export type BuiltInCriterionV1 = {
     };
 };
 /** A v1 writer may only emit a known builtin or a versioned third-party schema. */
-export type WritableCriterionEnvelopeV1 = BuiltInCriterionV1 | ThirdPartyCriterionV1;
-export type AssertionMaterialV1<BlobRef> = {
+export type WritableCriterionEnvelope = BuiltInCriterion | ThirdPartyCriterion;
+export type AssertionMaterial<BlobRef> = {
     readonly kind: "snapshot";
-    readonly value: BoundedJsonValueV1;
+    readonly value: BoundedJsonValue;
 } | {
     readonly kind: "blob";
     readonly ref: BlobRef;
     readonly encoding: "utf-8" | "binary";
     readonly byteLength: number;
-    readonly preview: string;
-}
-/**
- * An Assertion can name an exact, same-owner Attachment without receiving a
- * storage handle.  v1 deliberately exposes no hash, path, blob ref, or
- * evidence id here: the Evaluation Record contract verifies the matching
- * Attempt write before a complete marker can be published.
- */
- | {
-    readonly kind: "record-attachment";
-    readonly schemaId: "niceeval.diff/v1";
+    /** SHA-256 of the exact retained blob bytes. */
+    readonly sha256: Sha256Digest;
     readonly preview: string;
 };
-export type AssertionCoverageV1 = {
+export type AssertionCoverage = {
     readonly state: "complete";
 } | {
     readonly state: "partial";
@@ -149,7 +141,7 @@ export type AssertionCoverageV1 = {
     readonly state: "not-applicable";
     readonly reason: "optional-material" | "unsupported-subject";
 };
-export type AssertionLimitationV1 = {
+export type AssertionLimitation = {
     readonly kind: "redacted";
     readonly fieldCount: number;
 } | {
@@ -162,96 +154,96 @@ export type AssertionLimitationV1 = {
 } | {
     readonly kind: "provider-limited";
 };
-export type GateDispositionV1 = "not-gate" | "satisfied" | "failed" | "unavailable" | "not-applicable";
-export interface NoScoreContributionV1 {
+export type GateDisposition = "not-gate" | "satisfied" | "failed" | "unavailable" | "not-applicable";
+export interface NoScoreContribution {
     readonly state: "not-scored";
 }
-export interface EarnedScoreContributionV1 {
+export interface EarnedScoreContribution {
     readonly state: "earned";
     readonly points: number;
     readonly earned: number;
 }
-export interface UnavailableScoreContributionV1 {
+export interface UnavailableScoreContribution {
     readonly state: "unavailable";
     readonly points: number;
     readonly reason: "source-unavailable" | "evaluation-errored" | "not-applicable";
 }
-export type ScoreContributionV1 = NoScoreContributionV1 | EarnedScoreContributionV1 | UnavailableScoreContributionV1;
-export type SealedAssertionResultV1 = {
+export type ScoreContribution = NoScoreContribution | EarnedScoreContribution | UnavailableScoreContribution;
+export type SealedAssertionResult = {
     readonly state: "matched";
     readonly gate: "not-gate" | "satisfied";
-    readonly score: NoScoreContributionV1 | EarnedScoreContributionV1;
+    readonly score: NoScoreContribution | EarnedScoreContribution;
     /** Bounded evaluator diagnostics, including ToolMatch evidence paths. */
-    readonly diagnostic?: BoundedJsonObjectV1;
+    readonly diagnostic?: BoundedJsonObject;
 } | {
     readonly state: "mismatched";
     readonly reason: "condition-not-met";
     readonly gate: "not-gate" | "failed";
-    readonly score: NoScoreContributionV1 | EarnedScoreContributionV1;
-    readonly diagnostic?: BoundedJsonObjectV1;
+    readonly score: NoScoreContribution | EarnedScoreContribution;
+    readonly diagnostic?: BoundedJsonObject;
 } | {
     readonly state: "unavailable";
     readonly reason: "evidence-unavailable" | "source-unavailable" | "redacted";
     readonly gate: "not-gate" | "unavailable";
-    readonly score: NoScoreContributionV1 | UnavailableScoreContributionV1;
-    readonly diagnostic?: BoundedJsonObjectV1;
+    readonly score: NoScoreContribution | UnavailableScoreContribution;
+    readonly diagnostic?: BoundedJsonObject;
 } | {
     readonly state: "errored";
     readonly reason: "evaluator-failed" | "producer-interrupted" | "invalid-subject";
     readonly gate: "not-gate" | "unavailable";
-    readonly score: NoScoreContributionV1 | UnavailableScoreContributionV1;
-    readonly diagnostic?: BoundedJsonObjectV1;
+    readonly score: NoScoreContribution | UnavailableScoreContribution;
+    readonly diagnostic?: BoundedJsonObject;
 } | {
     readonly state: "not-applicable";
     readonly reason: "coverage-not-applicable";
     readonly gate: "not-gate" | "not-applicable";
-    readonly score: NoScoreContributionV1 | UnavailableScoreContributionV1;
-    readonly diagnostic?: BoundedJsonObjectV1;
+    readonly score: NoScoreContribution | UnavailableScoreContribution;
+    readonly diagnostic?: BoundedJsonObject;
 };
 /** The exact v1 value that a producer is allowed to seal. */
-export interface AssertionEntryV1<BlobRef> {
+export interface AssertionEntry<BlobRef> {
     readonly entryId: AssertionEntryId;
-    readonly display: AssertionDisplayV1;
-    readonly criterion: WritableCriterionEnvelopeV1;
-    readonly subject: AssertionMaterialV1<BlobRef>;
-    readonly evidence: readonly AssertionMaterialV1<BlobRef>[];
-    readonly coverage: AssertionCoverageV1;
-    readonly limitations: readonly AssertionLimitationV1[];
-    readonly result: SealedAssertionResultV1;
+    readonly display: AssertionDisplay;
+    readonly criterion: WritableCriterionEnvelope;
+    readonly subject: AssertionMaterial<BlobRef>;
+    readonly evidence: readonly AssertionMaterial<BlobRef>[];
+    readonly coverage: AssertionCoverage;
+    readonly limitations: readonly AssertionLimitation[];
+    readonly result: SealedAssertionResult;
 }
 /**
  * Reader framing intentionally leaves `criterion` as bounded JSON.  This
  * lets a bad plugin or future criterion affect its entry only after every
  * other entry boundary has already been verified.
  */
-export interface AssertionEntryOuterV1<BlobRef> {
+export interface AssertionEntryOuter<BlobRef> {
     readonly entryId: AssertionEntryId;
-    readonly display: AssertionDisplayV1;
-    readonly criterion: BoundedJsonObjectV1;
-    readonly subject: AssertionMaterialV1<BlobRef>;
-    readonly evidence: readonly AssertionMaterialV1<BlobRef>[];
-    readonly coverage: AssertionCoverageV1;
-    readonly limitations: readonly AssertionLimitationV1[];
-    readonly result: SealedAssertionResultV1;
+    readonly display: AssertionDisplay;
+    readonly criterion: BoundedJsonObject;
+    readonly subject: AssertionMaterial<BlobRef>;
+    readonly evidence: readonly AssertionMaterial<BlobRef>[];
+    readonly coverage: AssertionCoverage;
+    readonly limitations: readonly AssertionLimitation[];
+    readonly result: SealedAssertionResult;
 }
-export interface AssertionsDocumentV1<BlobRef> {
-    readonly entries: readonly AssertionEntryV1<BlobRef>[];
+export interface AssertionsDocument<BlobRef> {
+    readonly entries: readonly AssertionEntry<BlobRef>[];
 }
-export interface AssertionsDocumentOuterV1<BlobRef> {
-    readonly entries: readonly AssertionEntryOuterV1<BlobRef>[];
+export interface AssertionsDocumentOuter<BlobRef> {
+    readonly entries: readonly AssertionEntryOuter<BlobRef>[];
 }
-export type AssertionEntryReadV1<BlobRef> = {
+export type AssertionEntryRead<BlobRef> = {
     readonly state: "available";
-    readonly entry: AssertionEntryV1<BlobRef>;
+    readonly entry: AssertionEntry<BlobRef>;
 } | {
     readonly state: "unsupported";
-    readonly entry: AssertionEntryOuterV1<BlobRef>;
+    readonly entry: AssertionEntryOuter<BlobRef>;
     readonly reason: "builtin-unknown" | "third-party-schema-unavailable";
 } | {
     readonly state: "invalid";
-    readonly entry: AssertionEntryOuterV1<BlobRef>;
+    readonly entry: AssertionEntryOuter<BlobRef>;
     readonly reason: "criterion-envelope-invalid" | "criterion-data-invalid";
 };
-export interface AssertionsProjectionV1<BlobRef> {
-    readonly entries: readonly AssertionEntryReadV1<BlobRef>[];
+export interface AssertionsProjection<BlobRef> {
+    readonly entries: readonly AssertionEntryRead<BlobRef>[];
 }

package/dist/assertions/record/model.d.ts

@@ -1,37 +1,38 @@
 import type { AssertionEntryId } from "../identity.js";
+import type { Sha256Digest } from "../../record/model/identifiers.js";
 /**
  * `entryId` is only stable inside one Assertions Attachment. It is not an
  * authoring key and deliberately has no cross-Attempt meaning.
  */
 export { ASSERTION_ENTRY_ID_BRAND, } from "../identity.js";
 export type { AssertionEntryId } from "../identity.js";
-export type BoundedJsonPrimitiveV1 = null | boolean | number | string;
-export interface BoundedJsonObjectV1 {
-    readonly [key: string]: BoundedJsonValueV1;
+export type BoundedJsonPrimitive = null | boolean | number | string;
+export interface BoundedJsonObject {
+    readonly [key: string]: BoundedJsonValue;
 }
 /** JSON-only material that is bounded by the Assertions v1 decoder. */
-export type BoundedJsonValueV1 = BoundedJsonPrimitiveV1 | readonly BoundedJsonValueV1[] | BoundedJsonObjectV1;
-export interface AssertionDisplayV1 {
+export type BoundedJsonValue = BoundedJsonPrimitive | readonly BoundedJsonValue[] | BoundedJsonObject;
+export interface AssertionDisplay {
     readonly key?: string;
     readonly label?: string;
     readonly groupPath: readonly string[];
 }
 /** The outer builtin shape deliberately preserves an unknown future id. */
-export interface BuiltInCriterionEnvelopeV1 {
+export interface BuiltInCriterionEnvelope {
     readonly kind: "builtin";
     readonly id: string;
-    readonly data: BoundedJsonValueV1;
+    readonly data: BoundedJsonValue;
 }
 /** Third-party data is exact JSON owned by the named third-party schema. */
-export interface ThirdPartyCriterionV1 {
+export interface ThirdPartyCriterion {
     readonly name: string;
     readonly schemaId: string;
-    readonly data: BoundedJsonValueV1;
+    readonly data: BoundedJsonValue;
 }
 /** Raw identity envelope used by the reader's second decode phase. */
-export type CriterionEnvelopeV1 = BuiltInCriterionEnvelopeV1 | ThirdPartyCriterionV1;
-export type CriterionOuterEnvelopeV1 = CriterionEnvelopeV1;
-export type BuiltInCriterionV1 = {
+export type CriterionEnvelope = BuiltInCriterionEnvelope | ThirdPartyCriterion;
+export type CriterionOuterEnvelope = CriterionEnvelope;
+export type BuiltInCriterion = {
     readonly kind: "builtin";
     readonly id: "value-match/v1";
     readonly data: {
@@ -115,29 +116,20 @@ export type BuiltInCriterionV1 = {
     };
 };
 /** A v1 writer may only emit a known builtin or a versioned third-party schema. */
-export type WritableCriterionEnvelopeV1 = BuiltInCriterionV1 | ThirdPartyCriterionV1;
-export type AssertionMaterialV1<BlobRef> = {
+export type WritableCriterionEnvelope = BuiltInCriterion | ThirdPartyCriterion;
+export type AssertionMaterial<BlobRef> = {
     readonly kind: "snapshot";
-    readonly value: BoundedJsonValueV1;
+    readonly value: BoundedJsonValue;
 } | {
     readonly kind: "blob";
     readonly ref: BlobRef;
     readonly encoding: "utf-8" | "binary";
     readonly byteLength: number;
-    readonly preview: string;
-}
-/**
- * An Assertion can name an exact, same-owner Attachment without receiving a
- * storage handle.  v1 deliberately exposes no hash, path, blob ref, or
- * evidence id here: the Evaluation Record contract verifies the matching
- * Attempt write before a complete marker can be published.
- */
- | {
-    readonly kind: "record-attachment";
-    readonly schemaId: "niceeval.diff/v1";
+    /** SHA-256 of the exact retained blob bytes. */
+    readonly sha256: Sha256Digest;
     readonly preview: string;
 };
-export type AssertionCoverageV1 = {
+export type AssertionCoverage = {
     readonly state: "complete";
 } | {
     readonly state: "partial";
@@ -149,7 +141,7 @@ export type AssertionCoverageV1 = {
     readonly state: "not-applicable";
     readonly reason: "optional-material" | "unsupported-subject";
 };
-export type AssertionLimitationV1 = {
+export type AssertionLimitation = {
     readonly kind: "redacted";
     readonly fieldCount: number;
 } | {
@@ -162,96 +154,96 @@ export type AssertionLimitationV1 = {
 } | {
     readonly kind: "provider-limited";
 };
-export type GateDispositionV1 = "not-gate" | "satisfied" | "failed" | "unavailable" | "not-applicable";
-export interface NoScoreContributionV1 {
+export type GateDisposition = "not-gate" | "satisfied" | "failed" | "unavailable" | "not-applicable";
+export interface NoScoreContribution {
     readonly state: "not-scored";
 }
-export interface EarnedScoreContributionV1 {
+export interface EarnedScoreContribution {
     readonly state: "earned";
     readonly points: number;
     readonly earned: number;
 }
-export interface UnavailableScoreContributionV1 {
+export interface UnavailableScoreContribution {
     readonly state: "unavailable";
     readonly points: number;
     readonly reason: "source-unavailable" | "evaluation-errored" | "not-applicable";
 }
-export type ScoreContributionV1 = NoScoreContributionV1 | EarnedScoreContributionV1 | UnavailableScoreContributionV1;
-export type SealedAssertionResultV1 = {
+export type ScoreContribution = NoScoreContribution | EarnedScoreContribution | UnavailableScoreContribution;
+export type SealedAssertionResult = {
     readonly state: "matched";
     readonly gate: "not-gate" | "satisfied";
-    readonly score: NoScoreContributionV1 | EarnedScoreContributionV1;
+    readonly score: NoScoreContribution | EarnedScoreContribution;
     /** Bounded evaluator diagnostics, including ToolMatch evidence paths. */
-    readonly diagnostic?: BoundedJsonObjectV1;
+    readonly diagnostic?: BoundedJsonObject;
 } | {
     readonly state: "mismatched";
     readonly reason: "condition-not-met";
     readonly gate: "not-gate" | "failed";
-    readonly score: NoScoreContributionV1 | EarnedScoreContributionV1;
-    readonly diagnostic?: BoundedJsonObjectV1;
+    readonly score: NoScoreContribution | EarnedScoreContribution;
+    readonly diagnostic?: BoundedJsonObject;
 } | {
     readonly state: "unavailable";
     readonly reason: "evidence-unavailable" | "source-unavailable" | "redacted";
     readonly gate: "not-gate" | "unavailable";
-    readonly score: NoScoreContributionV1 | UnavailableScoreContributionV1;
-    readonly diagnostic?: BoundedJsonObjectV1;
+    readonly score: NoScoreContribution | UnavailableScoreContribution;
+    readonly diagnostic?: BoundedJsonObject;
 } | {
     readonly state: "errored";
     readonly reason: "evaluator-failed" | "producer-interrupted" | "invalid-subject";
     readonly gate: "not-gate" | "unavailable";
-    readonly score: NoScoreContributionV1 | UnavailableScoreContributionV1;
-    readonly diagnostic?: BoundedJsonObjectV1;
+    readonly score: NoScoreContribution | UnavailableScoreContribution;
+    readonly diagnostic?: BoundedJsonObject;
 } | {
     readonly state: "not-applicable";
     readonly reason: "coverage-not-applicable";
     readonly gate: "not-gate" | "not-applicable";
-    readonly score: NoScoreContributionV1 | UnavailableScoreContributionV1;
-    readonly diagnostic?: BoundedJsonObjectV1;
+    readonly score: NoScoreContribution | UnavailableScoreContribution;
+    readonly diagnostic?: BoundedJsonObject;
 };
 /** The exact v1 value that a producer is allowed to seal. */
-export interface AssertionEntryV1<BlobRef> {
+export interface AssertionEntry<BlobRef> {
     readonly entryId: AssertionEntryId;
-    readonly display: AssertionDisplayV1;
-    readonly criterion: WritableCriterionEnvelopeV1;
-    readonly subject: AssertionMaterialV1<BlobRef>;
-    readonly evidence: readonly AssertionMaterialV1<BlobRef>[];
-    readonly coverage: AssertionCoverageV1;
-    readonly limitations: readonly AssertionLimitationV1[];
-    readonly result: SealedAssertionResultV1;
+    readonly display: AssertionDisplay;
+    readonly criterion: WritableCriterionEnvelope;
+    readonly subject: AssertionMaterial<BlobRef>;
+    readonly evidence: readonly AssertionMaterial<BlobRef>[];
+    readonly coverage: AssertionCoverage;
+    readonly limitations: readonly AssertionLimitation[];
+    readonly result: SealedAssertionResult;
 }
 /**
  * Reader framing intentionally leaves `criterion` as bounded JSON.  This
  * lets a bad plugin or future criterion affect its entry only after every
  * other entry boundary has already been verified.
  */
-export interface AssertionEntryOuterV1<BlobRef> {
+export interface AssertionEntryOuter<BlobRef> {
     readonly entryId: AssertionEntryId;
-    readonly display: AssertionDisplayV1;
-    readonly criterion: BoundedJsonObjectV1;
-    readonly subject: AssertionMaterialV1<BlobRef>;
-    readonly evidence: readonly AssertionMaterialV1<BlobRef>[];
-    readonly coverage: AssertionCoverageV1;
-    readonly limitations: readonly AssertionLimitationV1[];
-    readonly result: SealedAssertionResultV1;
+    readonly display: AssertionDisplay;
+    readonly criterion: BoundedJsonObject;
+    readonly subject: AssertionMaterial<BlobRef>;
+    readonly evidence: readonly AssertionMaterial<BlobRef>[];
+    readonly coverage: AssertionCoverage;
+    readonly limitations: readonly AssertionLimitation[];
+    readonly result: SealedAssertionResult;
 }
-export interface AssertionsDocumentV1<BlobRef> {
-    readonly entries: readonly AssertionEntryV1<BlobRef>[];
+export interface AssertionsDocument<BlobRef> {
+    readonly entries: readonly AssertionEntry<BlobRef>[];
 }
-export interface AssertionsDocumentOuterV1<BlobRef> {
-    readonly entries: readonly AssertionEntryOuterV1<BlobRef>[];
+export interface AssertionsDocumentOuter<BlobRef> {
+    readonly entries: readonly AssertionEntryOuter<BlobRef>[];
 }
-export type AssertionEntryReadV1<BlobRef> = {
+export type AssertionEntryRead<BlobRef> = {
     readonly state: "available";
-    readonly entry: AssertionEntryV1<BlobRef>;
+    readonly entry: AssertionEntry<BlobRef>;
 } | {
     readonly state: "unsupported";
-    readonly entry: AssertionEntryOuterV1<BlobRef>;
+    readonly entry: AssertionEntryOuter<BlobRef>;
     readonly reason: "builtin-unknown" | "third-party-schema-unavailable";
 } | {
     readonly state: "invalid";
-    readonly entry: AssertionEntryOuterV1<BlobRef>;
+    readonly entry: AssertionEntryOuter<BlobRef>;
     readonly reason: "criterion-envelope-invalid" | "criterion-data-invalid";
 };
-export interface AssertionsProjectionV1<BlobRef> {
-    readonly entries: readonly AssertionEntryReadV1<BlobRef>[];
+export interface AssertionsProjection<BlobRef> {
+    readonly entries: readonly AssertionEntryRead<BlobRef>[];
 }

package/dist/assertions/record/producer.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAssertionsDocumentBuilderV1 = createAssertionsDocumentBuilderV1;
+exports.createAssertionsDocumentBuilder = createAssertionsDocumentBuilder;
 const effect_1 = require("effect");
 const codec_ts_1 = require("./codec.cjs");
 /**
@@ -8,7 +8,7 @@ const codec_ts_1 = require("./codec.cjs");
  * neither Record paths nor blob streams: the later Attachment adapter supplies
  * Record's local builder, so an entry cannot borrow another Attachment's ref.
  */
-function createAssertionsDocumentBuilderV1(input) {
+function createAssertionsDocumentBuilder(input) {
     const entryIds = new Set();
     const entries = [];
     let sealed;
@@ -42,6 +42,9 @@ function createAssertionsDocumentBuilderV1(input) {
             const document = Object.freeze({
                 entries: Object.freeze([...entries]),
             });
+            if (!(0, codec_ts_1.isAssertionsRawDataGraph)(document)) {
+                return effect_1.Either.left({ code: "assertions-document-invalid" });
+            }
             const encoded = effect_1.Schema.encodeUnknownEither(input.documentSchema, codec_ts_1.AssertionsExactParseOptions)(document);
             if (effect_1.Either.isLeft(encoded)) {
                 return effect_1.Either.left({ code: "assertions-document-invalid" });

package/dist/assertions/record/producer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"producer.js","sourceRoot":"","sources":["producer.ts"],"names":[],"mappings":";;AA0CA,8EA8CC;AAxFD,mCAAwC;AACxC,yCAAkF;AAoClF;;;;GAIG;AACH,SAAgB,iCAAiC,CAAmB,KAGnE;IACG,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IACnC,MAAM,OAAO,GAAgC,EAAE,CAAC;IAChD,IAAI,MAAiD,CAAC;IACtD,MAAM,OAAO,GAAyC;QAClD,MAAM,CAAC,KAAqC;YACxC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACvB,OAAO,eAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,4BAA4B,EAAE,CAAC,CAAC;YAC/D,CAAC;YACD,MAAM,WAAW,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;YAC1C,MAAM,OAAO,GAAG,eAAM,CAAC,mBAAmB,CAAC,iCAAsB,EAAE,sCAA2B,CAAC,CAAC,WAAW,CAAC,CAAC;YAC7G,IAAI,eAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;gBACzB,OAAO,eAAM,CAAC,IAAI,CAAC;oBACf,IAAI,EAAE,4BAA4B;oBAClC,OAAO,EAAE,WAAW;iBACvB,CAAC,CAAC;YACP,CAAC;YACD,IAAI,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC9B,OAAO,eAAM,CAAC,IAAI,CAAC;oBACf,IAAI,EAAE,8BAA8B;oBACpC,OAAO,EAAE,WAAW;iBACvB,CAAC,CAAC;YACP,CAAC;YACD,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC5B,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC;YAClE,OAAO,eAAM,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACvC,CAAC;QACD,IAAI;YACA,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACvB,OAAO,eAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAChC,CAAC;YACD,MAAM,QAAQ,GAAkC,MAAM,CAAC,MAAM,CAAC;gBAC1D,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;aACvC,CAAC,CAAC;YACH,MAAM,OAAO,GAAG,eAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC,cAAc,EAAE,sCAA2B,CAAC,CAAC,QAAQ,CAAC,CAAC;YACxG,IAAI,eAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;gBACzB,OAAO,eAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,6BAA6B,EAAE,CAAC,CAAC;YAChE,CAAC;YACD,MAAM,GAAG,QAAQ,CAAC;YAClB,OAAO,eAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAClC,CAAC;KACJ,CAAC;IACF,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAClC,CAAC","sourcesContent":["import { Either, Schema } from \"effect\";\nimport { AssertionEntryIdSchema, AssertionsExactParseOptions, } from \"./codec.ts\";\nimport type { AssertionDisplayV1, AssertionEntryId, AssertionEntryV1, AssertionLimitationV1, AssertionMaterialV1, AssertionCoverageV1, AssertionsDocumentV1, SealedAssertionResultV1, WritableCriterionEnvelopeV1, } from \"./model.ts\";\nexport interface AssertionEntryInputV1<BlobRef> {\n    readonly display: AssertionDisplayV1;\n    readonly criterion: WritableCriterionEnvelopeV1;\n    readonly subject: AssertionMaterialV1<BlobRef>;\n    readonly evidence: readonly AssertionMaterialV1<BlobRef>[];\n    readonly coverage: AssertionCoverageV1;\n    readonly limitations: readonly AssertionLimitationV1[];\n    readonly result: SealedAssertionResultV1;\n}\nexport interface AssertionsEntryIdSourceV1 {\n    /** Must return a fresh `ae_[a-z0-9]{20}` candidate for this Attachment. */\n    readonly next: () => string;\n}\nexport type AssertionsProducerErrorV1 = {\n    readonly code: \"assertion-entry-id-invalid\";\n    readonly entryId: string;\n} | {\n    readonly code: \"assertion-entry-id-duplicate\";\n    readonly entryId: string;\n} | {\n    readonly code: \"assertions-document-sealed\";\n} | {\n    readonly code: \"assertions-document-invalid\";\n};\nexport interface AssertionsDocumentBuilderV1<BlobRef> {\n    /** Appends exactly one completed Assertion in declaration/display order. */\n    readonly append: (entry: AssertionEntryInputV1<BlobRef>) => Either.Either<AssertionEntryId, AssertionsProducerErrorV1>;\n    /**\n     * Checks the writer-only exact document schema once and prevents subsequent\n     * appends. Repeated calls return the same sealed document without running\n     * an evaluator or minting another entry ID.\n     */\n    readonly seal: () => Either.Either<AssertionsDocumentV1<BlobRef>, AssertionsProducerErrorV1>;\n}\n/**\n * Assertion producers own normalization and ID allocation. This builder owns\n * neither Record paths nor blob streams: the later Attachment adapter supplies\n * Record's local builder, so an entry cannot borrow another Attachment's ref.\n */\nexport function createAssertionsDocumentBuilderV1<BlobRef, Encoded>(input: {\n    readonly documentSchema: Schema.Schema<AssertionsDocumentV1<BlobRef>, Encoded>;\n    readonly entryIds: AssertionsEntryIdSourceV1;\n}): AssertionsDocumentBuilderV1<BlobRef> {\n    const entryIds = new Set<string>();\n    const entries: AssertionEntryV1<BlobRef>[] = [];\n    let sealed: AssertionsDocumentV1<BlobRef> | undefined;\n    const builder: AssertionsDocumentBuilderV1<BlobRef> = {\n        append(entry: AssertionEntryInputV1<BlobRef>): Either.Either<AssertionEntryId, AssertionsProducerErrorV1> {\n            if (sealed !== undefined) {\n                return Either.left({ code: \"assertions-document-sealed\" });\n            }\n            const entryIdText = input.entryIds.next();\n            const entryId = Schema.decodeUnknownEither(AssertionEntryIdSchema, AssertionsExactParseOptions)(entryIdText);\n            if (Either.isLeft(entryId)) {\n                return Either.left({\n                    code: \"assertion-entry-id-invalid\",\n                    entryId: entryIdText,\n                });\n            }\n            if (entryIds.has(entryId.right)) {\n                return Either.left({\n                    code: \"assertion-entry-id-duplicate\",\n                    entryId: entryIdText,\n                });\n            }\n            entryIds.add(entryId.right);\n            entries.push(Object.freeze({ entryId: entryId.right, ...entry }));\n            return Either.right(entryId.right);\n        },\n        seal(): Either.Either<AssertionsDocumentV1<BlobRef>, AssertionsProducerErrorV1> {\n            if (sealed !== undefined) {\n                return Either.right(sealed);\n            }\n            const document: AssertionsDocumentV1<BlobRef> = Object.freeze({\n                entries: Object.freeze([...entries]),\n            });\n            const encoded = Schema.encodeUnknownEither(input.documentSchema, AssertionsExactParseOptions)(document);\n            if (Either.isLeft(encoded)) {\n                return Either.left({ code: \"assertions-document-invalid\" });\n            }\n            sealed = document;\n            return Either.right(document);\n        },\n    };\n    return Object.freeze(builder);\n}\n"]}
+{"version":3,"file":"producer.js","sourceRoot":"","sources":["producer.ts"],"names":[],"mappings":";;AA0CA,0EAiDC;AA3FD,mCAAwC;AACxC,yCAA4G;AAoC5G;;;;GAIG;AACH,SAAgB,+BAA+B,CAAmB,KAGjE;IACG,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IACnC,MAAM,OAAO,GAA8B,EAAE,CAAC;IAC9C,IAAI,MAA+C,CAAC;IACpD,MAAM,OAAO,GAAuC;QAChD,MAAM,CAAC,KAAmC;YACtC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACvB,OAAO,eAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,4BAA4B,EAAE,CAAC,CAAC;YAC/D,CAAC;YACD,MAAM,WAAW,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;YAC1C,MAAM,OAAO,GAAG,eAAM,CAAC,mBAAmB,CAAC,iCAAsB,EAAE,sCAA2B,CAAC,CAAC,WAAW,CAAC,CAAC;YAC7G,IAAI,eAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;gBACzB,OAAO,eAAM,CAAC,IAAI,CAAC;oBACf,IAAI,EAAE,4BAA4B;oBAClC,OAAO,EAAE,WAAW;iBACvB,CAAC,CAAC;YACP,CAAC;YACD,IAAI,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC9B,OAAO,eAAM,CAAC,IAAI,CAAC;oBACf,IAAI,EAAE,8BAA8B;oBACpC,OAAO,EAAE,WAAW;iBACvB,CAAC,CAAC;YACP,CAAC;YACD,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC5B,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC;YAClE,OAAO,eAAM,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACvC,CAAC;QACD,IAAI;YACA,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACvB,OAAO,eAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAChC,CAAC;YACD,MAAM,QAAQ,GAAgC,MAAM,CAAC,MAAM,CAAC;gBACxD,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;aACvC,CAAC,CAAC;YACH,IAAI,CAAC,IAAA,mCAAwB,EAAC,QAAQ,CAAC,EAAE,CAAC;gBACtC,OAAO,eAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,6BAA6B,EAAE,CAAC,CAAC;YAChE,CAAC;YACD,MAAM,OAAO,GAAG,eAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC,cAAc,EAAE,sCAA2B,CAAC,CAAC,QAAQ,CAAC,CAAC;YACxG,IAAI,eAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;gBACzB,OAAO,eAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,6BAA6B,EAAE,CAAC,CAAC;YAChE,CAAC;YACD,MAAM,GAAG,QAAQ,CAAC;YAClB,OAAO,eAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAClC,CAAC;KACJ,CAAC;IACF,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAClC,CAAC","sourcesContent":["import { Either, Schema } from \"effect\";\nimport { AssertionEntryIdSchema, AssertionsExactParseOptions, isAssertionsRawDataGraph, } from \"./codec.ts\";\nimport type { AssertionDisplay, AssertionEntryId, AssertionEntry, AssertionLimitation, AssertionMaterial, AssertionCoverage, AssertionsDocument, SealedAssertionResult, WritableCriterionEnvelope, } from \"./model.ts\";\nexport interface AssertionEntryInput<BlobRef> {\n    readonly display: AssertionDisplay;\n    readonly criterion: WritableCriterionEnvelope;\n    readonly subject: AssertionMaterial<BlobRef>;\n    readonly evidence: readonly AssertionMaterial<BlobRef>[];\n    readonly coverage: AssertionCoverage;\n    readonly limitations: readonly AssertionLimitation[];\n    readonly result: SealedAssertionResult;\n}\nexport interface AssertionsEntryIdSource {\n    /** Must return a fresh `ae_[a-z0-9]{20}` candidate for this Attachment. */\n    readonly next: () => string;\n}\nexport type AssertionsProducerError = {\n    readonly code: \"assertion-entry-id-invalid\";\n    readonly entryId: string;\n} | {\n    readonly code: \"assertion-entry-id-duplicate\";\n    readonly entryId: string;\n} | {\n    readonly code: \"assertions-document-sealed\";\n} | {\n    readonly code: \"assertions-document-invalid\";\n};\nexport interface AssertionsDocumentBuilder<BlobRef> {\n    /** Appends exactly one completed Assertion in declaration/display order. */\n    readonly append: (entry: AssertionEntryInput<BlobRef>) => Either.Either<AssertionEntryId, AssertionsProducerError>;\n    /**\n     * Checks the writer-only exact document schema once and prevents subsequent\n     * appends. Repeated calls return the same sealed document without running\n     * an evaluator or minting another entry ID.\n     */\n    readonly seal: () => Either.Either<AssertionsDocument<BlobRef>, AssertionsProducerError>;\n}\n/**\n * Assertion producers own normalization and ID allocation. This builder owns\n * neither Record paths nor blob streams: the later Attachment adapter supplies\n * Record's local builder, so an entry cannot borrow another Attachment's ref.\n */\nexport function createAssertionsDocumentBuilder<BlobRef, Encoded>(input: {\n    readonly documentSchema: Schema.Schema<AssertionsDocument<BlobRef>, Encoded>;\n    readonly entryIds: AssertionsEntryIdSource;\n}): AssertionsDocumentBuilder<BlobRef> {\n    const entryIds = new Set<string>();\n    const entries: AssertionEntry<BlobRef>[] = [];\n    let sealed: AssertionsDocument<BlobRef> | undefined;\n    const builder: AssertionsDocumentBuilder<BlobRef> = {\n        append(entry: AssertionEntryInput<BlobRef>): Either.Either<AssertionEntryId, AssertionsProducerError> {\n            if (sealed !== undefined) {\n                return Either.left({ code: \"assertions-document-sealed\" });\n            }\n            const entryIdText = input.entryIds.next();\n            const entryId = Schema.decodeUnknownEither(AssertionEntryIdSchema, AssertionsExactParseOptions)(entryIdText);\n            if (Either.isLeft(entryId)) {\n                return Either.left({\n                    code: \"assertion-entry-id-invalid\",\n                    entryId: entryIdText,\n                });\n            }\n            if (entryIds.has(entryId.right)) {\n                return Either.left({\n                    code: \"assertion-entry-id-duplicate\",\n                    entryId: entryIdText,\n                });\n            }\n            entryIds.add(entryId.right);\n            entries.push(Object.freeze({ entryId: entryId.right, ...entry }));\n            return Either.right(entryId.right);\n        },\n        seal(): Either.Either<AssertionsDocument<BlobRef>, AssertionsProducerError> {\n            if (sealed !== undefined) {\n                return Either.right(sealed);\n            }\n            const document: AssertionsDocument<BlobRef> = Object.freeze({\n                entries: Object.freeze([...entries]),\n            });\n            if (!isAssertionsRawDataGraph(document)) {\n                return Either.left({ code: \"assertions-document-invalid\" });\n            }\n            const encoded = Schema.encodeUnknownEither(input.documentSchema, AssertionsExactParseOptions)(document);\n            if (Either.isLeft(encoded)) {\n                return Either.left({ code: \"assertions-document-invalid\" });\n            }\n            sealed = document;\n            return Either.right(document);\n        },\n    };\n    return Object.freeze(builder);\n}\n"]}

package/dist/assertions/record/producer.d.cts

@@ -1,19 +1,19 @@
 import { Either, Schema } from "effect";
-import type { AssertionDisplayV1, AssertionEntryId, AssertionLimitationV1, AssertionMaterialV1, AssertionCoverageV1, AssertionsDocumentV1, SealedAssertionResultV1, WritableCriterionEnvelopeV1 } from "./model.cjs";
-export interface AssertionEntryInputV1<BlobRef> {
-    readonly display: AssertionDisplayV1;
-    readonly criterion: WritableCriterionEnvelopeV1;
-    readonly subject: AssertionMaterialV1<BlobRef>;
-    readonly evidence: readonly AssertionMaterialV1<BlobRef>[];
-    readonly coverage: AssertionCoverageV1;
-    readonly limitations: readonly AssertionLimitationV1[];
-    readonly result: SealedAssertionResultV1;
+import type { AssertionDisplay, AssertionEntryId, AssertionLimitation, AssertionMaterial, AssertionCoverage, AssertionsDocument, SealedAssertionResult, WritableCriterionEnvelope } from "./model.cjs";
+export interface AssertionEntryInput<BlobRef> {
+    readonly display: AssertionDisplay;
+    readonly criterion: WritableCriterionEnvelope;
+    readonly subject: AssertionMaterial<BlobRef>;
+    readonly evidence: readonly AssertionMaterial<BlobRef>[];
+    readonly coverage: AssertionCoverage;
+    readonly limitations: readonly AssertionLimitation[];
+    readonly result: SealedAssertionResult;
 }
-export interface AssertionsEntryIdSourceV1 {
+export interface AssertionsEntryIdSource {
     /** Must return a fresh `ae_[a-z0-9]{20}` candidate for this Attachment. */
     readonly next: () => string;
 }
-export type AssertionsProducerErrorV1 = {
+export type AssertionsProducerError = {
     readonly code: "assertion-entry-id-invalid";
     readonly entryId: string;
 } | {
@@ -24,22 +24,22 @@ export type AssertionsProducerErrorV1 = {
 } | {
     readonly code: "assertions-document-invalid";
 };
-export interface AssertionsDocumentBuilderV1<BlobRef> {
+export interface AssertionsDocumentBuilder<BlobRef> {
     /** Appends exactly one completed Assertion in declaration/display order. */
-    readonly append: (entry: AssertionEntryInputV1<BlobRef>) => Either.Either<AssertionEntryId, AssertionsProducerErrorV1>;
+    readonly append: (entry: AssertionEntryInput<BlobRef>) => Either.Either<AssertionEntryId, AssertionsProducerError>;
     /**
      * Checks the writer-only exact document schema once and prevents subsequent
      * appends. Repeated calls return the same sealed document without running
      * an evaluator or minting another entry ID.
      */
-    readonly seal: () => Either.Either<AssertionsDocumentV1<BlobRef>, AssertionsProducerErrorV1>;
+    readonly seal: () => Either.Either<AssertionsDocument<BlobRef>, AssertionsProducerError>;
 }
 /**
  * Assertion producers own normalization and ID allocation. This builder owns
  * neither Record paths nor blob streams: the later Attachment adapter supplies
  * Record's local builder, so an entry cannot borrow another Attachment's ref.
  */
-export declare function createAssertionsDocumentBuilderV1<BlobRef, Encoded>(input: {
-    readonly documentSchema: Schema.Schema<AssertionsDocumentV1<BlobRef>, Encoded>;
-    readonly entryIds: AssertionsEntryIdSourceV1;
-}): AssertionsDocumentBuilderV1<BlobRef>;
+export declare function createAssertionsDocumentBuilder<BlobRef, Encoded>(input: {
+    readonly documentSchema: Schema.Schema<AssertionsDocument<BlobRef>, Encoded>;
+    readonly entryIds: AssertionsEntryIdSource;
+}): AssertionsDocumentBuilder<BlobRef>;