@openpond/evals 0.10.10 → 0.11.1

package/CONTRACT.md

@@ -32,6 +32,19 @@ runtime processes.
 
 ## Compatibility policy
 
+Custom verifiers may declare `runtime: "sandbox_process"` when their private
+module needs filesystem or subprocess access. The requirement belongs to the
+immutable Reward implementation and compiled grader, so Model derivation,
+Reward rebinding, reviewed learning batches and training export retain it.
+Omitting `runtime` keeps the original isolated JavaScript behavior and hashes.
+
+A runtime declaration grants no execution permission. The host must use a
+quiescent sandbox with network egress blocked, keep the verifier private from
+the policy, enforce its deadline, stop its process group and complete cleanup
+before accepting a result. Isolated JavaScript executors reject a declared
+process runtime; callers must pass the grader's `runtime` to those executors.
+Declaring the runtime does not qualify a source package or its dependencies.
+
 - Schema versions are literal and independent from package semver.
 - `openpond.harnessRunManifest.v1` and `openpond.taskAttempt.v1` remain accepted
   host persistence formats during migration, but are not emitted as new public

package/LEARNING.md

@@ -339,3 +339,23 @@ Taskset output paths, media types, schema references and size bounds. Evidence
 conversion copies them into every task before grading or sealing a batch, so a
 changed output contract requires a new definition and new matching evidence and
 review receipts. Definitions without this field retain their existing hashes.
+
+## Nightly and task-count triggers
+
+Policies may use `trigger: { kind: "nightly", localTime: "20:00", timeZone:
+"America/New_York" }`. The durable timer computes the next local date in that
+IANA timezone. DST repeats use the earlier occurrence once; missing local times
+advance by the DST gap. Calendar edits recompute the due time; unchanged calendars
+retain it. Existing `schedule` policies retain elapsed-interval semantics.
+
+`trigger: { kind: "approved_count" }` uses `admission.minimumApprovedExamples`
+as its threshold and checks once per minute. Below-threshold checks advance the
+timer without creating iterations or fire records. Once ready, the same atomic
+reservation, consumption, budget, cooldown and execution-owner checks apply.
+Both new automatic triggers require reviewer authorization to enable.
+
+`service.inspectTaskQueue(context, modelProjectId?)` is a read-only snapshot of
+unique eligible, unconsumed training attempts across current policies. It
+deduplicates shared sources and excludes held-out family reservations. Paused
+policies retain pending tasks. An invalid policy yields a null count and explicit
+issues rather than a misleading zero. Source credentials cannot read the queue.

package/dist/javascript-verifier-contract.js

@@ -5,3 +5,8 @@ export const JavaScriptVerifierResultSchema = z.object({
     feedback: z.string().max(20_000),
     evidenceRefs: z.array(z.string().max(240)).max(1_000).default([]),
 }).strict();
+/** A process checker must never silently execute under different semantics. */
+export function assertIsolatedVerifierRuntime(runtime) {
+    if (runtime === "sandbox_process")
+        throw new Error("verifier_sandbox_process_required");
+}

package/dist/javascript-verifier-node.js

@@ -1,11 +1,13 @@
-import { JavaScriptVerifierResultSchema } from "./javascript-verifier-contract.js";
+import { assertIsolatedVerifierRuntime, JavaScriptVerifierResultSchema } from "./javascript-verifier-contract.js";
 import { executeJavaScriptIsolateInWorker } from "./javascript-isolate-node.js";
 import { executeJavaScriptIsolateInProcess } from "./javascript-isolate-process.js";
 /** Resolves/rejects only after the execution owner has stopped the worker. */
 export async function executeJavaScriptVerifierInWorker(input) {
+    assertIsolatedVerifierRuntime(input.runtime);
     return JavaScriptVerifierResultSchema.parse(await executeJavaScriptIsolateInWorker({ ...input, exportName: input.exportName ?? "verify", maxResultBytes: 65_536, errorPrefix: "verifier" }));
 }
 /** Uses a Node child process and waits for exit on success, failure, or cancellation. */
 export async function executeJavaScriptVerifierInProcess(input) {
+    assertIsolatedVerifierRuntime(input.runtime);
     return JavaScriptVerifierResultSchema.parse(await executeJavaScriptIsolateInProcess({ ...input, exportName: input.exportName ?? "verify", maxResultBytes: 65_536, errorPrefix: "verifier" }));
 }

package/dist/javascript-verifier.js

@@ -1,9 +1,10 @@
 import { executeJavaScriptIsolate } from "./javascript-isolate.js";
-import { JavaScriptVerifierResultSchema } from "./javascript-verifier-contract.js";
+import { assertIsolatedVerifierRuntime, JavaScriptVerifierResultSchema } from "./javascript-verifier-contract.js";
 export { JavaScriptVerifierResultSchema } from "./javascript-verifier-contract.js";
 /** A fresh interpreter with no filesystem, network, timers or module loader.
  * Hosts should use the worker entrypoint for cancellation and responsiveness. */
 export async function executeJavaScriptVerifier(input) {
+    assertIsolatedVerifierRuntime(input.runtime);
     const result = await executeJavaScriptIsolate({ ...input, exportName: input.exportName ?? "verify", maxResultBytes: 65_536, errorPrefix: "verifier" });
     return JavaScriptVerifierResultSchema.parse(result);
 }

package/dist/learning/contracts.js

@@ -5,6 +5,7 @@ import { RewardBindingSchema, RewardCompositionSchema, RewardReleaseRefSchema, R
 import { TaskRecordSchema, TaskSplitSchema, TasksetReleaseContentSchema } from "../tasksets.js";
 import { assertBoundedTaskJson, validateTaskSchema } from "../task-schema.js";
 import { JudgeCallReservationSchema } from "./judge-budget.js";
+import { NightlyScheduleSchema } from "./nightly-schedule.js";
 export const LearningJsonObjectSchema = z.record(z.string(), z.json());
 export const LearningRevisionRefSchema = RewardReleaseRefSchema;
 export const LearningJsonPointerSchema = z.string().max(2_000).refine((value) => value === "" || (value.startsWith("/") && !/~(?![01])/u.test(value)), "Use an RFC 6901 JSON pointer.");
@@ -222,6 +223,7 @@ export const LearningPolicyContentSchema = z.object({
         z.object({ kind: z.literal("manual") }).strict(),
         z.object({ kind: z.literal("approved_count") }).strict(),
         z.object({ kind: z.literal("schedule"), intervalSeconds: z.number().int().min(60).max(31_536_000) }).strict(),
+        NightlyScheduleSchema.extend({ kind: z.literal("nightly") }).strict(),
         z.object({ kind: z.literal("upstream_accepted"), modelProjectId: ReleaseIdSchema }).strict(),
     ]),
     trainingParent: ImmutableReleaseRefSchema,

package/dist/learning/index.js

@@ -29,4 +29,6 @@ export { resolveLearningTrainingParent } from "./iteration-training-parent.js";
 export * from "./schedule-contracts.js";
 export * from "./schedule-service.js";
 export * from "./schedule-worker.js";
+export * from "./nightly-schedule.js";
 export * from "./policy-inspection.js";
+export * from "./task-queue-inspection.js";

package/dist/learning/iteration-eligibility.js

@@ -9,7 +9,7 @@ export function learningChainId(modelProjectId) {
 export function learningConsumptionId(chainId, evidence) {
     return `consumption-${contentHash([chainId, evidence.id, evidence.revision])}`;
 }
-export async function inspectIterationEligibility(transaction, policy) {
+export async function inspectIterationEligibility(transaction, policy, options = {}) {
     // These are the methods supported by the approved-batch materializer.
     const purpose = policy.training.method === "sft" ? "supervised_training" : "reward_training";
     if (!["sft", "grpo", "ppo"].includes(policy.training.method)) {
@@ -24,6 +24,7 @@ export async function inspectIterationEligibility(transaction, policy) {
         throw new LearningDomainError("learning_policy_binding_mismatch", 422);
     const counts = { eligible: 0, awaitingReview: 0, excluded: 0, consumed: 0 };
     const selected = [];
+    const eligibleEvidence = [];
     const chainId = learningChainId(policy.modelProjectId);
     const seen = new Set();
     let backlog = 0;
@@ -66,11 +67,13 @@ export async function inspectIterationEligibility(transaction, policy) {
                     continue;
                 }
                 counts.eligible += 1;
+                if (options.collectEligible)
+                    eligibleEvidence.push(learningRef(evidence));
                 if (selected.length < policy.limits.maxBatchExamples)
                     selected.push({ evidence, decision });
             }
             afterId = page.nextCursor ?? undefined;
         } while (afterId);
     }
-    return { counts, selected, purpose };
+    return { counts, selected, purpose, eligibleEvidence };
 }

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

@@ -4,6 +4,7 @@ import { LearningAcceptedParentSchema, LearningRevisionRefSchema } from "./contr
 export const LearningIterationTriggerSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("manual"), identity: ReleaseIdSchema }).strict(),
     z.object({ kind: z.literal("schedule"), scheduledAt: ReleaseTimestampSchema }).strict(),
+    z.object({ kind: z.literal("approved_count"), checkedAt: ReleaseTimestampSchema }).strict(),
 ]);
 /** Stable across policy edits: a Model owns one learning chain in its scope. */
 export const LearningChainSchema = z.object({

package/dist/learning/iteration-reservation-service.js

@@ -11,7 +11,8 @@ import { latestAcceptedLearningParent, resolveLearningTrainingParent } from "./i
 export async function reserveLearningIteration(transaction, input, actorId, now) {
     const policy = await requireLearningRelease(transaction, "policy", input.policy);
     const chainId = learningChainId(policy.modelProjectId);
-    const trigger = input.trigger.kind === "schedule" ? { ...input.trigger, scheduledAt: new Date(input.trigger.scheduledAt).toISOString() } : input.trigger;
+    const trigger = input.trigger.kind === "schedule" ? { ...input.trigger, scheduledAt: new Date(input.trigger.scheduledAt).toISOString() }
+        : input.trigger.kind === "approved_count" ? { ...input.trigger, checkedAt: new Date(input.trigger.checkedAt).toISOString() } : input.trigger;
     const triggerIdentity = contentHash([input.policy.id, trigger]);
     const id = `iteration-${contentHash([chainId, triggerIdentity])}`;
     const requestHash = contentHash({ policy: input.policy, trigger });
@@ -30,11 +31,17 @@ export async function reserveLearningIteration(transaction, input, actorId, now)
     if (policy.automation.accept || policy.automation.serve)
         throw new LearningDomainError("learning_automatic_acceptance_not_available", 422);
     if (input.trigger.kind === "schedule") {
-        if (policy.trigger.kind !== "schedule" || !policy.automation.train)
+        if (!["schedule", "nightly"].includes(policy.trigger.kind) || !policy.automation.train)
             throw new LearningDomainError("learning_schedule_not_enabled", 409);
         if (Date.parse(input.trigger.scheduledAt) > Date.parse(now))
             throw new LearningDomainError("learning_schedule_not_due", 409);
     }
+    if (input.trigger.kind === "approved_count") {
+        if (policy.trigger.kind !== "approved_count" || !policy.automation.train)
+            throw new LearningDomainError("learning_count_trigger_not_enabled", 409);
+        if (Date.parse(input.trigger.checkedAt) > Date.parse(now))
+            throw new LearningDomainError("learning_count_trigger_not_due", 409);
+    }
     const chain = await transaction.get("chain", chainId);
     if (chain?.activeIterationId)
         throw new LearningDomainError("learning_iteration_active", 409, chain.activeIterationId);
@@ -43,6 +50,8 @@ export async function reserveLearningIteration(transaction, input, actorId, now)
     }
     const eligibility = await inspectIterationEligibility(transaction, policy);
     const ready = eligibility.counts.eligible >= policy.admission.minimumApprovedExamples;
+    if (input.trigger.kind === "approved_count" && !ready)
+        throw new LearningDomainError("learning_count_threshold_not_met", 409);
     const status = ready ? "ready" : eligibility.counts.awaitingReview > 0 ? "waiting_for_review" : "waiting_for_data";
     const pointers = [];
     const acceptedParent = await latestAcceptedLearningParent(transaction, chainId, true);

package/dist/learning/nightly-schedule.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+export const NightlyScheduleSchema = z.object({
+    localTime: z.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/),
+    timeZone: z.string().min(1).max(200).refine(value => {
+        try {
+            new Intl.DateTimeFormat("en", { timeZone: value });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, "Choose a valid IANA timezone."),
+}).strict();
+const DAY = 86_400_000;
+function formatter(calendar) {
+    return new Intl.DateTimeFormat("en-US", { timeZone: calendar.timeZone, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", hourCycle: "h23" });
+}
+function wallTime(format, instant) {
+    const parts = Object.fromEntries(format.formatToParts(instant).filter(part => part.type !== "literal").map(part => [part.type, Number(part.value)]));
+    return Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute);
+}
+function localDay(format, instant) { return Math.floor(wallTime(format, instant) / DAY) * DAY; }
+/** One occurrence per local date. A repeated time uses its first occurrence;
+ * a missing time advances by the DST gap. Entirely skipped dates have no fire. */
+function occurrence(format, calendar, date) {
+    const [hour, minute] = calendar.localTime.split(":").map(Number);
+    const requested = date + hour * 3_600_000 + minute * 60_000;
+    const offsets = new Set();
+    for (let hours = -36; hours <= 36; hours += 6) {
+        const probe = requested + hours * 3_600_000;
+        offsets.add(wallTime(format, probe) - probe);
+    }
+    const candidates = [...offsets].map(offset => requested - offset).sort((a, b) => a - b);
+    const exact = candidates.find(instant => wallTime(format, instant) === requested);
+    if (exact !== undefined)
+        return exact;
+    const shifted = candidates.filter(instant => localDay(format, instant) === date && wallTime(format, instant) > requested);
+    return shifted.sort((a, b) => wallTime(format, a) - wallTime(format, b))[0] ?? null;
+}
+export function nextNightlyOccurrence(calendar, after) {
+    const parsed = NightlyScheduleSchema.parse(calendar);
+    const time = Date.parse(after);
+    if (!Number.isFinite(time))
+        throw new Error("A nightly schedule requires a valid timestamp.");
+    const format = formatter(parsed);
+    const date = localDay(format, time);
+    for (let days = 0; days < 4; days++) {
+        const candidate = occurrence(format, parsed, date + days * DAY);
+        if (candidate !== null && candidate > time)
+            return new Date(candidate).toISOString();
+    }
+    throw new Error("Unable to resolve the next nightly occurrence.");
+}
+export function coalesceNightlyOccurrences(calendar, due, now) {
+    const parsed = NightlyScheduleSchema.parse(calendar);
+    const format = formatter(parsed);
+    const time = Date.parse(now);
+    const date = localDay(format, time);
+    for (let days = 0; days < 4; days++) {
+        const candidate = occurrence(format, parsed, date - days * DAY);
+        if (candidate !== null && candidate <= time)
+            return {
+                coalescedThroughAt: new Date(candidate).toISOString(),
+                coalescedCount: Math.max(0, Math.round((localDay(format, candidate) - localDay(format, Date.parse(due))) / DAY)),
+                nextRunAt: nextNightlyOccurrence(parsed, now),
+            };
+    }
+    throw new Error("Unable to resolve the due nightly occurrence.");
+}

package/dist/learning/reward-authoring.js

@@ -24,7 +24,8 @@ export function compileRewardAuthoring(input) {
     let calibrationCheckRef;
     if (fields.kind === "custom_verifier") {
         asset = createLearningTextAsset({ text: fields.code, path: "verifier.mjs", mediaType: "application/javascript", visibility: "verifier" });
-        implementation = { kind: fields.kind, verifierRef: asset.asset, exportName: fields.exportName, timeoutMs: authoringNumber(fields.timeout, "Time limit"), networkPolicy: "none" };
+        implementation = { kind: fields.kind, verifierRef: asset.asset, exportName: fields.exportName, timeoutMs: authoringNumber(fields.timeout, "Time limit"), networkPolicy: "none",
+            ...(base?.implementation.kind === "custom_verifier" && base.implementation.runtime !== undefined ? { runtime: base.implementation.runtime } : {}) };
     }
     else if (fields.kind === "model_judge" || fields.kind === "human") {
         if (!fields.rubric.trim())

package/dist/learning/reward-fixture-executor.js

@@ -14,7 +14,7 @@ export function createIsolatedRewardFixtureExecutor(options) {
                         throw new Error("reward_check_source_missing");
                     const source = verifyLearningTextAsset(asset, grader.verifierRef);
                     const result = await options.executeJavaScript({
-                        source, exportName: grader.exportName, signal: input.signal,
+                        source, exportName: grader.exportName, runtime: grader.runtime, signal: input.signal,
                         timeoutMs: Math.min(grader.timeoutMs, input.run.timeoutMs),
                         value: { task, attempt: evidence, input: task.input, output: evidence.output, expectedOutput: task.expectedOutput,
                             evaluatorContext: input.fixture.evaluatorContext, infrastructureError: evidence.infrastructureError ?? null },

package/dist/learning/schedule-contracts.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
 import { LearningRevisionRefSchema } from "./contracts.js";
+import { NightlyScheduleSchema } from "./nightly-schedule.js";
 /** The durable timer is operational state; every fire retains its own policy. */
 export const LearningScheduleSchema = z.object({
     schemaVersion: z.literal("openpond.learningSchedule.v1"),
@@ -11,6 +12,7 @@ export const LearningScheduleSchema = z.object({
     executionOwner: z.enum(["local", "hosted"]),
     state: z.enum(["scheduled", "disabled", "blocked"]),
     intervalSeconds: z.number().int().min(60).max(31_536_000).nullable(),
+    calendar: NightlyScheduleSchema.nullable().default(null),
     nextRunAt: ReleaseTimestampSchema.nullable(),
     lastFire: LearningRevisionRefSchema.nullable(),
     consecutiveFailures: z.number().int().nonnegative(),
@@ -19,10 +21,12 @@ export const LearningScheduleSchema = z.object({
     createdAt: ReleaseTimestampSchema,
     updatedAt: ReleaseTimestampSchema,
 }).strict().superRefine((value, context) => {
-    if (value.state !== "disabled" && (!value.intervalSeconds || !value.nextRunAt))
+    if (value.state !== "disabled" && ((!value.intervalSeconds && !value.calendar) || !value.nextRunAt))
         context.addIssue({ code: "custom", path: ["nextRunAt"], message: "An active timer must retain its cadence and due time." });
     if (value.state === "disabled" && value.nextRunAt)
         context.addIssue({ code: "custom", path: ["nextRunAt"], message: "A disabled timer cannot have a pending occurrence." });
+    if (value.intervalSeconds && value.calendar)
+        context.addIssue({ code: "custom", path: ["calendar"], message: "A timer uses either an interval or a nightly calendar." });
 });
 /** Immutable occurrence evidence survives timer edits and coalesced downtime. */
 export const LearningScheduleFireSchema = z.object({

package/dist/learning/schedule-service.js

@@ -2,7 +2,8 @@ import { contentHash } from "@openpond/harness";
 import { assertLearningContentHash, learningRef, sameLearningRef } from "./contracts.js";
 import { LearningScheduleSchema } from "./schedule-contracts.js";
 import { LearningDomainError } from "./errors.js";
-import { requireLearningResource } from "./repository.js";
+import { requireLearningRelease, requireLearningResource } from "./repository.js";
+import { nextNightlyOccurrence } from "./nightly-schedule.js";
 export function learningScheduleId(policyId) { return `schedule-${contentHash(policyId)}`; }
 /** Called atomically with policy publication. No external timer or Work is made. */
 export async function synchronizeLearningSchedule(tx, policy, now) {
@@ -14,15 +15,18 @@ export async function synchronizeLearningSchedule(tx, policy, now) {
     const previous = await tx.get("schedule", id);
     if (previous && sameLearningRef(previous.policy, learningRef(policy)))
         return previous;
-    const intervalSeconds = policy.trigger.kind === "schedule" ? policy.trigger.intervalSeconds : null;
-    const enabled = policy.enabled && policy.automation.train && intervalSeconds !== null;
+    const intervalSeconds = policy.trigger.kind === "schedule" ? policy.trigger.intervalSeconds : policy.trigger.kind === "approved_count" ? 60 : null;
+    const calendar = policy.trigger.kind === "nightly" ? { localTime: policy.trigger.localTime, timeZone: policy.trigger.timeZone } : null;
+    const enabled = policy.enabled && policy.automation.train && (intervalSeconds !== null || calendar !== null);
+    const previousPolicy = previous ? await requireLearningRelease(tx, "policy", previous.policy) : null;
     const preserveDue = previous?.nextRunAt && previous.intervalSeconds === intervalSeconds
+        && JSON.stringify(previous.calendar) === JSON.stringify(calendar) && previousPolicy?.trigger.kind === policy.trigger.kind
         && previous.executionOwner === policy.executionOwner;
     const schedule = LearningScheduleSchema.parse({
         schemaVersion: "openpond.learningSchedule.v1", id, revision: (previous?.revision ?? 0) + 1,
         policy: learningRef(policy), modelProjectId: policy.modelProjectId, executionOwner: policy.executionOwner,
-        state: enabled ? "scheduled" : "disabled", intervalSeconds,
-        nextRunAt: enabled ? preserveDue ? previous.nextRunAt : new Date(Date.parse(now) + intervalSeconds * 1_000).toISOString() : null,
+        state: enabled ? "scheduled" : "disabled", intervalSeconds, calendar,
+        nextRunAt: enabled ? preserveDue ? previous.nextRunAt : calendar ? nextNightlyOccurrence(calendar, now) : new Date(Date.parse(now) + intervalSeconds * 1_000).toISOString() : null,
         lastFire: previous?.lastFire ?? null, consecutiveFailures: 0, nextAttemptAt: null, lastError: null,
         createdAt: previous?.createdAt ?? now, updatedAt: now,
     });

package/dist/learning/schedule-worker.js

@@ -4,6 +4,8 @@ import { LearningDomainError } from "./errors.js";
 import { reserveLearningIteration } from "./iteration-reservation-service.js";
 import { LearningScheduleFireSchema, LearningScheduleSchema } from "./schedule-contracts.js";
 import { requireLearningRelease, requireLearningResource } from "./repository.js";
+import { inspectIterationEligibility } from "./iteration-eligibility.js";
+import { coalesceNightlyOccurrences } from "./nightly-schedule.js";
 const skipReasons = new Map([
     ["learning_iteration_active", "active_iteration"], ["learning_iteration_cooldown", "cooldown"],
     ["learning_daily_budget_exhausted", "daily_budget"],
@@ -28,20 +30,33 @@ export function createLearningScheduleWorker(repository, options) {
                 attempt = { schedule, maxRetries: 0 };
                 const policy = await requireLearningRelease(tx, "policy", schedule.policy);
                 attempt.maxRetries = policy.limits.maxRetries;
-                if (policy.executionOwner !== schedule.executionOwner || policy.trigger.kind !== "schedule"
-                    || policy.trigger.intervalSeconds !== schedule.intervalSeconds)
+                const matches = policy.trigger.kind === "nightly" ? schedule.intervalSeconds === null && schedule.calendar?.localTime === policy.trigger.localTime && schedule.calendar.timeZone === policy.trigger.timeZone
+                    : policy.trigger.kind === "schedule" ? schedule.calendar === null && policy.trigger.intervalSeconds === schedule.intervalSeconds
+                        : policy.trigger.kind === "approved_count" && schedule.calendar === null && schedule.intervalSeconds === 60;
+                if (policy.executionOwner !== schedule.executionOwner || !matches)
                     throw new LearningDomainError("learning_schedule_policy_mismatch", 409);
                 const scheduledAt = schedule.nextRunAt;
-                const interval = schedule.intervalSeconds * 1_000;
+                const interval = (schedule.intervalSeconds ?? 86_400) * 1_000;
                 const due = Date.parse(scheduledAt);
                 const coalescedCount = Math.floor((time - due) / interval);
+                const occurrence = schedule.calendar ? coalesceNightlyOccurrences(schedule.calendar, scheduledAt, timestamp) : {
+                    coalescedCount, coalescedThroughAt: new Date(due + coalescedCount * interval).toISOString(), nextRunAt: new Date(due + (coalescedCount + 1) * interval).toISOString(),
+                };
+                // Below-threshold count checks advance their timer without filling the
+                // Model's history with empty iterations or consuming any evidence.
+                if (policy.trigger.kind === "approved_count" && (await inspectIterationEligibility(tx, policy)).counts.eligible < policy.admission.minimumApprovedExamples) {
+                    const updated = LearningScheduleSchema.parse({ ...schedule, revision: schedule.revision + 1, nextRunAt: occurrence.nextRunAt,
+                        consecutiveFailures: 0, nextAttemptAt: null, lastError: null, updatedAt: timestamp });
+                    await tx.put("schedule", updated, schedule.revision, { parentId: schedule.modelProjectId, status: updated.state });
+                    return updated;
+                }
                 const id = `schedule-fire-${contentHash([schedule.id, scheduledAt])}`;
                 let outcome = "skipped";
                 let reason = null;
                 let iteration = null;
                 try {
                     const pointers = await reserveLearningIteration(tx, { action: "reserve_iteration", operationId: id,
-                        policy: schedule.policy, trigger: { kind: "schedule", scheduledAt } }, actorId, timestamp);
+                        policy: schedule.policy, trigger: policy.trigger.kind === "approved_count" ? { kind: "approved_count", checkedAt: scheduledAt } : { kind: "schedule", scheduledAt } }, actorId, timestamp);
                     const pointer = pointers.find(value => value.kind === "iteration");
                     if (!pointer)
                         throw new LearningDomainError("learning_schedule_reservation_missing", 409);
@@ -59,12 +74,12 @@ export function createLearningScheduleWorker(repository, options) {
                 }
                 const fire = LearningScheduleFireSchema.parse(sealLearningContent({
                     schemaVersion: "openpond.learningScheduleFire.v1", id, revision: 1, scheduleId,
-                    policy: schedule.policy, scheduledAt, coalescedThroughAt: new Date(due + coalescedCount * interval).toISOString(),
-                    coalescedCount, outcome, reason, iteration, createdAt: timestamp,
+                    policy: schedule.policy, scheduledAt, coalescedThroughAt: occurrence.coalescedThroughAt,
+                    coalescedCount: occurrence.coalescedCount, outcome, reason, iteration, createdAt: timestamp,
                 }));
                 await tx.put("schedule_fire", fire, 0, { parentId: schedule.id, status: outcome });
                 const updated = LearningScheduleSchema.parse({ ...schedule, revision: schedule.revision + 1,
-                    nextRunAt: new Date(due + (coalescedCount + 1) * interval).toISOString(), lastFire: learningRef(fire),
+                    nextRunAt: occurrence.nextRunAt, lastFire: learningRef(fire),
                     consecutiveFailures: 0, nextAttemptAt: null, lastError: null, updatedAt: timestamp });
                 await tx.put("schedule", updated, schedule.revision, { parentId: schedule.modelProjectId, status: updated.state });
                 return updated;

package/dist/learning/service.js

@@ -9,6 +9,8 @@ import { assertRewardCalibration, qualifyRewardCheck } from "./reward-calibratio
 import { queueRewardCheck, cancelRewardCheck } from "./reward-check-service.js";
 import { LearningDomainError } from "./errors.js";
 import { contentHash } from "@openpond/harness";
+import { inspectLearningTaskQueue } from "./task-queue-inspection.js";
+import { LearningReadRequestSchema } from "./transport.js";
 import { createRewardBinding, createRewardRelease } from "../rewards.js";
 import { assertBoundedTaskJson, validateTaskValue } from "../task-schema.js";
 import { assertAdmissionDecision, assertGradeIdentity, inspectTaskEvidence } from "./admission.js";
@@ -360,6 +362,13 @@ export function createLearningService(repository, options = {}) {
     }
     return {
         command,
+        async inspectTaskQueue(context, modelProjectId = null) {
+            authorizeRead(context);
+            const input = LearningReadRequestSchema.parse({ action: "inspect_task_queue", scope: context.scope, modelProjectId });
+            if (input.action !== "inspect_task_queue")
+                throw new LearningDomainError("learning_request_invalid", 400);
+            return repository.transaction(context.scope, transaction => inspectLearningTaskQueue(transaction, input.modelProjectId, now()));
+        },
         async inspectPolicy(context, reference) {
             authorizeRead(context);
             const ref = LearningRevisionRefSchema.parse(reference);
@@ -407,7 +416,7 @@ function authorize(context, input) {
         throw new LearningDomainError("learning_scope_required", 400);
     const publications = input.action === "publish" ? [input] : input.action === "publish_resources" ? input.resources : [];
     if (context.actor.role !== "reviewer" && publications.some(value => value.kind === "policy" && value.content.enabled
-        && value.content.automation.train && value.content.trigger.kind === "schedule"))
+        && value.content.automation.train && value.content.trigger.kind !== "manual"))
         throw new LearningDomainError("learning_review_not_authorized", 403);
     if (context.actor.role === "source") {
         const sourceId = input.action === "submit_example" ? input.example.sourceId : input.action === "submit_feedback" ? input.feedback.sourceId : null;

package/dist/learning/task-queue-inspection.js

@@ -0,0 +1,48 @@
+import { ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
+import { z } from "zod";
+import { LearningDomainError } from "./errors.js";
+import { inspectIterationEligibility } from "./iteration-eligibility.js";
+import { taskFamilyReservations } from "./admission.js";
+import { requireLearningRelease } from "./repository.js";
+export const LearningTaskQueueInspectionSchema = z.object({
+    modelProjectId: ReleaseIdSchema.nullable(),
+    inspectedAt: ReleaseTimestampSchema,
+    pendingTrainingCount: z.number().int().nonnegative().nullable(),
+    issues: z.array(z.object({ policyId: ReleaseIdSchema, code: z.string(), message: z.string() }).strict()),
+}).strict();
+/** Count exact eligible, unconsumed attempts once across selected policies.
+ * Paused policies still have pending work; review-only and held-out tasks do not. */
+export async function inspectLearningTaskQueue(transaction, modelProjectId, now) {
+    const eligible = new Set();
+    const issues = [];
+    let afterId;
+    do {
+        const page = await transaction.list("policy", { limit: 100, ...(modelProjectId ? { parentId: modelProjectId } : {}), ...(afterId ? { afterId } : {}) });
+        for (const policy of page.items) {
+            try {
+                const inspection = await inspectIterationEligibility(transaction, policy, { collectEligible: true });
+                const definition = await requireLearningRelease(transaction, "definition", policy.taskDefinition);
+                for (const reference of inspection.eligibleEvidence) {
+                    const evidence = await requireLearningRelease(transaction, "evidence", reference);
+                    let heldOut = false;
+                    for (const family of taskFamilyReservations(evidence, definition)) {
+                        const split = await transaction.familySplit(family.namespace, family.kind, family.key);
+                        if (split !== null && split !== "train") {
+                            heldOut = true;
+                            break;
+                        }
+                    }
+                    if (!heldOut)
+                        eligible.add(JSON.stringify([reference.id, reference.revision, reference.contentHash]));
+                }
+            }
+            catch (error) {
+                if (!(error instanceof LearningDomainError))
+                    throw error;
+                issues.push({ policyId: policy.id, code: error.code, message: error.message });
+            }
+        }
+        afterId = page.nextCursor ?? undefined;
+    } while (afterId);
+    return LearningTaskQueueInspectionSchema.parse({ modelProjectId, inspectedAt: now, pendingTrainingCount: issues.length ? null : eligible.size, issues });
+}

package/dist/learning/transport.js

@@ -17,6 +17,7 @@ export function assertLearningRequestJson(raw) {
 /** Scope selection is never authorization; each host resolves its authenticated owner. */
 export const LearningCommandRequestSchema = z.object({ scope: ReleaseIdSchema, command: LearningCommandSchema }).strict();
 export const LearningReadRequestSchema = z.discriminatedUnion("action", [
+    z.object({ action: z.literal("inspect_task_queue"), scope: ReleaseIdSchema, modelProjectId: ReleaseIdSchema.nullable() }).strict(),
     z.object({ action: z.literal("inspect_policy"), scope: ReleaseIdSchema, policy: LearningRevisionRefSchema }).strict(),
     z.object({ action: z.literal("inspect_evidence"), scope: ReleaseIdSchema, evidence: LearningRevisionRefSchema }).strict(),
     z.object({ action: z.literal("get"), scope: ReleaseIdSchema, kind: LearningResourceKindSchema, id: ReleaseIdSchema, revision: z.number().int().positive().optional() }).strict(),

package/dist/tasksets.js

@@ -44,8 +44,11 @@ export const ModelJudgeGraderSpecSchema = GraderBaseSchema.extend({
     model: z.object({ providerId: ReleaseIdSchema, modelId: ReleaseIdSchema, revision: z.string().trim().min(1).max(500).nullable() }).strict().optional(),
     temperature: z.number().min(0).max(2).optional(),
 }).strict();
+export const CustomVerifierRuntimeSchema = z.enum(["isolated_javascript", "sandbox_process"]);
 export const CustomVerifierGraderSpecSchema = GraderBaseSchema.extend({
     kind: z.literal("custom_verifier"),
+    // Omission retains the original isolated-JavaScript contract and hash.
+    runtime: CustomVerifierRuntimeSchema.optional(),
     verifierRef: ImmutableAssetRefSchema,
     exportName: z.string().trim().min(1).max(240).optional(),
     timeoutMs: z.number().int().positive().max(300_000),

package/dist/types/builtin-benchmarks/harness-refiner.d.ts

@@ -114,6 +114,7 @@ export declare const harnessRefinerBenchmarkRelease: {
         };
         timeoutMs: number;
         networkPolicy: "none";
+        runtime?: "isolated_javascript" | "sandbox_process" | undefined;
         exportName?: string | undefined;
     } | {
         id: string;

package/dist/types/builtin-benchmarks/harness-refiner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"harness-refiner.d.ts","sourceRoot":"","sources":["../../../../../src/builtin-benchmarks/harness-refiner.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqqD1C,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASzE,CAAC"}
+{"version":3,"file":"harness-refiner.d.ts","sourceRoot":"","sources":["../../../../../src/builtin-benchmarks/harness-refiner.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqqD1C,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASzE,CAAC"}

package/dist/types/conformance.d.ts

@@ -224,6 +224,7 @@ export declare const genericToolConformance: {
             };
             timeoutMs: number;
             networkPolicy: "none";
+            runtime?: "isolated_javascript" | "sandbox_process" | undefined;
             exportName?: string | undefined;
         } | {
             id: string;
@@ -534,6 +535,7 @@ export declare const marketingPortfolioConformance: {
             };
             timeoutMs: number;
             networkPolicy: "none";
+            runtime?: "isolated_javascript" | "sandbox_process" | undefined;
             exportName?: string | undefined;
         } | {
             id: string;

package/dist/types/conformance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../../../src/conformance.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEjC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxC,CAAC"}
+{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../../../src/conformance.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEjC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxC,CAAC"}

package/dist/types/execution-contracts.d.ts

@@ -399,6 +399,10 @@ export declare const VerifierSetReleaseContentSchema: z.ZodObject<{
         rewardEligible: z.ZodDefault<z.ZodBoolean>;
         privileged: z.ZodDefault<z.ZodBoolean>;
         kind: z.ZodLiteral<"custom_verifier">;
+        runtime: z.ZodOptional<z.ZodEnum<{
+            isolated_javascript: "isolated_javascript";
+            sandbox_process: "sandbox_process";
+        }>>;
         verifierRef: z.ZodObject<{
             id: z.ZodString;
             path: z.ZodString;
@@ -509,6 +513,10 @@ export declare const VerifierSetReleaseSchema: z.ZodObject<{
         rewardEligible: z.ZodDefault<z.ZodBoolean>;
         privileged: z.ZodDefault<z.ZodBoolean>;
         kind: z.ZodLiteral<"custom_verifier">;
+        runtime: z.ZodOptional<z.ZodEnum<{
+            isolated_javascript: "isolated_javascript";
+            sandbox_process: "sandbox_process";
+        }>>;
         verifierRef: z.ZodObject<{
             id: z.ZodString;
             path: z.ZodString;

package/dist/types/execution-contracts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execution-contracts.d.ts","sourceRoot":"","sources":["../../../../src/execution-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,mBAAmB;;;EAAmC,CAAC;AACpE,eAAO,MAAM,kBAAkB;;;;;;;;;EAS7B,CAAC;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAYpC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAcjC,CAAC;AACZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE1B,CAAC;AAEZ,eAAO,MAAM,8BAA8B;;;;;EAKzC,CAAC;AACH,eAAO,MAAM,8BAA8B;;;;EAIzC,CAAC;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAa7B,CAAC;AACZ,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAO/B,CAAC;AACZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAExB,CAAC;AAEZ,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAYjC,CAAC;AACZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE1B,CAAC;AAEZ,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuBvC,CAAC;AAkCH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA6D,CAAC;AACrG,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGK,CAAC;AAEtC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}
+{"version":3,"file":"execution-contracts.d.ts","sourceRoot":"","sources":["../../../../src/execution-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,mBAAmB;;;EAAmC,CAAC;AACpE,eAAO,MAAM,kBAAkB;;;;;;;;;EAS7B,CAAC;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAYpC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAcjC,CAAC;AACZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE1B,CAAC;AAEZ,eAAO,MAAM,8BAA8B;;;;;EAKzC,CAAC;AACH,eAAO,MAAM,8BAA8B;;;;EAIzC,CAAC;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAa7B,CAAC;AACZ,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAO/B,CAAC;AACZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAExB,CAAC;AAEZ,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAYjC,CAAC;AACZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE1B,CAAC;AAEZ,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuBvC,CAAC;AAkCH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA6D,CAAC;AACrG,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGK,CAAC;AAEtC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

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

@@ -6,4 +6,6 @@ export declare const JavaScriptVerifierResultSchema: z.ZodObject<{
     evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type JavaScriptVerifierResult = z.infer<typeof JavaScriptVerifierResultSchema>;
+/** A process checker must never silently execute under different semantics. */
+export declare function assertIsolatedVerifierRuntime(runtime?: "isolated_javascript" | "sandbox_process"): void;
 //# sourceMappingURL=javascript-verifier-contract.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"javascript-verifier-contract.d.ts","sourceRoot":"","sources":["../../../../src/javascript-verifier-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,8BAA8B;;;;;kBAKhC,CAAC;AACZ,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC"}
+{"version":3,"file":"javascript-verifier-contract.d.ts","sourceRoot":"","sources":["../../../../src/javascript-verifier-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,8BAA8B;;;;;kBAKhC,CAAC;AACZ,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,+EAA+E;AAC/E,wBAAgB,6BAA6B,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,iBAAiB,GAAG,IAAI,CAEvG"}

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,EAAkC,KAAK,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAIlH,8EAA8E;AAC9E,wBAAsB,iCAAiC,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAEjJ;AAED,yFAAyF;AACzF,wBAAsB,kCAAkC,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAElJ"}
+{"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"}