niceeval 0.12.1 → 0.12.2-canary.31

package/dist/eval/record/eligibility.d.cts

@@ -0,0 +1,151 @@
+import { Either, Schema } from "effect";
+import type { Effect } from "effect";
+import { type RecordAttachmentValue, type RecordAttachmentWrite } from "../../record/attachment/index.cjs";
+import type { RecordAttachmentRead } from "../../record/model/read-state.cjs";
+import type { FrozenRecordAttempt, FrozenRecordView } from "../../record/reader/types.cjs";
+import { type RecordAttachmentProjector } from "../../projection/projector.cjs";
+export declare const ELIGIBILITY_ATTACHMENT_NAME_V1: "niceeval.eligibility";
+export declare const ELIGIBILITY_ATTACHMENT_SCHEMA_ID_V1: "niceeval.eligibility/v1";
+/**
+ * The one clock domain used by ProjectTarget targets and persisted Eligibility
+ * facts. A source duration is comparable only when both sides name this exact
+ * domain.
+ */
+export declare const EXECUTION_DURATION_DOMAIN_V1: "niceeval.execution-duration/v1";
+/** Durable token text is bounded before it reaches an opaque Record payload. */
+export declare const EQUALITY_TOKEN_DOMAIN_MAXIMUM_LENGTH_V1: 255;
+export declare const EQUALITY_TOKEN_VALUE_MAXIMUM_LENGTH_V1: 4096;
+/** Runtime guard shared by planner inputs and the exact persisted schema. */
+export declare function isEqualityTokenV1(value: unknown): value is EqualityTokenV1;
+/** Runtime guard shared by planner inputs and the exact persisted schema. */
+export declare function isDurationLimitV1(value: unknown): value is DurationLimitV1;
+/**
+ * An opaque equality claim. Its value is meaningful only within its domain;
+ * callers must never compare values from different domains.
+ */
+export declare const EqualityTokenV1Schema: Schema.Struct<{
+    domain: Schema.filter<typeof Schema.String>;
+    value: Schema.filter<typeof Schema.String>;
+}>;
+export type EqualityTokenV1 = Schema.Schema.Type<typeof EqualityTokenV1Schema>;
+/** The duration's domain states which execution clock produced its milliseconds. */
+export declare const DurationLimitV1Schema: Schema.Struct<{
+    domain: Schema.filter<typeof Schema.String>;
+    milliseconds: Schema.filter<Schema.filter<typeof Schema.Number>>;
+}>;
+export type DurationLimitV1 = Schema.Schema.Type<typeof DurationLimitV1Schema>;
+/**
+ * The immutable eligibility claims recorded by an origin Attempt. This is not
+ * a reusable result state: availability and migration remain Record read
+ * states, while these four fields are compared by a named reuse policy.
+ */
+export declare const AttemptEligibilityPayloadV1Schema: Schema.Struct<{
+    reuseContract: Schema.Struct<{
+        domain: Schema.filter<typeof Schema.String>;
+        value: Schema.filter<typeof Schema.String>;
+    }>;
+    inputIdentity: Schema.Struct<{
+        domain: Schema.filter<typeof Schema.String>;
+        value: Schema.filter<typeof Schema.String>;
+    }>;
+    configIdentity: Schema.Struct<{
+        domain: Schema.filter<typeof Schema.String>;
+        value: Schema.filter<typeof Schema.String>;
+    }>;
+    executionDuration: Schema.Struct<{
+        domain: Schema.filter<typeof Schema.String>;
+        milliseconds: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    }>;
+}>;
+export type AttemptEligibilityPayloadV1 = Schema.Schema.Type<typeof AttemptEligibilityPayloadV1Schema>;
+export type AttemptEligibilityPayloadV1Encoded = Schema.Schema.Encoded<typeof AttemptEligibilityPayloadV1Schema>;
+/** Exact JSON definition for the Attempt-owned eligibility fact. */
+export declare const eligibilityAttachmentDefinitionV1: import("../../record/attachment/types.cjs").JsonRecordAttachmentDefinition<"attempt", {
+    readonly reuseContract: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly inputIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly configIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly executionDuration: {
+        readonly domain: string;
+        readonly milliseconds: number;
+    };
+}>;
+export declare const eligibilityAttachmentFamilyV1: import("../../record/attachment/types.cjs").RecordAttachmentFamily<"attempt", {
+    readonly reuseContract: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly inputIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly configIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly executionDuration: {
+        readonly domain: string;
+        readonly milliseconds: number;
+    };
+}>;
+/** Uses the same all-errors, excess-property-rejecting boundary as Record. */
+export declare function decodeAttemptEligibilityPayloadV1(input: unknown): Either.Either<{
+    readonly reuseContract: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly inputIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly configIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly executionDuration: {
+        readonly domain: string;
+        readonly milliseconds: number;
+    };
+}, import("../../record/attachment/errors.cjs").RecordAttachmentPayloadInvalid>;
+export type AttemptEligibilityPayloadBuildErrorV1 = {
+    readonly code: "eligibility-payload-schema-invalid";
+};
+/**
+ * Validates producer input before it is captured by Record's opaque writer.
+ * The payload contains only durable facts; it deliberately has no state field.
+ */
+export declare function buildAttemptEligibilityPayloadV1(input: AttemptEligibilityPayloadV1): Either.Either<AttemptEligibilityPayloadV1, AttemptEligibilityPayloadBuildErrorV1>;
+/** Builds the real opaque Attempt write after exact payload validation. */
+export declare function buildEligibilityAttachmentWriteV1(input: AttemptEligibilityPayloadV1): Either.Either<RecordAttachmentWrite<"attempt", never, never>, AttemptEligibilityPayloadBuildErrorV1>;
+/** The typed reader helper leaves unavailable and migration states as data. */
+export declare function readAttemptEligibilityAttachmentV1<ReadError>(reader: FrozenRecordView<ReadError>, owner: FrozenRecordAttempt): Effect.Effect<RecordAttachmentRead<RecordAttachmentValue<AttemptEligibilityPayloadV1>>, ReadError>;
+/** A pure view over the exact decoded eligibility facts. */
+export declare function projectAttemptEligibilityPayloadV1(payload: AttemptEligibilityPayloadV1): AttemptEligibilityPayloadV1;
+/** A typed synchronous projector for one available Attachment snapshot. */
+export declare function projectEligibilityAttachmentV1(value: RecordAttachmentValue<AttemptEligibilityPayloadV1>): AttemptEligibilityPayloadV1;
+/** A domain-qualified equality token exposed without durable payload coupling. */
+export interface EligibilityToken {
+    readonly domain: string;
+    readonly token: string;
+}
+export interface EligibilityDuration {
+    readonly clockDomain: string;
+    readonly milliseconds: number;
+}
+/** Historical reuse facts exposed as an immutable semantic view. */
+export interface Eligibility {
+    readonly reuseContract: EligibilityToken;
+    readonly input: EligibilityToken;
+    readonly configuration: EligibilityToken;
+    readonly duration: EligibilityDuration;
+}
+/** The public Eligibility view for an Attempt-owned Attachment. */
+export declare const eligibilityProjector: RecordAttachmentProjector<"attempt", Eligibility>;

package/dist/eval/record/eligibility.d.mts

@@ -0,0 +1,151 @@
+import { Either, Schema } from "effect";
+import type { Effect } from "effect";
+import { type RecordAttachmentValue, type RecordAttachmentWrite } from "../../record/attachment/index.mjs";
+import type { RecordAttachmentRead } from "../../record/model/read-state.mjs";
+import type { FrozenRecordAttempt, FrozenRecordView } from "../../record/reader/types.mjs";
+import { type RecordAttachmentProjector } from "../../projection/projector.mjs";
+export declare const ELIGIBILITY_ATTACHMENT_NAME_V1: "niceeval.eligibility";
+export declare const ELIGIBILITY_ATTACHMENT_SCHEMA_ID_V1: "niceeval.eligibility/v1";
+/**
+ * The one clock domain used by ProjectTarget targets and persisted Eligibility
+ * facts. A source duration is comparable only when both sides name this exact
+ * domain.
+ */
+export declare const EXECUTION_DURATION_DOMAIN_V1: "niceeval.execution-duration/v1";
+/** Durable token text is bounded before it reaches an opaque Record payload. */
+export declare const EQUALITY_TOKEN_DOMAIN_MAXIMUM_LENGTH_V1: 255;
+export declare const EQUALITY_TOKEN_VALUE_MAXIMUM_LENGTH_V1: 4096;
+/** Runtime guard shared by planner inputs and the exact persisted schema. */
+export declare function isEqualityTokenV1(value: unknown): value is EqualityTokenV1;
+/** Runtime guard shared by planner inputs and the exact persisted schema. */
+export declare function isDurationLimitV1(value: unknown): value is DurationLimitV1;
+/**
+ * An opaque equality claim. Its value is meaningful only within its domain;
+ * callers must never compare values from different domains.
+ */
+export declare const EqualityTokenV1Schema: Schema.Struct<{
+    domain: Schema.filter<typeof Schema.String>;
+    value: Schema.filter<typeof Schema.String>;
+}>;
+export type EqualityTokenV1 = Schema.Schema.Type<typeof EqualityTokenV1Schema>;
+/** The duration's domain states which execution clock produced its milliseconds. */
+export declare const DurationLimitV1Schema: Schema.Struct<{
+    domain: Schema.filter<typeof Schema.String>;
+    milliseconds: Schema.filter<Schema.filter<typeof Schema.Number>>;
+}>;
+export type DurationLimitV1 = Schema.Schema.Type<typeof DurationLimitV1Schema>;
+/**
+ * The immutable eligibility claims recorded by an origin Attempt. This is not
+ * a reusable result state: availability and migration remain Record read
+ * states, while these four fields are compared by a named reuse policy.
+ */
+export declare const AttemptEligibilityPayloadV1Schema: Schema.Struct<{
+    reuseContract: Schema.Struct<{
+        domain: Schema.filter<typeof Schema.String>;
+        value: Schema.filter<typeof Schema.String>;
+    }>;
+    inputIdentity: Schema.Struct<{
+        domain: Schema.filter<typeof Schema.String>;
+        value: Schema.filter<typeof Schema.String>;
+    }>;
+    configIdentity: Schema.Struct<{
+        domain: Schema.filter<typeof Schema.String>;
+        value: Schema.filter<typeof Schema.String>;
+    }>;
+    executionDuration: Schema.Struct<{
+        domain: Schema.filter<typeof Schema.String>;
+        milliseconds: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    }>;
+}>;
+export type AttemptEligibilityPayloadV1 = Schema.Schema.Type<typeof AttemptEligibilityPayloadV1Schema>;
+export type AttemptEligibilityPayloadV1Encoded = Schema.Schema.Encoded<typeof AttemptEligibilityPayloadV1Schema>;
+/** Exact JSON definition for the Attempt-owned eligibility fact. */
+export declare const eligibilityAttachmentDefinitionV1: import("../../record/attachment/types.mjs").JsonRecordAttachmentDefinition<"attempt", {
+    readonly reuseContract: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly inputIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly configIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly executionDuration: {
+        readonly domain: string;
+        readonly milliseconds: number;
+    };
+}>;
+export declare const eligibilityAttachmentFamilyV1: import("../../record/attachment/types.mjs").RecordAttachmentFamily<"attempt", {
+    readonly reuseContract: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly inputIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly configIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly executionDuration: {
+        readonly domain: string;
+        readonly milliseconds: number;
+    };
+}>;
+/** Uses the same all-errors, excess-property-rejecting boundary as Record. */
+export declare function decodeAttemptEligibilityPayloadV1(input: unknown): Either.Either<{
+    readonly reuseContract: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly inputIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly configIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly executionDuration: {
+        readonly domain: string;
+        readonly milliseconds: number;
+    };
+}, import("../../record/attachment/errors.mjs").RecordAttachmentPayloadInvalid>;
+export type AttemptEligibilityPayloadBuildErrorV1 = {
+    readonly code: "eligibility-payload-schema-invalid";
+};
+/**
+ * Validates producer input before it is captured by Record's opaque writer.
+ * The payload contains only durable facts; it deliberately has no state field.
+ */
+export declare function buildAttemptEligibilityPayloadV1(input: AttemptEligibilityPayloadV1): Either.Either<AttemptEligibilityPayloadV1, AttemptEligibilityPayloadBuildErrorV1>;
+/** Builds the real opaque Attempt write after exact payload validation. */
+export declare function buildEligibilityAttachmentWriteV1(input: AttemptEligibilityPayloadV1): Either.Either<RecordAttachmentWrite<"attempt", never, never>, AttemptEligibilityPayloadBuildErrorV1>;
+/** The typed reader helper leaves unavailable and migration states as data. */
+export declare function readAttemptEligibilityAttachmentV1<ReadError>(reader: FrozenRecordView<ReadError>, owner: FrozenRecordAttempt): Effect.Effect<RecordAttachmentRead<RecordAttachmentValue<AttemptEligibilityPayloadV1>>, ReadError>;
+/** A pure view over the exact decoded eligibility facts. */
+export declare function projectAttemptEligibilityPayloadV1(payload: AttemptEligibilityPayloadV1): AttemptEligibilityPayloadV1;
+/** A typed synchronous projector for one available Attachment snapshot. */
+export declare function projectEligibilityAttachmentV1(value: RecordAttachmentValue<AttemptEligibilityPayloadV1>): AttemptEligibilityPayloadV1;
+/** A domain-qualified equality token exposed without durable payload coupling. */
+export interface EligibilityToken {
+    readonly domain: string;
+    readonly token: string;
+}
+export interface EligibilityDuration {
+    readonly clockDomain: string;
+    readonly milliseconds: number;
+}
+/** Historical reuse facts exposed as an immutable semantic view. */
+export interface Eligibility {
+    readonly reuseContract: EligibilityToken;
+    readonly input: EligibilityToken;
+    readonly configuration: EligibilityToken;
+    readonly duration: EligibilityDuration;
+}
+/** The public Eligibility view for an Attempt-owned Attachment. */
+export declare const eligibilityProjector: RecordAttachmentProjector<"attempt", Eligibility>;

package/dist/eval/record/eligibility.d.ts

@@ -0,0 +1,151 @@
+import { Either, Schema } from "effect";
+import type { Effect } from "effect";
+import { type RecordAttachmentValue, type RecordAttachmentWrite } from "../../record/attachment/index.js";
+import type { RecordAttachmentRead } from "../../record/model/read-state.js";
+import type { FrozenRecordAttempt, FrozenRecordView } from "../../record/reader/types.js";
+import { type RecordAttachmentProjector } from "../../projection/projector.js";
+export declare const ELIGIBILITY_ATTACHMENT_NAME_V1: "niceeval.eligibility";
+export declare const ELIGIBILITY_ATTACHMENT_SCHEMA_ID_V1: "niceeval.eligibility/v1";
+/**
+ * The one clock domain used by ProjectTarget targets and persisted Eligibility
+ * facts. A source duration is comparable only when both sides name this exact
+ * domain.
+ */
+export declare const EXECUTION_DURATION_DOMAIN_V1: "niceeval.execution-duration/v1";
+/** Durable token text is bounded before it reaches an opaque Record payload. */
+export declare const EQUALITY_TOKEN_DOMAIN_MAXIMUM_LENGTH_V1: 255;
+export declare const EQUALITY_TOKEN_VALUE_MAXIMUM_LENGTH_V1: 4096;
+/** Runtime guard shared by planner inputs and the exact persisted schema. */
+export declare function isEqualityTokenV1(value: unknown): value is EqualityTokenV1;
+/** Runtime guard shared by planner inputs and the exact persisted schema. */
+export declare function isDurationLimitV1(value: unknown): value is DurationLimitV1;
+/**
+ * An opaque equality claim. Its value is meaningful only within its domain;
+ * callers must never compare values from different domains.
+ */
+export declare const EqualityTokenV1Schema: Schema.Struct<{
+    domain: Schema.filter<typeof Schema.String>;
+    value: Schema.filter<typeof Schema.String>;
+}>;
+export type EqualityTokenV1 = Schema.Schema.Type<typeof EqualityTokenV1Schema>;
+/** The duration's domain states which execution clock produced its milliseconds. */
+export declare const DurationLimitV1Schema: Schema.Struct<{
+    domain: Schema.filter<typeof Schema.String>;
+    milliseconds: Schema.filter<Schema.filter<typeof Schema.Number>>;
+}>;
+export type DurationLimitV1 = Schema.Schema.Type<typeof DurationLimitV1Schema>;
+/**
+ * The immutable eligibility claims recorded by an origin Attempt. This is not
+ * a reusable result state: availability and migration remain Record read
+ * states, while these four fields are compared by a named reuse policy.
+ */
+export declare const AttemptEligibilityPayloadV1Schema: Schema.Struct<{
+    reuseContract: Schema.Struct<{
+        domain: Schema.filter<typeof Schema.String>;
+        value: Schema.filter<typeof Schema.String>;
+    }>;
+    inputIdentity: Schema.Struct<{
+        domain: Schema.filter<typeof Schema.String>;
+        value: Schema.filter<typeof Schema.String>;
+    }>;
+    configIdentity: Schema.Struct<{
+        domain: Schema.filter<typeof Schema.String>;
+        value: Schema.filter<typeof Schema.String>;
+    }>;
+    executionDuration: Schema.Struct<{
+        domain: Schema.filter<typeof Schema.String>;
+        milliseconds: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    }>;
+}>;
+export type AttemptEligibilityPayloadV1 = Schema.Schema.Type<typeof AttemptEligibilityPayloadV1Schema>;
+export type AttemptEligibilityPayloadV1Encoded = Schema.Schema.Encoded<typeof AttemptEligibilityPayloadV1Schema>;
+/** Exact JSON definition for the Attempt-owned eligibility fact. */
+export declare const eligibilityAttachmentDefinitionV1: import("../../record/attachment/types.js").JsonRecordAttachmentDefinition<"attempt", {
+    readonly reuseContract: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly inputIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly configIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly executionDuration: {
+        readonly domain: string;
+        readonly milliseconds: number;
+    };
+}>;
+export declare const eligibilityAttachmentFamilyV1: import("../../record/attachment/types.js").RecordAttachmentFamily<"attempt", {
+    readonly reuseContract: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly inputIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly configIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly executionDuration: {
+        readonly domain: string;
+        readonly milliseconds: number;
+    };
+}>;
+/** Uses the same all-errors, excess-property-rejecting boundary as Record. */
+export declare function decodeAttemptEligibilityPayloadV1(input: unknown): Either.Either<{
+    readonly reuseContract: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly inputIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly configIdentity: {
+        readonly value: string;
+        readonly domain: string;
+    };
+    readonly executionDuration: {
+        readonly domain: string;
+        readonly milliseconds: number;
+    };
+}, import("../../record/attachment/errors.js").RecordAttachmentPayloadInvalid>;
+export type AttemptEligibilityPayloadBuildErrorV1 = {
+    readonly code: "eligibility-payload-schema-invalid";
+};
+/**
+ * Validates producer input before it is captured by Record's opaque writer.
+ * The payload contains only durable facts; it deliberately has no state field.
+ */
+export declare function buildAttemptEligibilityPayloadV1(input: AttemptEligibilityPayloadV1): Either.Either<AttemptEligibilityPayloadV1, AttemptEligibilityPayloadBuildErrorV1>;
+/** Builds the real opaque Attempt write after exact payload validation. */
+export declare function buildEligibilityAttachmentWriteV1(input: AttemptEligibilityPayloadV1): Either.Either<RecordAttachmentWrite<"attempt", never, never>, AttemptEligibilityPayloadBuildErrorV1>;
+/** The typed reader helper leaves unavailable and migration states as data. */
+export declare function readAttemptEligibilityAttachmentV1<ReadError>(reader: FrozenRecordView<ReadError>, owner: FrozenRecordAttempt): Effect.Effect<RecordAttachmentRead<RecordAttachmentValue<AttemptEligibilityPayloadV1>>, ReadError>;
+/** A pure view over the exact decoded eligibility facts. */
+export declare function projectAttemptEligibilityPayloadV1(payload: AttemptEligibilityPayloadV1): AttemptEligibilityPayloadV1;
+/** A typed synchronous projector for one available Attachment snapshot. */
+export declare function projectEligibilityAttachmentV1(value: RecordAttachmentValue<AttemptEligibilityPayloadV1>): AttemptEligibilityPayloadV1;
+/** A domain-qualified equality token exposed without durable payload coupling. */
+export interface EligibilityToken {
+    readonly domain: string;
+    readonly token: string;
+}
+export interface EligibilityDuration {
+    readonly clockDomain: string;
+    readonly milliseconds: number;
+}
+/** Historical reuse facts exposed as an immutable semantic view. */
+export interface Eligibility {
+    readonly reuseContract: EligibilityToken;
+    readonly input: EligibilityToken;
+    readonly configuration: EligibilityToken;
+    readonly duration: EligibilityDuration;
+}
+/** The public Eligibility view for an Attempt-owned Attachment. */
+export declare const eligibilityProjector: RecordAttachmentProjector<"attempt", Eligibility>;

package/dist/eval/record/eligibility.js

@@ -0,0 +1,42 @@
+import { createRequire as __niceevalCreateRequire } from "node:module";
+const __niceevalRequire = __niceevalCreateRequire(import.meta.url);
+const __niceevalCanonical = __niceevalRequire("./eligibility.cjs");
+const __niceevalExport0 = __niceevalCanonical["AttemptEligibilityPayloadV1Schema"];
+export { __niceevalExport0 as AttemptEligibilityPayloadV1Schema };
+const __niceevalExport1 = __niceevalCanonical["DurationLimitV1Schema"];
+export { __niceevalExport1 as DurationLimitV1Schema };
+const __niceevalExport2 = __niceevalCanonical["ELIGIBILITY_ATTACHMENT_NAME_V1"];
+export { __niceevalExport2 as ELIGIBILITY_ATTACHMENT_NAME_V1 };
+const __niceevalExport3 = __niceevalCanonical["ELIGIBILITY_ATTACHMENT_SCHEMA_ID_V1"];
+export { __niceevalExport3 as ELIGIBILITY_ATTACHMENT_SCHEMA_ID_V1 };
+const __niceevalExport4 = __niceevalCanonical["EQUALITY_TOKEN_DOMAIN_MAXIMUM_LENGTH_V1"];
+export { __niceevalExport4 as EQUALITY_TOKEN_DOMAIN_MAXIMUM_LENGTH_V1 };
+const __niceevalExport5 = __niceevalCanonical["EQUALITY_TOKEN_VALUE_MAXIMUM_LENGTH_V1"];
+export { __niceevalExport5 as EQUALITY_TOKEN_VALUE_MAXIMUM_LENGTH_V1 };
+const __niceevalExport6 = __niceevalCanonical["EXECUTION_DURATION_DOMAIN_V1"];
+export { __niceevalExport6 as EXECUTION_DURATION_DOMAIN_V1 };
+const __niceevalExport7 = __niceevalCanonical["EqualityTokenV1Schema"];
+export { __niceevalExport7 as EqualityTokenV1Schema };
+const __niceevalExport8 = __niceevalCanonical["buildAttemptEligibilityPayloadV1"];
+export { __niceevalExport8 as buildAttemptEligibilityPayloadV1 };
+const __niceevalExport9 = __niceevalCanonical["buildEligibilityAttachmentWriteV1"];
+export { __niceevalExport9 as buildEligibilityAttachmentWriteV1 };
+const __niceevalExport10 = __niceevalCanonical["decodeAttemptEligibilityPayloadV1"];
+export { __niceevalExport10 as decodeAttemptEligibilityPayloadV1 };
+const __niceevalExport11 = __niceevalCanonical["eligibilityAttachmentDefinitionV1"];
+export { __niceevalExport11 as eligibilityAttachmentDefinitionV1 };
+const __niceevalExport12 = __niceevalCanonical["eligibilityAttachmentFamilyV1"];
+export { __niceevalExport12 as eligibilityAttachmentFamilyV1 };
+const __niceevalExport13 = __niceevalCanonical["eligibilityProjector"];
+export { __niceevalExport13 as eligibilityProjector };
+const __niceevalExport14 = __niceevalCanonical["isDurationLimitV1"];
+export { __niceevalExport14 as isDurationLimitV1 };
+const __niceevalExport15 = __niceevalCanonical["isEqualityTokenV1"];
+export { __niceevalExport15 as isEqualityTokenV1 };
+const __niceevalExport16 = __niceevalCanonical["projectAttemptEligibilityPayloadV1"];
+export { __niceevalExport16 as projectAttemptEligibilityPayloadV1 };
+const __niceevalExport17 = __niceevalCanonical["projectEligibilityAttachmentV1"];
+export { __niceevalExport17 as projectEligibilityAttachmentV1 };
+const __niceevalExport18 = __niceevalCanonical["readAttemptEligibilityAttachmentV1"];
+export { __niceevalExport18 as readAttemptEligibilityAttachmentV1 };
+//# sourceMappingURL=eligibility.js.map

package/dist/eval/record/eligibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eligibility.js","sources":[],"names":[],"mappings":""}

package/dist/eval/record/evaluation-plan.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluationPlanProjector = void 0;
+const projector_ts_1 = require("../../projection/projector.cjs");
+const experiment_id_ts_1 = require("../experiment-id.cjs");
+/** The public semantic projection for the Run-owned evaluation plan. */
+exports.evaluationPlanProjector = (0, projector_ts_1.defineRecordAttachmentProjector)({
+    attachment: experiment_id_ts_1.evaluationsAttachmentFamily,
+    project: (value) => {
+        const coordinatesBySlot = new Map();
+        for (const evaluation of value.payload.evaluations) {
+            for (const slot of evaluation.slots) {
+                coordinatesBySlot.set(slot.slotId, Object.freeze({
+                    experimentId: value.payload.experimentId,
+                    evalId: evaluation.evalId,
+                    attempt: slot.attempt,
+                    kind: evaluation.evaluationKind,
+                }));
+            }
+        }
+        return Object.freeze({
+            coordinateForSlot: (slotId) => coordinatesBySlot.get(slotId),
+        });
+    },
+});
+//# sourceMappingURL=evaluation-plan.cjs.map

package/dist/eval/record/evaluation-plan.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation-plan.js","sourceRoot":"","sources":["evaluation-plan.ts"],"names":[],"mappings":";;;AAAA,gEAAiH;AAEjH,0DAAmE;AAanE,wEAAwE;AAC3D,QAAA,uBAAuB,GAAyD,IAAA,8CAA+B,EAAC;IACzH,UAAU,EAAE,8CAA2B;IACvC,OAAO,EAAE,CAAC,KAAK,EAAsB,EAAE;QACnC,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAoC,CAAC;QACtE,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;YACjD,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,KAAK,EAAE,CAAC;gBAClC,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC;oBAC7C,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC,YAAY;oBACxC,MAAM,EAAE,UAAU,CAAC,MAAM;oBACzB,OAAO,EAAE,IAAI,CAAC,OAAO;oBACrB,IAAI,EAAE,UAAU,CAAC,cAAc;iBAClC,CAAC,CAAC,CAAC;YACR,CAAC;QACL,CAAC;QACD,OAAO,MAAM,CAAC,MAAM,CAAC;YACjB,iBAAiB,EAAE,CAAC,MAAc,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC;SACvE,CAAC,CAAC;IACP,CAAC;CACJ,CAAC,CAAC","sourcesContent":["import { defineRecordAttachmentProjector, type RecordAttachmentProjector, } from \"../../projection/projector.ts\";\nimport type { ExperimentId, SlotId } from \"../../analysis/index.ts\";\nimport { evaluationsAttachmentFamily, } from \"../experiment-id.ts\";\nimport type { EvaluationKind } from \"./evaluation.ts\";\n/** The semantic evaluation coordinates assigned to one Run denominator Slot. */\nexport interface EvaluationPlanCoordinate {\n    readonly experimentId: ExperimentId;\n    readonly evalId: string;\n    readonly attempt: number;\n    readonly kind: EvaluationKind;\n}\n/** A Run-local lookup over the evaluation plan without exposing its durable shape. */\nexport interface EvaluationPlanView {\n    readonly coordinateForSlot: (slotId: SlotId) => EvaluationPlanCoordinate | undefined;\n}\n/** The public semantic projection for the Run-owned evaluation plan. */\nexport const evaluationPlanProjector: RecordAttachmentProjector<\"run\", EvaluationPlanView> = defineRecordAttachmentProjector({\n    attachment: evaluationsAttachmentFamily,\n    project: (value): EvaluationPlanView => {\n        const coordinatesBySlot = new Map<SlotId, EvaluationPlanCoordinate>();\n        for (const evaluation of value.payload.evaluations) {\n            for (const slot of evaluation.slots) {\n                coordinatesBySlot.set(slot.slotId, Object.freeze({\n                    experimentId: value.payload.experimentId,\n                    evalId: evaluation.evalId,\n                    attempt: slot.attempt,\n                    kind: evaluation.evaluationKind,\n                }));\n            }\n        }\n        return Object.freeze({\n            coordinateForSlot: (slotId: SlotId) => coordinatesBySlot.get(slotId),\n        });\n    },\n});\n"]}

package/dist/eval/record/evaluation-plan.d.cts

@@ -0,0 +1,16 @@
+import { type RecordAttachmentProjector } from "../../projection/projector.cjs";
+import type { ExperimentId, SlotId } from "../../analysis/index.cjs";
+import type { EvaluationKind } from "./evaluation.cjs";
+/** The semantic evaluation coordinates assigned to one Run denominator Slot. */
+export interface EvaluationPlanCoordinate {
+    readonly experimentId: ExperimentId;
+    readonly evalId: string;
+    readonly attempt: number;
+    readonly kind: EvaluationKind;
+}
+/** A Run-local lookup over the evaluation plan without exposing its durable shape. */
+export interface EvaluationPlanView {
+    readonly coordinateForSlot: (slotId: SlotId) => EvaluationPlanCoordinate | undefined;
+}
+/** The public semantic projection for the Run-owned evaluation plan. */
+export declare const evaluationPlanProjector: RecordAttachmentProjector<"run", EvaluationPlanView>;

package/dist/eval/record/evaluation-plan.d.mts

@@ -0,0 +1,16 @@
+import { type RecordAttachmentProjector } from "../../projection/projector.mjs";
+import type { ExperimentId, SlotId } from "../../analysis/index.mjs";
+import type { EvaluationKind } from "./evaluation.mjs";
+/** The semantic evaluation coordinates assigned to one Run denominator Slot. */
+export interface EvaluationPlanCoordinate {
+    readonly experimentId: ExperimentId;
+    readonly evalId: string;
+    readonly attempt: number;
+    readonly kind: EvaluationKind;
+}
+/** A Run-local lookup over the evaluation plan without exposing its durable shape. */
+export interface EvaluationPlanView {
+    readonly coordinateForSlot: (slotId: SlotId) => EvaluationPlanCoordinate | undefined;
+}
+/** The public semantic projection for the Run-owned evaluation plan. */
+export declare const evaluationPlanProjector: RecordAttachmentProjector<"run", EvaluationPlanView>;

package/dist/eval/record/evaluation-plan.d.ts

@@ -0,0 +1,16 @@
+import { type RecordAttachmentProjector } from "../../projection/projector.js";
+import type { ExperimentId, SlotId } from "../../analysis/index.js";
+import type { EvaluationKind } from "./evaluation.js";
+/** The semantic evaluation coordinates assigned to one Run denominator Slot. */
+export interface EvaluationPlanCoordinate {
+    readonly experimentId: ExperimentId;
+    readonly evalId: string;
+    readonly attempt: number;
+    readonly kind: EvaluationKind;
+}
+/** A Run-local lookup over the evaluation plan without exposing its durable shape. */
+export interface EvaluationPlanView {
+    readonly coordinateForSlot: (slotId: SlotId) => EvaluationPlanCoordinate | undefined;
+}
+/** The public semantic projection for the Run-owned evaluation plan. */
+export declare const evaluationPlanProjector: RecordAttachmentProjector<"run", EvaluationPlanView>;

package/dist/eval/record/evaluation-plan.js

@@ -0,0 +1,6 @@
+import { createRequire as __niceevalCreateRequire } from "node:module";
+const __niceevalRequire = __niceevalCreateRequire(import.meta.url);
+const __niceevalCanonical = __niceevalRequire("./evaluation-plan.cjs");
+const __niceevalExport0 = __niceevalCanonical["evaluationPlanProjector"];
+export { __niceevalExport0 as evaluationPlanProjector };
+//# sourceMappingURL=evaluation-plan.js.map

package/dist/eval/record/evaluation-plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation-plan.js","sources":[],"names":[],"mappings":""}