niceeval 0.15.1-canary.76 → 0.16.1

package/dist/record/family/judge-usage/schema.d.ts

@@ -0,0 +1,351 @@
+import { Schema } from "effect";
+import { type RecordAttachmentIssue } from "../../attachment/index.js";
+export declare const JudgeUsageLimits: Readonly<{
+    maximumCalls: 4000;
+    maximumModelBytes: 8192;
+    maximumReceiptBytes: 32768;
+    maximumReceiptFields: 24;
+}>;
+/** @internal Used to validate observations before retaining their response fields. */
+export declare const JudgeUsageModelSchema: Schema.String;
+/** Only these protocol facts may enter durable receipts; business text is excluded. */
+export declare const JudgeUsageReceiptPaths: readonly ["model", "provider", "usage.completion_tokens", "usage.cost", "usage.input_tokens", "usage.output_tokens", "usage.prompt_tokens", "usage.prompt_tokens_details.cache_write_tokens", "usage.prompt_tokens_details.cached_tokens", "usage.total_tokens"];
+declare const CallShapeSchema: Schema.Struct<{
+    readonly callId: Schema.String;
+    readonly entryIndex: Schema.Number;
+    readonly entryId: Schema.Codec<import("../../../index.js").AssertionEntryId, string, never, never>;
+    readonly logicalOrdinal: Schema.Number;
+    readonly transmissionOrdinal: Schema.Number;
+    readonly operation: Schema.Literals<readonly ["score", "classify", "extract", "batchClassify"]>;
+    readonly requestModel: Schema.String;
+    readonly transportProvider: Schema.Literals<readonly ["openai", "vercel", "openrouter", "typesafe"]>;
+    readonly provider: Schema.NullOr<Schema.String>;
+    readonly model: Schema.NullOr<Schema.String>;
+    readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled", "unknown"]>;
+    readonly httpStatus: Schema.NullOr<Schema.Number>;
+    readonly inputTokens: Schema.NullOr<Schema.Number>;
+    readonly inputTotalTokens: Schema.NullOr<Schema.Number>;
+    readonly outputTokens: Schema.NullOr<Schema.Number>;
+    readonly cacheReadTokens: Schema.NullOr<Schema.Number>;
+    readonly cacheWriteTokens: Schema.NullOr<Schema.Number>;
+    readonly cost: Schema.NullOr<Schema.Struct<{
+        readonly amount: Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+        readonly currency: Schema.Codec<import("../source-receipt/model.js").CurrencyCode, string, never, never>;
+        readonly source: Schema.Struct<{
+            readonly kind: Schema.Literal<"reported">;
+            readonly id: Schema.String;
+        }>;
+    }>>;
+    readonly receipt: Schema.Struct<{
+        readonly state: Schema.Literals<readonly ["available", "unavailable"]>;
+        readonly reason: Schema.NullOr<Schema.Literals<readonly ["response-unavailable", "cancelled", "response-too-large", "invalid-json", "usage-not-reported", "invalid-usage", "response-model-too-large"]>>;
+        readonly responseDigest: Schema.NullOr<Schema.String>;
+        readonly fields: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.Literals<readonly ["model", "provider", "usage.completion_tokens", "usage.cost", "usage.input_tokens", "usage.output_tokens", "usage.prompt_tokens", "usage.prompt_tokens_details.cache_write_tokens", "usage.prompt_tokens_details.cached_tokens", "usage.total_tokens"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Null]>;
+        }>>;
+    }>;
+}>;
+export type JudgeUsageCall = Schema.Schema.Type<typeof CallShapeSchema>;
+export declare const JudgeUsageCallSchema: Schema.Struct<{
+    readonly callId: Schema.String;
+    readonly entryIndex: Schema.Number;
+    readonly entryId: Schema.Codec<import("../../../index.js").AssertionEntryId, string, never, never>;
+    readonly logicalOrdinal: Schema.Number;
+    readonly transmissionOrdinal: Schema.Number;
+    readonly operation: Schema.Literals<readonly ["score", "classify", "extract", "batchClassify"]>;
+    readonly requestModel: Schema.String;
+    readonly transportProvider: Schema.Literals<readonly ["openai", "vercel", "openrouter", "typesafe"]>;
+    readonly provider: Schema.NullOr<Schema.String>;
+    readonly model: Schema.NullOr<Schema.String>;
+    readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled", "unknown"]>;
+    readonly httpStatus: Schema.NullOr<Schema.Number>;
+    readonly inputTokens: Schema.NullOr<Schema.Number>;
+    readonly inputTotalTokens: Schema.NullOr<Schema.Number>;
+    readonly outputTokens: Schema.NullOr<Schema.Number>;
+    readonly cacheReadTokens: Schema.NullOr<Schema.Number>;
+    readonly cacheWriteTokens: Schema.NullOr<Schema.Number>;
+    readonly cost: Schema.NullOr<Schema.Struct<{
+        readonly amount: Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+        readonly currency: Schema.Codec<import("../source-receipt/model.js").CurrencyCode, string, never, never>;
+        readonly source: Schema.Struct<{
+            readonly kind: Schema.Literal<"reported">;
+            readonly id: Schema.String;
+        }>;
+    }>>;
+    readonly receipt: Schema.Struct<{
+        readonly state: Schema.Literals<readonly ["available", "unavailable"]>;
+        readonly reason: Schema.NullOr<Schema.Literals<readonly ["response-unavailable", "cancelled", "response-too-large", "invalid-json", "usage-not-reported", "invalid-usage", "response-model-too-large"]>>;
+        readonly responseDigest: Schema.NullOr<Schema.String>;
+        readonly fields: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.Literals<readonly ["model", "provider", "usage.completion_tokens", "usage.cost", "usage.input_tokens", "usage.output_tokens", "usage.prompt_tokens", "usage.prompt_tokens_details.cache_write_tokens", "usage.prompt_tokens_details.cached_tokens", "usage.total_tokens"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Null]>;
+        }>>;
+    }>;
+}>;
+declare const PriceReceiptShapeSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"judge-call-price-estimate">;
+    readonly callId: Schema.String;
+    readonly state: Schema.Literals<readonly ["complete", "partial"]>;
+    readonly amount: Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+    readonly currency: Schema.Literal<"USD">;
+    readonly source: Schema.Struct<{
+        readonly kind: Schema.Literal<"estimated">;
+        readonly id: Schema.String;
+    }>;
+    readonly pricing: Schema.Struct<{
+        readonly basis: Schema.Literal<"catalog-reference">;
+        readonly currency: Schema.Literal<"USD">;
+        readonly source: Schema.Struct<{
+            readonly kind: Schema.Literal<"configured-profile">;
+            readonly id: Schema.String;
+            readonly asOf: Schema.NullOr<Schema.Number>;
+            readonly profileDigest: Schema.String;
+        }>;
+        readonly requestModel: Schema.String;
+        readonly selector: Schema.String;
+        readonly match: Schema.Literals<readonly ["exact", "provider-wildcard"]>;
+        readonly ratesPerMTok: Schema.Struct<{
+            readonly input: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+            readonly output: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+            readonly cacheRead: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+            readonly cacheWrite: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+        }>;
+    }>;
+    readonly charges: Schema.NonEmptyArray<Schema.Struct<{
+        readonly bucket: Schema.Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+        readonly tokens: Schema.Number;
+        readonly ratePerMTok: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+        readonly amount: Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+    }>>;
+    readonly missing: Schema.$Array<Schema.Struct<{
+        readonly bucket: Schema.Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+        readonly reason: Schema.Literals<readonly ["tokens-unknown", "rate-unknown"]>;
+    }>>;
+}>;
+export type JudgePriceReceipt = Schema.Schema.Type<typeof PriceReceiptShapeSchema>;
+export declare const JudgePriceReceiptSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"judge-call-price-estimate">;
+    readonly callId: Schema.String;
+    readonly state: Schema.Literals<readonly ["complete", "partial"]>;
+    readonly amount: Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+    readonly currency: Schema.Literal<"USD">;
+    readonly source: Schema.Struct<{
+        readonly kind: Schema.Literal<"estimated">;
+        readonly id: Schema.String;
+    }>;
+    readonly pricing: Schema.Struct<{
+        readonly basis: Schema.Literal<"catalog-reference">;
+        readonly currency: Schema.Literal<"USD">;
+        readonly source: Schema.Struct<{
+            readonly kind: Schema.Literal<"configured-profile">;
+            readonly id: Schema.String;
+            readonly asOf: Schema.NullOr<Schema.Number>;
+            readonly profileDigest: Schema.String;
+        }>;
+        readonly requestModel: Schema.String;
+        readonly selector: Schema.String;
+        readonly match: Schema.Literals<readonly ["exact", "provider-wildcard"]>;
+        readonly ratesPerMTok: Schema.Struct<{
+            readonly input: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+            readonly output: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+            readonly cacheRead: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+            readonly cacheWrite: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+        }>;
+    }>;
+    readonly charges: Schema.NonEmptyArray<Schema.Struct<{
+        readonly bucket: Schema.Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+        readonly tokens: Schema.Number;
+        readonly ratePerMTok: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+        readonly amount: Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+    }>>;
+    readonly missing: Schema.$Array<Schema.Struct<{
+        readonly bucket: Schema.Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+        readonly reason: Schema.Literals<readonly ["tokens-unknown", "rate-unknown"]>;
+    }>>;
+}>;
+declare const AttachmentSchema: Schema.Struct<{
+    readonly collection: Schema.Union<readonly [Schema.Struct<{
+        readonly state: Schema.Literal<"complete">;
+        readonly limitations: Schema.Tuple<readonly []>;
+    }>, Schema.Struct<{
+        readonly state: Schema.Literal<"partial">;
+        readonly limitations: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["capture-failed", "capture-interrupted"]>;
+            readonly stage: Schema.String;
+        }>, Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["collection-cap-reached", "unsupported-input"]>;
+            readonly omittedAtLeast: Schema.Number;
+        }>]>>;
+    }>]>;
+    readonly calls: Schema.$Array<Schema.Struct<{
+        readonly callId: Schema.String;
+        readonly entryIndex: Schema.Number;
+        readonly entryId: Schema.Codec<import("../../../index.js").AssertionEntryId, string, never, never>;
+        readonly logicalOrdinal: Schema.Number;
+        readonly transmissionOrdinal: Schema.Number;
+        readonly operation: Schema.Literals<readonly ["score", "classify", "extract", "batchClassify"]>;
+        readonly requestModel: Schema.String;
+        readonly transportProvider: Schema.Literals<readonly ["openai", "vercel", "openrouter", "typesafe"]>;
+        readonly provider: Schema.NullOr<Schema.String>;
+        readonly model: Schema.NullOr<Schema.String>;
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled", "unknown"]>;
+        readonly httpStatus: Schema.NullOr<Schema.Number>;
+        readonly inputTokens: Schema.NullOr<Schema.Number>;
+        readonly inputTotalTokens: Schema.NullOr<Schema.Number>;
+        readonly outputTokens: Schema.NullOr<Schema.Number>;
+        readonly cacheReadTokens: Schema.NullOr<Schema.Number>;
+        readonly cacheWriteTokens: Schema.NullOr<Schema.Number>;
+        readonly cost: Schema.NullOr<Schema.Struct<{
+            readonly amount: Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+            readonly currency: Schema.Codec<import("../source-receipt/model.js").CurrencyCode, string, never, never>;
+            readonly source: Schema.Struct<{
+                readonly kind: Schema.Literal<"reported">;
+                readonly id: Schema.String;
+            }>;
+        }>>;
+        readonly receipt: Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["available", "unavailable"]>;
+            readonly reason: Schema.NullOr<Schema.Literals<readonly ["response-unavailable", "cancelled", "response-too-large", "invalid-json", "usage-not-reported", "invalid-usage", "response-model-too-large"]>>;
+            readonly responseDigest: Schema.NullOr<Schema.String>;
+            readonly fields: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.Literals<readonly ["model", "provider", "usage.completion_tokens", "usage.cost", "usage.input_tokens", "usage.output_tokens", "usage.prompt_tokens", "usage.prompt_tokens_details.cache_write_tokens", "usage.prompt_tokens_details.cached_tokens", "usage.total_tokens"]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Null]>;
+            }>>;
+        }>;
+    }>>;
+    readonly priceReceipts: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literal<"judge-call-price-estimate">;
+        readonly callId: Schema.String;
+        readonly state: Schema.Literals<readonly ["complete", "partial"]>;
+        readonly amount: Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+        readonly currency: Schema.Literal<"USD">;
+        readonly source: Schema.Struct<{
+            readonly kind: Schema.Literal<"estimated">;
+            readonly id: Schema.String;
+        }>;
+        readonly pricing: Schema.Struct<{
+            readonly basis: Schema.Literal<"catalog-reference">;
+            readonly currency: Schema.Literal<"USD">;
+            readonly source: Schema.Struct<{
+                readonly kind: Schema.Literal<"configured-profile">;
+                readonly id: Schema.String;
+                readonly asOf: Schema.NullOr<Schema.Number>;
+                readonly profileDigest: Schema.String;
+            }>;
+            readonly requestModel: Schema.String;
+            readonly selector: Schema.String;
+            readonly match: Schema.Literals<readonly ["exact", "provider-wildcard"]>;
+            readonly ratesPerMTok: Schema.Struct<{
+                readonly input: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+                readonly output: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+                readonly cacheRead: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+                readonly cacheWrite: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+            }>;
+        }>;
+        readonly charges: Schema.NonEmptyArray<Schema.Struct<{
+            readonly bucket: Schema.Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+            readonly tokens: Schema.Number;
+            readonly ratePerMTok: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+            readonly amount: Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+        }>>;
+        readonly missing: Schema.$Array<Schema.Struct<{
+            readonly bucket: Schema.Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+            readonly reason: Schema.Literals<readonly ["tokens-unknown", "rate-unknown"]>;
+        }>>;
+    }>>;
+}>;
+export type JudgeUsageAttachment = Schema.Schema.Type<typeof AttachmentSchema>;
+export declare const JudgeUsageAttachmentSchema: Schema.Struct<{
+    readonly collection: Schema.Union<readonly [Schema.Struct<{
+        readonly state: Schema.Literal<"complete">;
+        readonly limitations: Schema.Tuple<readonly []>;
+    }>, Schema.Struct<{
+        readonly state: Schema.Literal<"partial">;
+        readonly limitations: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["capture-failed", "capture-interrupted"]>;
+            readonly stage: Schema.String;
+        }>, Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["collection-cap-reached", "unsupported-input"]>;
+            readonly omittedAtLeast: Schema.Number;
+        }>]>>;
+    }>]>;
+    readonly calls: Schema.$Array<Schema.Struct<{
+        readonly callId: Schema.String;
+        readonly entryIndex: Schema.Number;
+        readonly entryId: Schema.Codec<import("../../../index.js").AssertionEntryId, string, never, never>;
+        readonly logicalOrdinal: Schema.Number;
+        readonly transmissionOrdinal: Schema.Number;
+        readonly operation: Schema.Literals<readonly ["score", "classify", "extract", "batchClassify"]>;
+        readonly requestModel: Schema.String;
+        readonly transportProvider: Schema.Literals<readonly ["openai", "vercel", "openrouter", "typesafe"]>;
+        readonly provider: Schema.NullOr<Schema.String>;
+        readonly model: Schema.NullOr<Schema.String>;
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled", "unknown"]>;
+        readonly httpStatus: Schema.NullOr<Schema.Number>;
+        readonly inputTokens: Schema.NullOr<Schema.Number>;
+        readonly inputTotalTokens: Schema.NullOr<Schema.Number>;
+        readonly outputTokens: Schema.NullOr<Schema.Number>;
+        readonly cacheReadTokens: Schema.NullOr<Schema.Number>;
+        readonly cacheWriteTokens: Schema.NullOr<Schema.Number>;
+        readonly cost: Schema.NullOr<Schema.Struct<{
+            readonly amount: Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+            readonly currency: Schema.Codec<import("../source-receipt/model.js").CurrencyCode, string, never, never>;
+            readonly source: Schema.Struct<{
+                readonly kind: Schema.Literal<"reported">;
+                readonly id: Schema.String;
+            }>;
+        }>>;
+        readonly receipt: Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["available", "unavailable"]>;
+            readonly reason: Schema.NullOr<Schema.Literals<readonly ["response-unavailable", "cancelled", "response-too-large", "invalid-json", "usage-not-reported", "invalid-usage", "response-model-too-large"]>>;
+            readonly responseDigest: Schema.NullOr<Schema.String>;
+            readonly fields: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.Literals<readonly ["model", "provider", "usage.completion_tokens", "usage.cost", "usage.input_tokens", "usage.output_tokens", "usage.prompt_tokens", "usage.prompt_tokens_details.cache_write_tokens", "usage.prompt_tokens_details.cached_tokens", "usage.total_tokens"]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Null]>;
+            }>>;
+        }>;
+    }>>;
+    readonly priceReceipts: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literal<"judge-call-price-estimate">;
+        readonly callId: Schema.String;
+        readonly state: Schema.Literals<readonly ["complete", "partial"]>;
+        readonly amount: Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+        readonly currency: Schema.Literal<"USD">;
+        readonly source: Schema.Struct<{
+            readonly kind: Schema.Literal<"estimated">;
+            readonly id: Schema.String;
+        }>;
+        readonly pricing: Schema.Struct<{
+            readonly basis: Schema.Literal<"catalog-reference">;
+            readonly currency: Schema.Literal<"USD">;
+            readonly source: Schema.Struct<{
+                readonly kind: Schema.Literal<"configured-profile">;
+                readonly id: Schema.String;
+                readonly asOf: Schema.NullOr<Schema.Number>;
+                readonly profileDigest: Schema.String;
+            }>;
+            readonly requestModel: Schema.String;
+            readonly selector: Schema.String;
+            readonly match: Schema.Literals<readonly ["exact", "provider-wildcard"]>;
+            readonly ratesPerMTok: Schema.Struct<{
+                readonly input: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+                readonly output: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+                readonly cacheRead: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+                readonly cacheWrite: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+            }>;
+        }>;
+        readonly charges: Schema.NonEmptyArray<Schema.Struct<{
+            readonly bucket: Schema.Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+            readonly tokens: Schema.Number;
+            readonly ratePerMTok: Schema.NullOr<Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+            readonly amount: Schema.Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+        }>>;
+        readonly missing: Schema.$Array<Schema.Struct<{
+            readonly bucket: Schema.Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+            readonly reason: Schema.Literals<readonly ["tokens-unknown", "rate-unknown"]>;
+        }>>;
+    }>>;
+}>;
+export declare function validateJudgeUsageAttachment(value: JudgeUsageAttachment): readonly RecordAttachmentIssue[];
+export {};

package/dist/record/family/judge-usage/schema.js

@@ -0,0 +1,18 @@
+import { createRequire as __niceevalCreateRequire } from "node:module";
+const __niceevalRequire = __niceevalCreateRequire(import.meta.url);
+const __niceevalCanonical = __niceevalRequire("./schema.cjs");
+const __niceevalExport0 = __niceevalCanonical["JudgePriceReceiptSchema"];
+export { __niceevalExport0 as JudgePriceReceiptSchema };
+const __niceevalExport1 = __niceevalCanonical["JudgeUsageAttachmentSchema"];
+export { __niceevalExport1 as JudgeUsageAttachmentSchema };
+const __niceevalExport2 = __niceevalCanonical["JudgeUsageCallSchema"];
+export { __niceevalExport2 as JudgeUsageCallSchema };
+const __niceevalExport3 = __niceevalCanonical["JudgeUsageLimits"];
+export { __niceevalExport3 as JudgeUsageLimits };
+const __niceevalExport4 = __niceevalCanonical["JudgeUsageModelSchema"];
+export { __niceevalExport4 as JudgeUsageModelSchema };
+const __niceevalExport5 = __niceevalCanonical["JudgeUsageReceiptPaths"];
+export { __niceevalExport5 as JudgeUsageReceiptPaths };
+const __niceevalExport6 = __niceevalCanonical["validateJudgeUsageAttachment"];
+export { __niceevalExport6 as validateJudgeUsageAttachment };
+//# sourceMappingURL=schema.js.map

package/dist/record/family/judge-usage/schema.js.map

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

package/dist/record/host/sqlite-host.cjs

@@ -31,6 +31,7 @@ const current_attachment_ts_1 = require("../writer/current-attachment.cjs");
 const errors_ts_3 = require("../writer/errors.cjs");
 const limits_ts_1 = require("../writer/limits.cjs");
 const types_ts_1 = require("./types.cjs");
+const index_ts_5 = require("../sqlite/index.cjs");
 const WRITE_DEADLINE_MS = 30000;
 const MAILBOX_COMMANDS = 64;
 const COLLECTION_READ_MAX_ROWS = 10000;
@@ -88,6 +89,45 @@ function exactMarker(value, key) {
     return descriptor?.enumerable && "value" in descriptor ? descriptor.value : undefined;
 }
 function hasOwnMarker(value, key) { return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, key); }
+/** Capture planning facts together, then release SQLite before any dispatch. */
+function captureReaderSnapshot(root) {
+    return effect_1.Effect.try({
+        try: () => {
+            const session = (0, index_ts_5.openOperationalRecordReadSession)(root);
+            try {
+                const summaries = [];
+                const resources = [];
+                const cores = new Map();
+                let afterRunId = "";
+                for (;;) {
+                    const page = session.readSealedRunSummaryPage(afterRunId, 100);
+                    summaries.push(...page.summaries);
+                    if (page.nextAfterRunId === null)
+                        break;
+                    afterRunId = page.nextAfterRunId;
+                }
+                for (const summary of summaries) {
+                    const core = session.readSealedRunCore(summary.runId);
+                    if (core !== undefined)
+                        cores.set(summary.runId, core);
+                }
+                afterRunId = "";
+                for (;;) {
+                    const page = session.listRunResources({ afterRunId, pageSize: 100 });
+                    resources.push(...page.runs);
+                    if (page.nextAfterRunId === null)
+                        break;
+                    afterRunId = page.nextAfterRunId;
+                }
+                return Object.freeze({ summaries: Object.freeze(summaries), resources: Object.freeze(resources), cutoff: session.publicationCutoff(), cores });
+            }
+            finally {
+                session.close();
+            }
+        },
+        catch: (cause) => cause instanceof index_ts_4.SqliteRecordError ? cause : new index_ts_4.SqliteRecordError("record-sqlite-error", "record-reader-snapshot", "Could not capture reader facts", { cause }),
+    });
+}
 const runSessions = new WeakMap();
 const attemptSessions = new WeakMap();
 const selectedAttemptCapabilities = new WeakMap();
@@ -607,13 +647,7 @@ function decodeCore(core) {
 function readCore(runtime, runId) {
     if (runtime.lifecycle.closed)
         return effect_1.Effect.fail(new errors_ts_2.RecordReaderClosed({ code: "record-reader-closed" }));
-    const cached = runtime.coreCache.get(runId);
-    return cached === undefined ? sqliteEffect(() => runtime.client.readSealedRunCore(runId)).pipe(effect_1.Effect.mapError((error) => error.code === "record-database-invalid" || error.code === "record-seal-incomplete"
-        ? new errors_ts_2.RecordIntegrityFailure({ code: "record-integrity-failure", runId, reason: "publication-closure-invalid" })
-        : error), effect_1.Effect.tap((core) => effect_1.Effect.sync(() => {
-        if (core !== undefined)
-            runtime.coreCache.set(runId, core);
-    }))) : effect_1.Effect.succeed(cached);
+    return effect_1.Effect.succeed(runtime.coreCache.get(runId));
 }
 function runRef(runtime, runId) {
     const old = runtime.runRefs.get(runId);
@@ -882,6 +916,16 @@ function readCollectionWhole(runtime, owner, definition) {
     });
 }
 function makeReadSession(runtime) {
+    const listRunResources = (input = {}) => effect_1.Effect.suspend(() => {
+        if (runtime.lifecycle.closed)
+            return effect_1.Effect.fail(new errors_ts_2.RecordReaderClosed({ code: "record-reader-closed" }));
+        const pageSize = input.pageSize ?? 100;
+        if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 256)
+            return effect_1.Effect.fail(new errors_ts_2.RecordHandleInvalid({ code: "record-handle-invalid" }));
+        const candidates = runtime.snapshot.resources.filter((run) => run.runId > (input.afterRunId ?? "") && (input.invocationId === undefined || run.invocationId === input.invocationId));
+        const runs = Object.freeze(candidates.slice(0, pageSize));
+        return effect_1.Effect.succeed(Object.freeze({ cutoff: runtime.snapshot.cutoff, runs, nextAfterRunId: candidates.length > pageSize ? runs.at(-1).runId : null }));
+    });
     const selectRuns = (request) => effect_1.Effect.gen(function* () {
         if (runtime.lifecycle.closed)
             return yield* effect_1.Effect.fail(new errors_ts_2.RecordReaderClosed({ code: "record-reader-closed" }));
@@ -889,7 +933,7 @@ function makeReadSession(runtime) {
         const cores = [];
         let after = "";
         while (true) {
-            const page = yield* sqliteEffect(() => runtime.client.listSealedRunSummaries(after, 100));
+            const page = runtime.snapshot.summaries.filter((summary) => summary.runId > after).slice(0, 100);
             if (page.length === 0)
                 break;
             for (const summary of page) {
@@ -962,6 +1006,7 @@ function makeReadSession(runtime) {
         return Object.freeze({ selection, attachments: runtime.catalog });
     });
     return Object.freeze({
+        listRunResources,
         selectRuns,
         readRun: readRunEntry,
         readAttempt: readAttemptEntry,
@@ -978,7 +1023,8 @@ function openRead(root, catalog) {
         const projectState = yield* index_ts_4.ProjectStateDatabase;
         const client = (yield* projectState.bind(rootPath)).record;
         const lifecycle = { closed: false };
-        const runtime = { root, client, catalog, lifecycle, runs: new WeakMap(), attempts: new WeakMap(), owners: new WeakMap(), selections: new WeakSet(), coreCache: new Map(), runRefs: new Map(), attemptRefs: new Map(), content: new WeakMap() };
+        const snapshot = yield* captureReaderSnapshot(rootPath);
+        const runtime = { root, client, catalog, lifecycle, snapshot, runs: new WeakMap(), attempts: new WeakMap(), owners: new WeakMap(), selections: new WeakSet(), coreCache: new Map(snapshot.cores), runRefs: new Map(), attemptRefs: new Map(), content: new WeakMap() };
         yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => { lifecycle.closed = true; }));
         return makeReadSession(runtime);
     });