@openpond/evals 0.12.3 → 0.12.5

package/dist/tool-learning/episodes.js

@@ -0,0 +1,284 @@
+import { z } from "zod";
+import { ToolLearningActionSchema } from "./actions.js";
+import { TOOL_LEARNING_LIMITS, ToolLearningAssetSchema, ToolLearningEnvironmentSchema, ToolLearningHashSchema as Hash, ToolLearningIdSchema as Id, ToolLearningRefSchema as Ref, ToolLearningSanitizationSchema, ToolLearningTimestampSchema as Timestamp, boundedToolLearningSchema, toolLearningContentHash, toolLearningText, } from "./primitives.js";
+export const ToolEpisodeAttemptSchema = z
+    .object({
+    intent: toolLearningText(2_000),
+    tool: z
+        .object({
+        name: z.string().min(1).max(200),
+        version: z.string().max(200).nullable(),
+        server: z.string().max(200).nullable(),
+    })
+        .strict(),
+    action: ToolLearningActionSchema,
+    actionHash: Hash,
+    environment: ToolLearningEnvironmentSchema,
+    contextAssets: z.array(ToolLearningAssetSchema).max(TOOL_LEARNING_LIMITS.assetsPerEpisode),
+    selection: z.discriminatedUnion("kind", [
+        z.object({ kind: z.literal("eligible_attempt") }).strict(),
+        z
+            .object({
+            kind: z.literal("unchanged_control"),
+            numerator: z.number().int().positive(),
+            denominator: z.number().int().positive(),
+            policyHash: Hash,
+        })
+            .strict(),
+    ]),
+})
+    .strict()
+    .superRefine((attempt, context) => {
+    if (toolLearningContentHash(attempt.action) !== attempt.actionHash)
+        context.addIssue({
+            code: "custom",
+            path: ["actionHash"],
+            message: "Action bytes differ from their hash.",
+        });
+    if (attempt.selection.kind === "unchanged_control" &&
+        attempt.selection.numerator > attempt.selection.denominator)
+        context.addIssue({
+            code: "custom",
+            path: ["selection"],
+            message: "Sampling probability cannot exceed one.",
+        });
+});
+export const ToolEpisodeFailureKindSchema = z.enum([
+    "validation_failure",
+    "execution_failure",
+    "process_failure",
+    "timeout",
+    "cancelled",
+    "infrastructure_failure",
+    "authorization_denied",
+    "outcome_failure",
+    "unknown_failure",
+]);
+const ObservationBase = {
+    attempt: Ref,
+    actionHash: Hash,
+    execution: z.enum(["not_executed", "executed", "unknown"]),
+    sideEffects: z.enum(["none", "possible", "observed", "unknown"]),
+    resultExcerpt: toolLearningText(TOOL_LEARNING_LIMITS.resultBytes),
+    resultHash: Hash.nullable(),
+    assets: z.array(ToolLearningAssetSchema).max(TOOL_LEARNING_LIMITS.assetsPerEpisode),
+};
+export const ToolEpisodeObservationSchema = z
+    .discriminatedUnion("outcome", [
+    z
+        .object({
+        ...ObservationBase,
+        outcome: z.literal("succeeded"),
+        exitCode: z.literal(0).nullable(),
+    })
+        .strict(),
+    z
+        .object({
+        ...ObservationBase,
+        outcome: z.literal("failed"),
+        classification: ToolEpisodeFailureKindSchema,
+        errorCode: z.string().min(1).max(200),
+        message: toolLearningText(2_000),
+        exitCode: z.number().int().min(-255).max(255).nullable(),
+    })
+        .strict(),
+    z
+        .object({
+        ...ObservationBase,
+        outcome: z.literal("incomplete"),
+        reason: z.enum([
+            "completion_not_observed",
+            "observer_restarted",
+            "transport_interrupted",
+            "coverage_gap",
+        ]),
+    })
+        .strict(),
+])
+    .superRefine((observation, context) => {
+    if (observation.execution === "not_executed" && observation.sideEffects !== "none")
+        context.addIssue({
+            code: "custom",
+            path: ["sideEffects"],
+            message: "An unexecuted action cannot claim tool effects.",
+        });
+    if (observation.outcome === "succeeded" && observation.execution !== "executed")
+        context.addIssue({
+            code: "custom",
+            path: ["execution"],
+            message: "Successful execution requires an observed execution.",
+        });
+    if (observation.outcome !== "failed")
+        return;
+    if (observation.classification === "validation_failure" &&
+        observation.execution !== "not_executed")
+        context.addIssue({
+            code: "custom",
+            path: ["execution"],
+            message: "Pre-execution validation failure must be unexecuted.",
+        });
+    if (observation.classification === "process_failure" &&
+        (observation.execution !== "executed" ||
+            observation.exitCode === null ||
+            observation.exitCode === 0))
+        context.addIssue({
+            code: "custom",
+            path: ["exitCode"],
+            message: "Process failure requires a nonzero observed exit.",
+        });
+});
+export const ToolEpisodeRecoveryLinkSchema = z
+    .object({
+    failedAttempt: Ref,
+    failedObservation: Ref,
+    replacementAttempt: Ref,
+    goalId: Id,
+    basis: z.enum(["explicit_relation", "artifact_lineage", "unverified"]),
+    attributionEvidence: z.array(Ref).max(16),
+})
+    .strict()
+    .superRefine((link, context) => {
+    if (link.failedAttempt.id === link.replacementAttempt.id)
+        context.addIssue({
+            code: "custom",
+            message: "A recovery must reference a different attempt.",
+        });
+    if (link.basis !== "unverified" && link.attributionEvidence.length === 0)
+        context.addIssue({
+            code: "custom",
+            path: ["attributionEvidence"],
+            message: "Recovery attribution needs retained evidence.",
+        });
+});
+/** A producer supplies a claim/reference. Intake must resolve its authentic owner
+ * receipt; possession of an append credential never grants verifier authority. */
+export const ToolEpisodeVerificationSchema = z
+    .object({
+    attempt: Ref,
+    actionHash: Hash,
+    outcome: z.enum(["passed", "failed", "unknown"]),
+    verifierRelease: Ref.nullable(),
+    verifierReceipt: Ref.nullable(),
+    environmentFingerprint: Hash,
+    resetStateHash: Hash.nullable(),
+    outputArtifacts: z.array(ToolLearningAssetSchema).max(TOOL_LEARNING_LIMITS.assetsPerEpisode),
+    reason: toolLearningText(2_000),
+})
+    .strict()
+    .superRefine((verification, context) => {
+    if (verification.outcome !== "unknown" &&
+        (!verification.verifierRelease || !verification.verifierReceipt))
+        context.addIssue({
+            code: "custom",
+            message: "A verification outcome requires an exact verifier and execution receipt.",
+        });
+});
+const Event = z
+    .object({
+    schemaVersion: z.literal("openpond.toolEpisodeEvent.v1"),
+    operationId: Id,
+    installationId: Id,
+    episodeId: Id,
+    eventId: Id,
+    sessionId: Id,
+    parentSessionId: Id.nullable(),
+    turnId: Id.nullable(),
+    callId: Id,
+    occurredAt: Timestamp,
+    sequence: z.number().int().nonnegative(),
+    adapterVersion: z.string().min(1).max(200),
+    sanitization: ToolLearningSanitizationSchema,
+    contentHash: Hash,
+})
+    .strict();
+export const ToolEpisodeEventSchema = boundedToolLearningSchema(z
+    .discriminatedUnion("eventKind", [
+    Event.extend({ eventKind: z.literal("attempt"), payload: ToolEpisodeAttemptSchema }).strict(),
+    Event.extend({
+        eventKind: z.literal("observation"),
+        payload: ToolEpisodeObservationSchema,
+    }).strict(),
+    Event.extend({
+        eventKind: z.literal("recovery_link"),
+        payload: ToolEpisodeRecoveryLinkSchema,
+    }).strict(),
+    Event.extend({
+        eventKind: z.literal("verification"),
+        payload: ToolEpisodeVerificationSchema,
+    }).strict(),
+    Event.extend({
+        eventKind: z.literal("lineage"),
+        payload: z
+            .object({
+            relation: z.enum(["fork", "split", "reopen"]),
+            parentEpisode: Ref,
+            parentSessionId: Id,
+            reason: toolLearningText(1_000),
+        })
+            .strict(),
+    }).strict(),
+])
+    .superRefine((event, context) => {
+    const { contentHash, ...body } = event;
+    if (toolLearningContentHash(body) !== contentHash)
+        context.addIssue({
+            code: "custom",
+            path: ["contentHash"],
+            message: "Episode event content hash mismatch.",
+        });
+}), TOOL_LEARNING_LIMITS.eventBytes);
+export function sealToolEpisodeEvent(value) {
+    const hash = toolLearningContentHash(value);
+    if (!value ||
+        typeof value !== "object" ||
+        Array.isArray(value) ||
+        Object.hasOwn(value, "contentHash"))
+        throw new Error("tool_episode_unsigned_envelope_required");
+    return ToolEpisodeEventSchema.parse({ ...value, contentHash: hash });
+}
+export const ToolEpisodeAppendSchema = boundedToolLearningSchema(z
+    .object({
+    schemaVersion: z.literal("openpond.toolEpisodeAppend.v1"),
+    operationId: Id,
+    installationId: Id,
+    events: z.array(ToolEpisodeEventSchema).min(1).max(TOOL_LEARNING_LIMITS.eventsPerAppend),
+})
+    .strict()
+    .superRefine((append, context) => {
+    if (append.events.some((event) => event.installationId !== append.installationId))
+        context.addIssue({
+            code: "custom",
+            path: ["events"],
+            message: "Append events must belong to the exact installation.",
+        });
+    if (new Set(append.events.map((event) => event.eventId)).size !== append.events.length)
+        context.addIssue({
+            code: "custom",
+            path: ["events"],
+            message: "Append event IDs must be unique.",
+        });
+}), TOOL_LEARNING_LIMITS.eventBytes * TOOL_LEARNING_LIMITS.eventsPerAppend);
+export const ToolEpisodeAppendReceiptSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.toolEpisodeAppendReceipt.v1"),
+    operationId: Id,
+    requestHash: Hash,
+    installationId: Id,
+    teamId: Id,
+    projectId: Id,
+    receivedAt: Timestamp,
+    events: z
+        .array(z
+        .object({
+        eventId: Id,
+        contentHash: Hash,
+        state: z.enum(["retained", "already_retained", "privacy_rejected"]),
+        receiptId: Id,
+        reason: z.string().max(200).nullable(),
+    })
+        .strict())
+        .min(1)
+        .max(TOOL_LEARNING_LIMITS.eventsPerAppend),
+    learningEnrollment: z.literal(false),
+})
+    .strict();

package/dist/tool-learning/index.js

@@ -0,0 +1,6 @@
+export * from "./primitives.js";
+export * from "./actions.js";
+export * from "./episodes.js";
+export * from "./installations.js";
+export * from "./consultation.js";
+export * from "./policy.js";

package/dist/tool-learning/installations.js

@@ -0,0 +1,151 @@
+import { z } from "zod";
+import { TOOL_LEARNING_LIMITS, ToolLearningClientSchema, ToolLearningHashSchema as Hash, ToolLearningIdSchema as Id, ToolLearningRefSchema as Ref, ToolLearningScopeSchema, ToolLearningTimestampSchema as Timestamp, boundedToolLearningSchema, } from "./primitives.js";
+export const ToolLearningCapturePolicySchema = z
+    .object({
+    revision: z.number().int().positive(),
+    permittedTools: z.array(z.string().min(1).max(200)).min(1).max(100),
+    workspaceRootHashes: z.array(Hash).min(1).max(32),
+    permittedFields: z
+        .array(z.enum(["action", "intent", "state", "result_excerpt", "artifact_reference"]))
+        .min(1)
+        .max(5),
+    unchangedControls: z
+        .object({
+        numerator: z.number().int().nonnegative(),
+        denominator: z.number().int().positive(),
+    })
+        .strict(),
+    maximumEventBytes: z.number().int().positive().max(TOOL_LEARNING_LIMITS.eventBytes),
+    maximumEpisodeBytes: z.number().int().positive().max(TOOL_LEARNING_LIMITS.episodeBytes),
+    maximumEpisodeEvents: z.number().int().positive().max(TOOL_LEARNING_LIMITS.eventsPerEpisode),
+    maximumQueueBytes: z.number().int().positive().max(TOOL_LEARNING_LIMITS.queueBytes),
+    maximumQueueEvents: z.number().int().positive().max(TOOL_LEARNING_LIMITS.queueEvents),
+    maximumQueueAgeSeconds: z.number().int().positive().max(TOOL_LEARNING_LIMITS.queueAgeSeconds),
+    rawRetentionDays: z.number().int().min(1).max(30),
+    purposes: z
+        .array(z.enum(["capture", "consultation"]))
+        .min(1)
+        .max(2),
+    modelUpdates: z.literal("requires_separate_review"),
+    variantGeneration: z.literal("disabled"),
+})
+    .strict()
+    .superRefine((policy, context) => {
+    if (policy.unchangedControls.numerator > policy.unchangedControls.denominator)
+        context.addIssue({
+            code: "custom",
+            path: ["unchangedControls"],
+            message: "Sampling probability cannot exceed one.",
+        });
+    for (const key of [
+        "permittedTools",
+        "workspaceRootHashes",
+        "permittedFields",
+        "purposes",
+    ])
+        if (new Set(policy[key]).size !== policy[key].length)
+            context.addIssue({
+                code: "custom",
+                path: [key],
+                message: "Policy entries must be unique.",
+            });
+    if (policy.maximumEpisodeBytes < policy.maximumEventBytes ||
+        policy.maximumQueueBytes < policy.maximumEventBytes)
+        context.addIssue({
+            code: "custom",
+            message: "Episode and queue capacities must fit one permitted event.",
+        });
+});
+export const ToolLearningCoverageSchema = z
+    .object({
+    receipt: Ref.nullable(),
+    start: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    resume: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    compaction: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    executionFailure: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    processFailure: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    validationFailure: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    nestedCalls: z.enum(["observed", "documented", "unsupported", "unqualified"]),
+    contextRefresh: z.enum([
+        "session_start",
+        "start_resume",
+        "start_resume_compaction",
+        "revision_aware_turn",
+        "unqualified",
+    ]),
+    gaps: z.array(z.string().min(1).max(500)).max(32),
+})
+    .strict()
+    .superRefine((coverage, context) => {
+    if (Object.values(coverage).includes("observed") && !coverage.receipt)
+        context.addIssue({
+            code: "custom",
+            path: ["receipt"],
+            message: "Observed coverage requires a qualification receipt.",
+        });
+});
+export const ToolLearningRegistrationSchema = boundedToolLearningSchema(z
+    .object({
+    schemaVersion: z.literal("openpond.toolLearningRegistration.v1"),
+    operationId: Id,
+    installationId: Id,
+    projectId: Id,
+    machineSourceId: Id,
+    client: ToolLearningClientSchema,
+    clientVersion: z.string().min(1).max(200),
+    adapterRelease: Ref,
+    collectionPolicy: ToolLearningCapturePolicySchema,
+})
+    .strict(), TOOL_LEARNING_LIMITS.eventBytes);
+/** Status deliberately exposes capability/expiry metadata, never the credential. */
+export const ToolLearningInstallationSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.toolLearningInstallation.v1"),
+    id: Id,
+    revision: z.number().int().positive(),
+    scope: ToolLearningScopeSchema,
+    ownerUserId: Id,
+    machineSourceId: Id,
+    client: ToolLearningClientSchema,
+    clientVersion: z.string().min(1).max(200),
+    adapterRelease: Ref,
+    state: z.enum(["pending_client_trust", "enabled", "disabled", "revoked"]),
+    collectionPolicy: ToolLearningCapturePolicySchema,
+    collectionPolicyHash: Hash,
+    coverage: ToolLearningCoverageSchema,
+    credential: z
+        .object({
+        id: Id,
+        expiresAt: Timestamp,
+        revokedAt: Timestamp.nullable(),
+        capabilities: z
+            .array(z.enum(["episode_append", "manifest_read", "consultation_submit", "consultation_read"]))
+            .min(1)
+            .max(4),
+    })
+        .strict()
+        .nullable(),
+    createdAt: Timestamp,
+    updatedAt: Timestamp,
+})
+    .strict();
+export const ToolLearningInstallationUpdateSchema = z
+    .object({
+    operationId: Id,
+    expectedRevision: z.number().int().positive(),
+    state: z.enum(["enabled", "disabled", "revoked"]),
+})
+    .strict();
+export const ToolEpisodeOriginSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.toolEpisodeOrigin.v1"),
+    installationId: Id,
+    projectId: Id,
+    ownerUserId: Id,
+    episode: Ref,
+    event: Ref,
+    appendReceipt: Ref,
+    purpose: z.literal("private_dataset_evidence"),
+    trainingConsent: z.literal("not_granted"),
+})
+    .strict();

package/dist/tool-learning/policy.js

@@ -0,0 +1,38 @@
+import { ToolEpisodeEventSchema } from "./episodes.js";
+import { ToolLearningCapturePolicySchema } from "./installations.js";
+import { toolLearningContentHash } from "./primitives.js";
+/** Shared local-persistence/intake boundary. A hash alone does not grant consent. */
+export function assertToolEpisodeCapturePolicy(eventValue, policyValue) {
+    const event = ToolEpisodeEventSchema.parse(eventValue);
+    const policy = ToolLearningCapturePolicySchema.parse(policyValue);
+    if (!policy.purposes.includes("capture"))
+        throw new Error("tool_learning_capture_not_enabled");
+    if (event.sanitization.policyRevision !== policy.revision ||
+        event.sanitization.policyHash !== toolLearningContentHash(policy))
+        throw new Error("tool_learning_capture_policy_changed");
+    if (new TextEncoder().encode(JSON.stringify(event)).byteLength > policy.maximumEventBytes)
+        throw new Error("tool_learning_event_policy_limit");
+    const permits = (field) => policy.permittedFields.includes(field);
+    if (event.eventKind === "attempt") {
+        if (!policy.permittedTools.includes(event.payload.tool.name))
+            throw new Error("tool_learning_tool_outside_collection_policy");
+        if (!permits("action") ||
+            (!permits("intent") && event.payload.intent !== "") ||
+            (!permits("state") && Object.keys(event.payload.environment.state).length > 0) ||
+            (!permits("artifact_reference") && event.payload.contextAssets.length > 0))
+            throw new Error("tool_learning_attempt_field_outside_collection_policy");
+    }
+    if (event.eventKind === "observation") {
+        if ((!permits("result_excerpt") &&
+            (event.payload.resultExcerpt !== "" ||
+                (event.payload.outcome === "failed" && event.payload.message !== ""))) ||
+            (!permits("artifact_reference") && event.payload.assets.length > 0))
+            throw new Error("tool_learning_result_field_outside_collection_policy");
+    }
+    if (event.eventKind === "verification" &&
+        ((!permits("result_excerpt") && event.payload.reason !== "") ||
+            (!permits("artifact_reference") && event.payload.outputArtifacts.length > 0)))
+        throw new Error("tool_learning_verification_field_outside_collection_policy");
+    if (event.eventKind === "lineage" && !permits("intent") && event.payload.reason !== "")
+        throw new Error("tool_learning_lineage_field_outside_collection_policy");
+}

package/dist/tool-learning/primitives.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { contentHash, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, } from "@openpond/harness";
+import { assertBoundedTaskJson } from "../task-schema-validation.js";
+export const TOOL_LEARNING_LIMITS = Object.freeze({
+    eventBytes: 65_536,
+    actionBytes: 16_384,
+    resultBytes: 8_192,
+    stateBytes: 8_192,
+    eventsPerAppend: 32,
+    eventsPerEpisode: 256,
+    episodeBytes: 2_097_152,
+    assetBytes: 1_048_576,
+    assetsPerEpisode: 16,
+    queueBytes: 52_428_800,
+    queueEvents: 5_000,
+    queueAgeSeconds: 86_400,
+    capabilities: 32,
+    consultationRounds: 3,
+    consultationBytes: 65_536,
+    manifestSeconds: 300,
+});
+export const ToolLearningIdSchema = ReleaseIdSchema;
+export const ToolLearningHashSchema = ReleaseHashSchema;
+export const ToolLearningTimestampSchema = ReleaseTimestampSchema;
+export const ToolLearningClientSchema = z.enum(["codex", "claude_code", "opencode", "openpond"]);
+export const ToolLearningRefSchema = z
+    .object({ id: ReleaseIdSchema, contentHash: ReleaseHashSchema })
+    .strict();
+export const ToolLearningScopeSchema = z
+    .object({ teamId: ReleaseIdSchema, projectId: ReleaseIdSchema })
+    .strict();
+/** Run the existing non-recursive JSON bound before Zod traverses producer data. */
+export function boundedToolLearningSchema(schema, maximumBytes) {
+    return z.preprocess((value, context) => {
+        try {
+            assertBoundedTaskJson(value, maximumBytes);
+        }
+        catch {
+            context.addIssue({
+                code: "custom",
+                message: "Tool learning data exceeds its JSON boundary.",
+            });
+            return z.NEVER;
+        }
+        return value;
+    }, schema);
+}
+export function toolLearningText(maximumBytes) {
+    return z
+        .string()
+        .max(maximumBytes)
+        .refine((value) => new TextEncoder().encode(value).byteLength <= maximumBytes, "Tool learning text exceeds its UTF-8 byte limit.");
+}
+export const ToolLearningStateSchema = boundedToolLearningSchema(z
+    .record(z.string().min(1).max(120), z.union([toolLearningText(2_000), z.number().finite(), z.boolean(), z.null()]))
+    .refine((value) => Object.keys(value).length <= 32, "Use at most 32 explicit state fields."), TOOL_LEARNING_LIMITS.stateBytes);
+export const ToolLearningEnvironmentSchema = z
+    .object({
+    application: z.string().trim().min(1).max(200),
+    version: z.string().trim().min(1).max(200),
+    state: ToolLearningStateSchema,
+    fingerprint: ReleaseHashSchema,
+})
+    .strict();
+export const ToolLearningAssetSchema = z
+    .object({
+    id: ReleaseIdSchema,
+    contentHash: ReleaseHashSchema,
+    mediaType: z.enum(["text/plain", "application/json", "text/x-python", "text/x-diff"]),
+    sizeBytes: z.number().int().nonnegative().max(TOOL_LEARNING_LIMITS.assetBytes),
+    purpose: z.enum(["action", "result", "state", "verification"]),
+})
+    .strict();
+export const ToolLearningSanitizationSchema = z
+    .object({
+    policyRevision: z.number().int().positive(),
+    policyHash: ReleaseHashSchema,
+    redactedFields: z.number().int().nonnegative().max(10_000),
+    omittedFields: z.number().int().nonnegative().max(10_000),
+    truncated: z.boolean(),
+})
+    .strict();
+/** Hash only the validated public envelope; no raw hook/transcript data enters it. */
+export function toolLearningContentHash(value, maximumBytes = TOOL_LEARNING_LIMITS.eventBytes) {
+    assertBoundedTaskJson(value, maximumBytes);
+    return contentHash(value);
+}

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/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"}