@openpond/evals 0.12.4 → 0.12.6

package/dist/learning/admission.js

@@ -88,7 +88,7 @@ export function taskRecordFromEvidence(evidence, definition) {
     return TaskRecordSchema.parse({
         id: evidence.id, clusterKey: evidence.submission.familyKey, split: evidence.submission.split,
         input: evidence.submission.input, expectedOutput: evidence.submission.expected,
-        policyVisibleContext: { instructions: definition.instructions },
+        policyVisibleContext: evidence.submission.policyVisibleContext ?? { instructions: definition.instructions },
         privilegedContextRef: evidence.submission.evaluatorContext === null ? null : `task-evidence:${evidence.contentHash}`,
         artifactRefs: evidence.submission.assets, tags: [definition.category],
         ...(requiredOutputs === undefined ? {} : { requiredOutputs }),

package/dist/learning/contracts.js

@@ -89,6 +89,13 @@ export const LearningReviewOriginSchema = z
     rewardBinding: LearningRevisionRefSchema,
 })
     .strict();
+/** A host must verify this retained import receipt before resolving package
+ * bytes. This portable reference is neither an approval nor an access grant. */
+export const LearningDatasetOriginSchema = z.object({
+    receiptId: ReleaseIdSchema,
+    packageHash: ReleaseHashSchema,
+    taskset: LearningRevisionRefSchema,
+}).strict();
 export const LearningSourceContentSchema = z
     .object({
     schemaVersion: z.literal("openpond.learningSource.v1"),
@@ -102,6 +109,7 @@ export const LearningSourceContentSchema = z
     mapping: TaskSourceMappingSchema.nullable(),
     adapterVersion: z.string().trim().min(1).max(200).nullable(),
     reviewOrigin: LearningReviewOriginSchema.optional(),
+    datasetOrigin: LearningDatasetOriginSchema.optional(),
     /** Host-retained authorization for materializing neutral conversation
      * evidence. The receipt is reauthorized at preparation and paid admission;
      * this portable reference alone never grants access or training consent. */
@@ -115,6 +123,8 @@ export const LearningSourceContentSchema = z
 })
     .strict()
     .superRefine((source, context) => {
+    if (source.datasetOrigin && (source.reviewOrigin || source.capturedOrigin))
+        context.addIssue({ code: "custom", path: ["datasetOrigin"], message: "Choose one retained source origin." });
     if (source.kind !== "direct" && !source.mapping)
         context.addIssue({
             code: "custom",
@@ -149,6 +159,8 @@ export const TaskExampleSubmissionSchema = z
     familyKey: ReleaseIdSchema.nullable(),
     split: TaskSplitSchema,
     input: LearningJsonObjectSchema,
+    /** Per-example policy context remains separate from evaluator-only data. */
+    policyVisibleContext: LearningJsonObjectSchema.optional(),
     observedOutput: LearningJsonObjectSchema.nullable(),
     expected: LearningJsonObjectSchema.nullable(),
     evaluatorContext: LearningJsonObjectSchema.nullable(),

package/dist/learning/index.js

@@ -25,6 +25,7 @@ export * from "./reward-fixture-executor.js";
 export * from "./iteration-reservation-contracts.js";
 export * from "./iteration-dispatch-contracts.js";
 export * from "./iteration-dispatch-worker.js";
+export * from "./iteration-dispatch-deferral.js";
 export * from "./iteration-candidate-decision.js";
 export { resolveLearningTrainingParent } from "./iteration-training-parent.js";
 export * from "./schedule-contracts.js";

package/dist/learning/iteration-dispatch-commands.js

@@ -22,7 +22,7 @@ export async function commandLearningIterationDispatch(tx, input, now) {
     const resumed = LearningIterationDispatchSchema.parse({ ...dispatch, revision: dispatch.revision + 1,
         state: dispatch.execution ? "submitted" : dispatch.submission ? "prepared" : "preparing",
         cancelRequestedAt: cancelling ? dispatch.cancelRequestedAt ?? now : null,
-        consecutiveFailures: 0, nextAttemptAt: null, lastError: null, updatedAt: now });
+        consecutiveFailures: 0, nextAttemptAt: null, lastError: null, admission: null, updatedAt: now });
     // Preserve an in-flight lease. Its owner observes cancellation on the next
     // transition, and a replacement worker may claim only after that lease ends.
     await tx.put("dispatch", resumed, dispatch.revision, { parentId: iteration.id, status: resumed.state });

package/dist/learning/iteration-dispatch-contracts.js

@@ -8,6 +8,24 @@ export const LearningIterationSubmissionSchema = z.object({
     protocol: ReleaseIdSchema,
     payload: LearningJsonObjectSchema,
 }).strict();
+/** Normal capacity/calendar waits are not failed execution attempts. */
+export const LearningIterationAdmissionSchema = z.discriminatedUnion("status", [
+    z.object({ status: z.literal("ready") }).strict(),
+    z.object({ status: z.literal("deferred"), retryAt: ReleaseTimestampSchema,
+        reason: z.string().trim().min(1).max(2_000) }).strict(),
+]);
+/** The execution owner has durably rejected/fenced this exact attempt before
+ * creating an execution or spending. A timeout/absence read is not this proof. */
+export const LearningIterationSubmissionDeferralSchema = z.object({
+    scope: ReleaseIdSchema,
+    dispatchId: ReleaseIdSchema,
+    submissionHash: z.string().regex(/^[a-f0-9]{64}$/),
+    leaseGeneration: z.number().int().positive(),
+    status: z.literal("deferred"),
+    retryAt: ReleaseTimestampSchema,
+    reason: z.string().trim().min(1).max(2_000),
+    receipt: ImmutableReleaseRefSchema,
+}).strict();
 export const LearningIterationDispatchSchema = z.object({
     schemaVersion: z.literal("openpond.learningIterationDispatch.v1"),
     id: ReleaseIdSchema,
@@ -28,6 +46,8 @@ export const LearningIterationDispatchSchema = z.object({
     leaseExpiresAt: ReleaseTimestampSchema.nullable(),
     consecutiveFailures: z.number().int().nonnegative(),
     nextAttemptAt: ReleaseTimestampSchema.nullable(),
+    admission: LearningIterationAdmissionSchema.nullable().optional(),
+    lastSubmissionDeferral: LearningIterationSubmissionDeferralSchema.optional(),
     lastError: z.string().max(20_000).nullable(),
     createdAt: ReleaseTimestampSchema,
     updatedAt: ReleaseTimestampSchema,
@@ -37,6 +57,13 @@ export const LearningIterationDispatchSchema = z.object({
     }
     if (value.submissionStartedAt && !value.submission)
         context.addIssue({ code: "custom", path: ["submission"], message: "A started dispatch requires its persisted submission." });
+    if (value.admission?.status === "deferred" && (value.submissionStartedAt || value.state !== "prepared" || value.nextAttemptAt !== value.admission.retryAt)) {
+        context.addIssue({ code: "custom", path: ["admission"], message: "Admission deferral requires an unstarted prepared dispatch and its retry time." });
+    }
+    if (value.lastSubmissionDeferral && (value.lastSubmissionDeferral.dispatchId !== value.id ||
+        value.lastSubmissionDeferral.submissionHash !== value.submissionHash || value.lastSubmissionDeferral.leaseGeneration >= value.leaseGeneration)) {
+        context.addIssue({ code: "custom", path: ["lastSubmissionDeferral"], message: "A retained deferral must identify an earlier fenced attempt of this submission." });
+    }
     if (value.execution && !value.submissionStartedAt)
         context.addIssue({ code: "custom", path: ["execution"], message: "An execution requires a started dispatch." });
     if (["prepared", "submitted"].includes(value.state) && !value.submission)

package/dist/learning/iteration-dispatch-deferral.js

@@ -0,0 +1,28 @@
+import { LearningIterationSchema } from "./contracts.js";
+import { LearningDomainError } from "./errors.js";
+import { LearningIterationDispatchSchema, LearningIterationSubmissionDeferralSchema } from "./iteration-dispatch-contracts.js";
+/** Call under the dispatch's scope lock. The execution owner must first fence
+ * this attempt and prove no execution/charge exists. When the owner shares this
+ * repository, commit this mutation in its native admission transaction instead:
+ * late submits then fail the same generation fence as lease replacement.
+ */
+export async function deferLearningIterationSubmission(tx, scope, current, iteration, value, now) {
+    const outcome = LearningIterationSubmissionDeferralSchema.parse(value);
+    if (outcome.scope !== scope || outcome.dispatchId !== current.id || outcome.submissionHash !== current.submissionHash ||
+        outcome.leaseGeneration !== current.leaseGeneration || !current.submissionStartedAt || current.execution ||
+        current.state !== "prepared" || !current.leaseOwner ||
+        !current.leaseExpiresAt || Date.parse(current.leaseExpiresAt) <= Date.parse(now) ||
+        iteration.id !== current.iterationId || (iteration.status !== "dispatching" && !(current.cancelRequestedAt && iteration.status === "cancelling")))
+        throw new LearningDomainError("learning_submission_deferral_fenced", 409);
+    const retryAt = new Date(Math.max(Date.parse(outcome.retryAt), Date.parse(now) + 1_000)).toISOString();
+    const dispatch = LearningIterationDispatchSchema.parse({ ...current, revision: current.revision + 1,
+        submissionStartedAt: null, leaseGeneration: current.leaseGeneration + 1, leaseOwner: null, leaseExpiresAt: null,
+        admission: current.cancelRequestedAt ? null : { status: "deferred", reason: outcome.reason, retryAt },
+        nextAttemptAt: current.cancelRequestedAt ? null : retryAt, lastSubmissionDeferral: outcome,
+        consecutiveFailures: 0, lastError: null, updatedAt: now });
+    await tx.put("dispatch", dispatch, current.revision, { parentId: current.iterationId, status: dispatch.state });
+    if (iteration.failure)
+        await tx.put("iteration", LearningIterationSchema.parse({ ...iteration,
+            revision: iteration.revision + 1, failure: null, updatedAt: now }), iteration.revision, { parentId: current.chainId, status: iteration.status });
+    return dispatch;
+}

package/dist/learning/iteration-dispatch-worker.js

@@ -2,8 +2,10 @@ import { contentHash } from "@openpond/harness";
 import { LearningIterationSchema } from "./contracts.js";
 import { LearningDomainError } from "./errors.js";
 import { LearningChainSchema, LearningIterationReservationSchema } from "./iteration-reservation-contracts.js";
-import { LearningIterationDispatchSchema, LearningIterationObservationSchema, LearningIterationSubmissionSchema, } from "./iteration-dispatch-contracts.js";
+import { LearningIterationAdmissionSchema, LearningIterationDispatchSchema, LearningIterationObservationSchema, LearningIterationSubmissionSchema, } from "./iteration-dispatch-contracts.js";
 import { requireLearningRelease, requireLearningResource } from "./repository.js";
+import { deferLearningIterationSubmission } from "./iteration-dispatch-deferral.js";
+import { LearningIterationSubmissionDeferralSchema } from "./iteration-dispatch-contracts.js";
 const closed = new Set(["accepted", "rejected", "failed", "cancelled", "completed_without_candidate"]);
 export function createLearningIterationWorker(repository, executor, options) {
     const now = options.now ?? (() => new Date().toISOString());
@@ -20,7 +22,7 @@ export function createLearningIterationWorker(repository, executor, options) {
             const stamp = now();
             if (current?.state === "settled" || (current?.state === "blocked" && !current.cancelRequestedAt)
                 || (current?.leaseExpiresAt && Date.parse(current.leaseExpiresAt) > Date.parse(stamp))
-                || (current?.nextAttemptAt && Date.parse(current.nextAttemptAt) > Date.parse(stamp)))
+                || (!current?.cancelRequestedAt && current?.nextAttemptAt && Date.parse(current.nextAttemptAt) > Date.parse(stamp)))
                 return null;
             const policy = await requireLearningRelease(tx, "policy", iteration.policy);
             if (policy.executionOwner !== options.executionOwner)
@@ -80,7 +82,7 @@ export function createLearningIterationWorker(repository, executor, options) {
         });
         await tx.put("iteration", updated, iteration.revision, { parentId: current.chainId, status });
         await saveDispatch(tx, current, { state: terminal ? "settled" : "submitted", execution: outcome?.execution ?? current.execution,
-            terminalReceipt: outcome?.receipt ?? null, leaseOwner: null, leaseExpiresAt: null,
+            terminalReceipt: outcome?.receipt ?? null, leaseOwner: null, leaseExpiresAt: null, admission: null,
             nextAttemptAt: terminal ? null : new Date(Date.parse(now()) + 5_000).toISOString(), consecutiveFailures: 0, lastError: null });
         if (terminal) {
             const reservation = await requireLearningResource(tx, "reservation", iteration.id);
@@ -124,6 +126,25 @@ export function createLearningIterationWorker(repository, executor, options) {
                     return read();
                 dispatch = prepared;
             }
+            if (!dispatch.submissionStartedAt && !dispatch.cancelRequestedAt && executor.admit) {
+                const checkedAt = now();
+                const admission = LearningIterationAdmissionSchema.parse(await bounded(input => executor.admit(input)));
+                if (admission.status === "deferred") {
+                    if (Date.parse(admission.retryAt) <= Date.parse(checkedAt))
+                        throw new LearningDomainError("learning_admission_retry_time_invalid", 409);
+                    await fenced(scope, dispatch, async (tx, current, iteration) => {
+                        if (current.cancelRequestedAt)
+                            return settle(tx, current, iteration, null);
+                        const retryAt = new Date(Math.max(Date.parse(admission.retryAt), Date.parse(now()) + 1_000)).toISOString();
+                        await saveDispatch(tx, current, { admission: { ...admission, retryAt }, nextAttemptAt: retryAt,
+                            consecutiveFailures: 0, lastError: null, leaseOwner: null, leaseExpiresAt: null });
+                        if (iteration.failure)
+                            await tx.put("iteration", LearningIterationSchema.parse({ ...iteration,
+                                revision: iteration.revision + 1, failure: null, updatedAt: now() }), iteration.revision, { parentId: current.chainId, status: iteration.status });
+                    });
+                    return read();
+                }
+            }
             const starting = await fenced(scope, dispatch, async (tx, current, iteration) => {
                 if (current.cancelRequestedAt && !current.submissionStartedAt) {
                     await settle(tx, current, iteration, null);
@@ -134,7 +155,7 @@ export function createLearningIterationWorker(repository, executor, options) {
                     await saveDispatch(tx, current, { leaseOwner: null, leaseExpiresAt: null });
                     return null;
                 }
-                return saveDispatch(tx, current, { submissionStartedAt: current.submissionStartedAt ?? now() });
+                return saveDispatch(tx, current, { submissionStartedAt: current.submissionStartedAt ?? now(), admission: null });
             });
             if (!starting)
                 return read();
@@ -147,6 +168,14 @@ export function createLearningIterationWorker(repository, executor, options) {
                 dispatch = refreshed;
                 observed = dispatch.cancelRequestedAt ? await bounded(input => executor.cancel(input)) : await bounded(input => executor.submit(input));
             }
+            if (observed.status === "deferred") {
+                const outcome = LearningIterationSubmissionDeferralSchema.parse(observed);
+                if (outcome.scope !== scope || outcome.dispatchId !== dispatch.id || outcome.submissionHash !== dispatch.submissionHash ||
+                    outcome.leaseGeneration !== dispatch.leaseGeneration)
+                    throw new LearningDomainError("learning_execution_identity_mismatch", 409);
+                await fenced(scope, dispatch, (tx, current, iteration) => deferLearningIterationSubmission(tx, scope, current, iteration, outcome, now()));
+                return read();
+            }
             const outcome = LearningIterationObservationSchema.parse(observed);
             if (outcome.scope !== scope || outcome.dispatchId !== dispatch.id || outcome.submissionHash !== dispatch.submissionHash
                 || (dispatch.execution && contentHash(outcome.execution) !== contentHash(dispatch.execution)))
@@ -165,7 +194,7 @@ export function createLearningIterationWorker(repository, executor, options) {
                 const blocked = failures > acquired.policy.limits.maxRetries;
                 const message = (error instanceof Error ? error.message : "Learning dispatch failed.").slice(0, 20_000);
                 await saveDispatch(tx, current, { state: blocked ? "blocked" : current.state, consecutiveFailures: failures,
-                    lastError: message, leaseOwner: null, leaseExpiresAt: null,
+                    lastError: message, leaseOwner: null, leaseExpiresAt: null, admission: null,
                     nextAttemptAt: blocked ? null : new Date(Date.parse(now()) + Math.min(60_000, 1_000 * 2 ** Math.min(failures, 6))).toISOString() });
                 const updated = LearningIterationSchema.parse({ ...iteration, revision: iteration.revision + 1, retryCount: iteration.retryCount + 1,
                     failure: { code: blocked ? "learning_dispatch_attention_required" : "learning_dispatch_retry_pending", message }, updatedAt: now() });

package/dist/learning/reward-authoring.js

@@ -1,4 +1,4 @@
-import { RewardReleaseSchema, createRewardRelease, feedbackKeyForReward } from "../rewards.js";
+import { RewardReleaseSchema, createRewardRelease } from "../rewards.js";
 import { assertBoundedTaskJson } from "../task-schema.js";
 import { RewardAuthoringFieldsSchema, RewardFixtureAuthoringFieldsSchema } from "./authoring.js";
 import { createLearningTextAsset, verifyLearningTextAsset } from "./assets.js";
@@ -65,7 +65,9 @@ export function compileRewardAuthoring(input) {
     const assets = [...(asset ? [asset] : []), ...(fixtureAsset ? [fixtureAsset] : [])];
     const reward = createRewardRelease({
         schemaVersion: "openpond.rewardRelease.v1", id: input.id, revision: (base?.revision ?? 0) + 1,
-        name: fields.name, description: fields.description, feedbackKey: fields.feedbackKey ?? feedbackKeyForReward({ id: input.id }), implementation,
+        // Derived defaults belong to feedbackKeyForReward at read time. Adding an
+        // unauthored field here changes the immutable calibration snapshot.
+        name: fields.name, description: fields.description, ...(fields.feedbackKey === undefined ? {} : { feedbackKey: fields.feedbackKey }), implementation,
         rawScore: fields.kind === "learned_model" ? { minimum: authoringNumber(fields.minimum, "Minimum score"), maximum: authoringNumber(fields.maximum, "Maximum score") } : { minimum: 0, maximum: 1 },
         assets: assets.map(value => value.asset), ...(fixtureAsset ? { fixtureSetRef: fixtureAsset.asset } : {}),
         ...(calibrationCheckRef ? { calibrationCheckRef } : {}),

package/dist/types/javascript-isolate-process.d.ts

@@ -1,4 +1,11 @@
 import { type JavaScriptIsolateInput } from "./javascript-isolate.js";
+/** Created only by the trusted parent wall timer, never from guest error text.
+ * The process executor rejects with this error only after child exit. */
+export declare class JavaScriptVerifierHostTimeoutError extends Error {
+    readonly timeoutMs: number;
+    readonly elapsedMs: number;
+    constructor(timeoutMs: number, elapsedMs: number);
+}
 /** A Node subprocess owns the interpreter; completion always waits for its exit. */
 export declare function executeJavaScriptIsolateInProcess(input: JavaScriptIsolateInput & {
     stripTypeScript?: boolean;

package/dist/types/javascript-isolate-process.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"javascript-isolate-process.d.ts","sourceRoot":"","sources":["../../src/javascript-isolate-process.ts"],"names":[],"mappings":"AACA,OAAO,EAAmE,KAAK,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAGvI,oFAAoF;AACpF,wBAAsB,iCAAiC,CAAC,KAAK,EAAE,sBAAsB,GAAG;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CA0DvI"}
+{"version":3,"file":"javascript-isolate-process.d.ts","sourceRoot":"","sources":["../../src/javascript-isolate-process.ts"],"names":[],"mappings":"AACA,OAAO,EAAmE,KAAK,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAGvI;yEACyE;AACzE,qBAAa,kCAAmC,SAAQ,KAAK;IAC/C,QAAQ,CAAC,SAAS,EAAE,MAAM;IAAE,QAAQ,CAAC,SAAS,EAAE,MAAM;IAAlE,YAAqB,SAAS,EAAE,MAAM,EAAW,SAAS,EAAE,MAAM,EAGjE;CACF;AAED,oFAAoF;AACpF,wBAAsB,iCAAiC,CAAC,KAAK,EAAE,sBAAsB,GAAG;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CA8EvI"}

package/dist/types/javascript-isolate.d.ts

@@ -12,6 +12,8 @@ export declare class JavaScriptIsolateExecutionError extends Error {
     constructor(message: string);
 }
 /** Authored code is interpreter data, with no host functions or module loader. */
-export declare function executeJavaScriptIsolate(input: JavaScriptIsolateInput): Promise<unknown>;
+export declare function executeJavaScriptIsolate(input: JavaScriptIsolateInput, host?: {
+    onExecutionReady(): void;
+}): Promise<unknown>;
 export declare function validateJavaScriptIsolateInput(input: JavaScriptIsolateInput): void;
 //# sourceMappingURL=javascript-isolate.d.ts.map

package/dist/types/javascript-isolate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"javascript-isolate.d.ts","sourceRoot":"","sources":["../../src/javascript-isolate.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,EAAE,UAAU,GAAG,aAAa,GAAG,WAAW,GAAG,QAAQ,CAAC;CAClE;AAED,qBAAa,+BAAgC,SAAQ,KAAK;IACxD,YAAY,OAAO,EAAE,MAAM,EAAoE;CAChG;AAED,kFAAkF;AAClF,wBAAsB,wBAAwB,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,CAuC9F;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAKlF"}
+{"version":3,"file":"javascript-isolate.d.ts","sourceRoot":"","sources":["../../src/javascript-isolate.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,EAAE,UAAU,GAAG,aAAa,GAAG,WAAW,GAAG,QAAQ,CAAC;CAClE;AAED,qBAAa,+BAAgC,SAAQ,KAAK;IACxD,YAAY,OAAO,EAAE,MAAM,EAAoE;CAChG;AAED,kFAAkF;AAClF,wBAAsB,wBAAwB,CAAC,KAAK,EAAE,sBAAsB,EAAE,IAAI,CAAC,EAAE;IAAE,gBAAgB,IAAI,IAAI,CAAA;CAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CA0CnI;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAKlF"}

package/dist/types/javascript-verifier-node.d.ts

@@ -1,5 +1,6 @@
 import type { executeJavaScriptVerifier } from "./javascript-verifier.js";
 import { type JavaScriptVerifierResult } from "./javascript-verifier-contract.js";
+export { JavaScriptVerifierHostTimeoutError } from "./javascript-isolate-process.js";
 /** Resolves/rejects only after the execution owner has stopped the worker. */
 export declare function executeJavaScriptVerifierInWorker(input: Parameters<typeof executeJavaScriptVerifier>[0]): Promise<JavaScriptVerifierResult>;
 /** Uses a Node child process and waits for exit on success, failure, or cancellation. */

package/dist/types/javascript-verifier-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"javascript-verifier-node.d.ts","sourceRoot":"","sources":["../../src/javascript-verifier-node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EAAiE,KAAK,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAIjJ,8EAA8E;AAC9E,wBAAsB,iCAAiC,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAGjJ;AAED,yFAAyF;AACzF,wBAAsB,kCAAkC,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAGlJ"}
+{"version":3,"file":"javascript-verifier-node.d.ts","sourceRoot":"","sources":["../../src/javascript-verifier-node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EAAiE,KAAK,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAGjJ,OAAO,EAAE,kCAAkC,EAAE,MAAM,iCAAiC,CAAC;AAErF,8EAA8E;AAC9E,wBAAsB,iCAAiC,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAGjJ;AAED,yFAAyF;AACzF,wBAAsB,kCAAkC,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAGlJ"}

package/dist/types/learning/batch-service.d.ts

@@ -306,6 +306,7 @@ export declare function prepareLearningBatch(transaction: LearningTransaction, i
             familyKey: string | null;
             split: "frozen_eval" | "test" | "train" | "validation";
             input: Record<string, import("zod").JSONType>;
+            policyVisibleContext?: Record<string, import("zod").JSONType> | undefined;
             observedOutput: Record<string, import("zod").JSONType> | null;
             expected: Record<string, import("zod").JSONType> | null;
             evaluatorContext: Record<string, import("zod").JSONType> | null;

package/dist/types/learning/batch-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch-service.d.ts","sourceRoot":"","sources":["../../../src/learning/batch-service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgC,KAAK,mBAAmB,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAA8E,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAErK,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAQ3M;AAED,kGAAkG;AAClG,wBAAsB,oBAAoB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsBzK;AAED,wBAAsB,8BAA8B,CAAC,WAAW,EAAE,mBAAmB,EAAE,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,CAKtI"}
+{"version":3,"file":"batch-service.d.ts","sourceRoot":"","sources":["../../../src/learning/batch-service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgC,KAAK,mBAAmB,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAA8E,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAErK,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAQ3M;AAED,kGAAkG;AAClG,wBAAsB,oBAAoB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsBzK;AAED,wBAAsB,8BAA8B,CAAC,WAAW,EAAE,mBAAmB,EAAE,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,CAKtI"}

package/dist/types/learning/contracts.d.ts

@@ -265,6 +265,17 @@ export declare const LearningReviewOriginSchema: z.ZodObject<{
         revision: z.ZodNumber;
     }, z.core.$strict>;
 }, z.core.$strict>;
+/** A host must verify this retained import receipt before resolving package
+ * bytes. This portable reference is neither an approval nor an access grant. */
+export declare const LearningDatasetOriginSchema: z.ZodObject<{
+    receiptId: z.ZodString;
+    packageHash: z.ZodString;
+    taskset: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export declare const LearningSourceContentSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"openpond.learningSource.v1">;
     id: z.ZodString;
@@ -326,6 +337,15 @@ export declare const LearningSourceContentSchema: z.ZodObject<{
             revision: z.ZodNumber;
         }, z.core.$strict>;
     }, z.core.$strict>>;
+    datasetOrigin: z.ZodOptional<z.ZodObject<{
+        receiptId: z.ZodString;
+        packageHash: z.ZodString;
+        taskset: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
     capturedOrigin: z.ZodOptional<z.ZodObject<{
         receiptId: z.ZodString;
         ownerUserId: z.ZodString;
@@ -399,6 +419,15 @@ export declare const LearningSourceSchema: z.ZodObject<{
             revision: z.ZodNumber;
         }, z.core.$strict>;
     }, z.core.$strict>>;
+    datasetOrigin: z.ZodOptional<z.ZodObject<{
+        receiptId: z.ZodString;
+        packageHash: z.ZodString;
+        taskset: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
     capturedOrigin: z.ZodOptional<z.ZodObject<{
         receiptId: z.ZodString;
         ownerUserId: z.ZodString;
@@ -432,6 +461,7 @@ export declare const TaskExampleSubmissionSchema: z.ZodObject<{
         validation: "validation";
     }>;
     input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    policyVisibleContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
     observedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
     expected: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
     evaluatorContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
@@ -500,6 +530,7 @@ export declare const TaskEvidenceContentSchema: z.ZodObject<{
             validation: "validation";
         }>;
         input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        policyVisibleContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
         observedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
         expected: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
         evaluatorContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
@@ -576,6 +607,7 @@ export declare const TaskEvidenceSchema: z.ZodObject<{
             validation: "validation";
         }>;
         input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        policyVisibleContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
         observedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
         expected: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
         evaluatorContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
@@ -2684,6 +2716,15 @@ export declare const LearningResourceSchema: z.ZodUnion<readonly [z.ZodObject<{
             revision: z.ZodNumber;
         }, z.core.$strict>;
     }, z.core.$strict>>;
+    datasetOrigin: z.ZodOptional<z.ZodObject<{
+        receiptId: z.ZodString;
+        packageHash: z.ZodString;
+        taskset: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
     capturedOrigin: z.ZodOptional<z.ZodObject<{
         receiptId: z.ZodString;
         ownerUserId: z.ZodString;
@@ -2725,6 +2766,7 @@ export declare const LearningResourceSchema: z.ZodUnion<readonly [z.ZodObject<{
             validation: "validation";
         }>;
         input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        policyVisibleContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
         observedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
         expected: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
         evaluatorContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;

package/dist/types/learning/contracts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../src/learning/contracts.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../src/learning/contracts.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAYjC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,wBAAgB,WAAW,CAAC,QAAQ,EAAE;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,mBAAmB,CAMtB;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,EAAE,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAM9F;AACD,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnE,OAAO,EAAE,CAAC,GACT,CAAC,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAG7B;AACD,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAKjF"}

package/dist/types/learning/index.d.ts

@@ -25,6 +25,7 @@ export * from "./reward-fixture-executor.js";
 export * from "./iteration-reservation-contracts.js";
 export * from "./iteration-dispatch-contracts.js";
 export * from "./iteration-dispatch-worker.js";
+export * from "./iteration-dispatch-deferral.js";
 export * from "./iteration-candidate-decision.js";
 export { resolveLearningTrainingParent } from "./iteration-training-parent.js";
 export * from "./schedule-contracts.js";

package/dist/types/learning/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/learning/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC;AAClD,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAE3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AAEtC,OAAO,EAAE,2BAA2B,EAAE,KAAK,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAChG,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/learning/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAE3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AAEtC,OAAO,EAAE,2BAA2B,EAAE,KAAK,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAChG,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC"}

package/dist/types/learning/iteration-dispatch-contracts.d.ts

@@ -6,6 +6,30 @@ export declare const LearningIterationSubmissionSchema: z.ZodObject<{
     protocol: z.ZodString;
     payload: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
 }, z.core.$strict>;
+/** Normal capacity/calendar waits are not failed execution attempts. */
+export declare const LearningIterationAdmissionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"ready">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"deferred">;
+    retryAt: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strict>], "status">;
+/** The execution owner has durably rejected/fenced this exact attempt before
+ * creating an execution or spending. A timeout/absence read is not this proof. */
+export declare const LearningIterationSubmissionDeferralSchema: z.ZodObject<{
+    scope: z.ZodString;
+    dispatchId: z.ZodString;
+    submissionHash: z.ZodString;
+    leaseGeneration: z.ZodNumber;
+    status: z.ZodLiteral<"deferred">;
+    retryAt: z.ZodString;
+    reason: z.ZodString;
+    receipt: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type LearningIterationSubmissionDeferral = z.infer<typeof LearningIterationSubmissionDeferralSchema>;
 export declare const LearningIterationDispatchSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"openpond.learningIterationDispatch.v1">;
     id: z.ZodString;
@@ -50,6 +74,26 @@ export declare const LearningIterationDispatchSchema: z.ZodObject<{
     leaseExpiresAt: z.ZodNullable<z.ZodString>;
     consecutiveFailures: z.ZodNumber;
     nextAttemptAt: z.ZodNullable<z.ZodString>;
+    admission: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"ready">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"deferred">;
+        retryAt: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>], "status">>>;
+    lastSubmissionDeferral: z.ZodOptional<z.ZodObject<{
+        scope: z.ZodString;
+        dispatchId: z.ZodString;
+        submissionHash: z.ZodString;
+        leaseGeneration: z.ZodNumber;
+        status: z.ZodLiteral<"deferred">;
+        retryAt: z.ZodString;
+        reason: z.ZodString;
+        receipt: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
     lastError: z.ZodNullable<z.ZodString>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
@@ -90,4 +134,5 @@ export declare const LearningIterationObservationSchema: z.ZodObject<{
 export type LearningIterationSubmission = z.infer<typeof LearningIterationSubmissionSchema>;
 export type LearningIterationDispatch = z.infer<typeof LearningIterationDispatchSchema>;
 export type LearningIterationObservation = z.infer<typeof LearningIterationObservationSchema>;
+export type LearningIterationAdmission = z.infer<typeof LearningIterationAdmissionSchema>;
 //# sourceMappingURL=iteration-dispatch-contracts.d.ts.map

package/dist/types/learning/iteration-dispatch-contracts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iteration-dispatch-contracts.d.ts","sourceRoot":"","sources":["../../../src/learning/iteration-dispatch-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;kFACkF;AAClF,eAAO,MAAM,iCAAiC;;;;kBAInC,CAAC;AAEZ,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiC1C,CAAC;AAEH;wEACwE;AACxE,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkB7C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAC5F,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AACxF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC"}
+{"version":3,"file":"iteration-dispatch-contracts.d.ts","sourceRoot":"","sources":["../../../src/learning/iteration-dispatch-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;kFACkF;AAClF,eAAO,MAAM,iCAAiC;;;;kBAInC,CAAC;AAEZ,wEAAwE;AACxE,eAAO,MAAM,gCAAgC;;;;;;8BAI3C,CAAC;AAEH;kFACkF;AAClF,eAAO,MAAM,yCAAyC;;;;;;;;;;;;kBAS3C,CAAC;AACZ,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAE5G,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0C1C,CAAC;AAEH;wEACwE;AACxE,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkB7C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAC5F,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AACxF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAC9F,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC"}

package/dist/types/learning/iteration-dispatch-deferral.d.ts

@@ -0,0 +1,71 @@
+import { type LearningIteration } from "./contracts.js";
+import { type LearningIterationDispatch } from "./iteration-dispatch-contracts.js";
+import type { LearningTransaction } from "./repository.js";
+/** Call under the dispatch's scope lock. The execution owner must first fence
+ * this attempt and prove no execution/charge exists. When the owner shares this
+ * repository, commit this mutation in its native admission transaction instead:
+ * late submits then fail the same generation fence as lease replacement.
+ */
+export declare function deferLearningIterationSubmission(tx: LearningTransaction, scope: string, current: LearningIterationDispatch, iteration: LearningIteration, value: unknown, now: string): Promise<{
+    schemaVersion: "openpond.learningIterationDispatch.v1";
+    id: string;
+    revision: number;
+    iterationId: string;
+    chainId: string;
+    policy: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    };
+    batch: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    };
+    state: "blocked" | "prepared" | "preparing" | "settled" | "submitted";
+    submission: {
+        provider: string;
+        protocol: string;
+        payload: Record<string, import("zod").JSONType>;
+    } | null;
+    submissionHash: string | null;
+    submissionStartedAt: string | null;
+    execution: {
+        id: string;
+        contentHash: string;
+    } | null;
+    terminalReceipt: {
+        id: string;
+        contentHash: string;
+    } | null;
+    cancelRequestedAt: string | null;
+    leaseOwner: string | null;
+    leaseGeneration: number;
+    leaseExpiresAt: string | null;
+    consecutiveFailures: number;
+    nextAttemptAt: string | null;
+    admission?: {
+        status: "ready";
+    } | {
+        status: "deferred";
+        retryAt: string;
+        reason: string;
+    } | null | undefined;
+    lastSubmissionDeferral?: {
+        scope: string;
+        dispatchId: string;
+        submissionHash: string;
+        leaseGeneration: number;
+        status: "deferred";
+        retryAt: string;
+        reason: string;
+        receipt: {
+            id: string;
+            contentHash: string;
+        };
+    } | undefined;
+    lastError: string | null;
+    createdAt: string;
+    updatedAt: string;
+}>;
+//# sourceMappingURL=iteration-dispatch-deferral.d.ts.map

package/dist/types/learning/iteration-dispatch-deferral.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iteration-dispatch-deferral.d.ts","sourceRoot":"","sources":["../../../src/learning/iteration-dispatch-deferral.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEjF,OAAO,EACL,KAAK,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAC5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D;;;;GAIG;AACH,wBAAsB,gCAAgC,CAAC,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,EAC3F,OAAO,EAAE,yBAAyB,EAAE,SAAS,EAAE,iBAAiB,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmB9F"}