@openpond/evals 0.7.1 → 0.7.3

package/dist/javascript-verifier-worker.js

@@ -1,6 +1,6 @@
 import { parentPort, workerData } from "node:worker_threads";
-import { executeJavaScriptVerifier } from "./javascript-verifier.js";
+import { executeJavaScriptIsolate } from "./javascript-isolate.js";
 // Only this trusted host program runs in Node. Authored source is interpreter data.
 if (!parentPort)
-    throw new Error("Verifier worker requires its execution owner.");
-void executeJavaScriptVerifier(workerData).then((result) => parentPort.postMessage({ ok: true, result }), (error) => parentPort.postMessage({ ok: false, error: error instanceof Error ? error.message : "Verifier execution failed." })).finally(() => parentPort.close());
+    throw new Error("JavaScript worker requires its execution owner.");
+void executeJavaScriptIsolate(workerData).then((result) => parentPort.postMessage({ ok: true, result }), (error) => parentPort.postMessage({ ok: false, error: error instanceof Error ? error.message : "JavaScript execution failed." })).finally(() => parentPort.close());

package/dist/javascript-verifier.js

@@ -1,64 +1,9 @@
-import { newQuickJSWASMModuleFromVariant, Scope } from "quickjs-emscripten-core";
-import variant from "@jitl/quickjs-singlefile-cjs-release-sync";
-import { assertBoundedTaskJson } from "./task-schema.js";
+import { executeJavaScriptIsolate } from "./javascript-isolate.js";
 import { JavaScriptVerifierResultSchema } from "./javascript-verifier-contract.js";
 export { JavaScriptVerifierResultSchema } from "./javascript-verifier-contract.js";
-/**
- * A fresh WebAssembly interpreter with no host functions, filesystem, network,
- * timers, or module loader. Hosts should run this on a worker to remain responsive
- * and terminate that worker when cancellation is requested.
- */
+/** 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) {
-    if (!Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 300_000)
-        throw new Error("verifier_timeout_invalid");
-    if (new TextEncoder().encode(input.source).byteLength > 524_288)
-        throw new Error("verifier_source_too_large");
-    assertBoundedTaskJson(input.value, 4_194_304);
-    input.signal?.throwIfAborted();
-    const deadline = Date.now() + input.timeoutMs;
-    const module = await newQuickJSWASMModuleFromVariant(variant);
-    input.signal?.throwIfAborted();
-    return Scope.withScope((scope) => {
-        const runtime = scope.manage(module.newRuntime());
-        runtime.setMemoryLimit(33_554_432);
-        runtime.setMaxStackSize(262_144);
-        runtime.setInterruptHandler(() => Date.now() >= deadline || input.signal?.aborted === true);
-        const context = scope.manage(runtime.newContext());
-        const stringify = scope.manage(context.unwrapResult(context.evalCode("JSON.stringify")));
-        const argument = scope.manage(context.unwrapResult(context.evalCode(`JSON.parse(${JSON.stringify(JSON.stringify(input.value))})`)));
-        const exported = scope.manage(context.unwrapResult(context.evalCode(input.source, "verifier.mjs", { type: "module" })));
-        const namespace = scope.manage(settle(context, exported, deadline, input.signal));
-        const fn = scope.manage(context.getProp(namespace, input.exportName ?? "verify"));
-        if (context.typeof(fn) !== "function")
-            throw new Error("verifier_function_export_missing");
-        const returned = scope.manage(context.unwrapResult(context.callFunction(fn, context.undefined, argument)));
-        const result = scope.manage(settle(context, returned, deadline, input.signal));
-        const serialized = scope.manage(context.unwrapResult(context.callFunction(stringify, context.undefined, result)));
-        if (context.typeof(serialized) !== "string")
-            throw new Error("verifier_result_not_json");
-        const json = context.getString(serialized);
-        if (new TextEncoder().encode(json).byteLength > 65_536)
-            throw new Error("verifier_result_too_large");
-        input.signal?.throwIfAborted();
-        if (Date.now() >= deadline)
-            throw new Error("verifier_timeout");
-        const value = JSON.parse(json);
-        assertBoundedTaskJson(value, 65_536);
-        return JavaScriptVerifierResultSchema.parse(value);
-    });
-}
-function settle(context, handle, deadline, signal) {
-    for (;;) {
-        signal?.throwIfAborted();
-        if (Date.now() >= deadline)
-            throw new Error("verifier_timeout");
-        const state = context.getPromiseState(handle);
-        if (state.type === "fulfilled")
-            return state.notAPromise ? state.value.dup() : state.value;
-        if (state.type === "rejected")
-            return context.unwrapResult(state);
-        const jobs = context.runtime.executePendingJobs(1);
-        if (jobs.unwrap() === 0)
-            throw new Error("verifier_unresolved_promise");
-    }
+    const result = await executeJavaScriptIsolate({ ...input, exportName: input.exportName ?? "verify", maxResultBytes: 65_536, errorPrefix: "verifier" });
+    return JavaScriptVerifierResultSchema.parse(result);
 }

package/dist/learning/authoring-service.js

@@ -0,0 +1,49 @@
+import { assertBoundedTaskJson } from "../task-schema.js";
+import { AuthoringDraftSchema } from "./authoring.js";
+import { LearningDomainError } from "./errors.js";
+import { learningRef, sameLearningRef, sealLearningContent } from "./contracts.js";
+import { requireLearningRelease } from "./repository.js";
+export async function saveAuthoringDraft(tx, input, now) {
+    // A 100-record page remains below the common 16 MiB response limit.
+    assertBoundedTaskJson(input.draft, 131_072);
+    const previous = await tx.get("draft", input.draft.id);
+    if (previous && (previous.status !== "draft" || previous.targetId !== input.draft.targetId || previous.targetKind !== input.draft.targetKind || (previous.baseRelease === null ? input.draft.baseRelease !== null : input.draft.baseRelease === null || !sameLearningRef(previous.baseRelease, input.draft.baseRelease))))
+        throw new LearningDomainError("authoring_draft_identity_conflict", 409);
+    if (input.draft.baseRelease) {
+        if (input.draft.baseRelease.id !== input.draft.targetId)
+            throw new LearningDomainError("authoring_draft_base_mismatch", 422);
+        await requireLearningRelease(tx, input.draft.targetKind, input.draft.baseRelease);
+    }
+    const draft = AuthoringDraftSchema.parse(sealLearningContent({ ...input.draft, schemaVersion: "openpond.authoringDraft.v1", revision: input.expectedRevision + 1, status: "draft", publishedRelease: null, createdAt: previous?.createdAt ?? now, updatedAt: now }));
+    await tx.put("draft", draft, input.expectedRevision, { parentId: draft.targetKind, status: draft.status });
+    return { kind: "draft", id: draft.id, revision: draft.revision };
+}
+export async function archiveAuthoringDraft(tx, ref, now) {
+    const draft = await currentDraft(tx, ref);
+    const { contentHash: _hash, ...content } = draft;
+    const archived = AuthoringDraftSchema.parse(sealLearningContent({ ...content, revision: draft.revision + 1, status: "archived", updatedAt: now }));
+    await tx.put("draft", archived, draft.revision, { parentId: draft.targetKind, status: archived.status });
+    return { kind: "draft", id: archived.id, revision: archived.revision };
+}
+export async function finalizeAuthoringDraft(tx, input, published, now) {
+    const finalization = input.finalizeDraft;
+    if (!finalization)
+        return null;
+    const draft = await currentDraft(tx, finalization.draft);
+    if (draft.targetKind !== finalization.targetKind || draft.targetId !== finalization.release.id || finalization.release.revision !== (draft.baseRelease?.revision ?? 0) + 1 || !published.some(value => value.kind === finalization.targetKind && value.id === finalization.release.id && value.revision === finalization.release.revision))
+        throw new LearningDomainError("authoring_draft_publication_mismatch", 422);
+    await requireLearningRelease(tx, finalization.targetKind, finalization.release);
+    const { contentHash: _hash, ...content } = draft;
+    const completed = AuthoringDraftSchema.parse(sealLearningContent({ ...content, revision: draft.revision + 1, status: "published", publishedRelease: finalization.release, updatedAt: now }));
+    await tx.put("draft", completed, draft.revision, { parentId: draft.targetKind, status: completed.status });
+    return { kind: "draft", id: completed.id, revision: completed.revision };
+}
+async function currentDraft(tx, ref) {
+    const draft = await requireLearningRelease(tx, "draft", ref);
+    const current = await tx.get("draft", ref.id);
+    if (!current || !sameLearningRef(learningRef(current), ref))
+        throw new LearningDomainError("authoring_draft_revision_stale", 409);
+    if (draft.status !== "draft")
+        throw new LearningDomainError("authoring_draft_closed", 409);
+    return draft;
+}

package/dist/learning/authoring.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
+import { RewardBindingSourceSchema, RewardReleaseRefSchema } from "../rewards.js";
+import { LearningRevisionRefSchema } from "./contracts.js";
+/** Strings intentionally preserve incomplete JSON/code until explicit publication. */
+export const RewardAuthoringFieldsSchema = z.object({
+    name: z.string().max(500), description: z.string().max(10_000),
+    kind: z.enum(["custom_verifier", "state", "content", "schema", "artifact", "runtime_event", "model_judge", "learned_model", "human"]),
+    fields: z.string(), outputField: z.string(), expectedField: z.string(), expectedValue: z.string(),
+    schema: z.string(), reference: z.string(), events: z.string(), code: z.string(), exportName: z.string(), timeout: z.string(),
+    rubric: z.string(), providerId: z.string(), modelId: z.string(), modelRevision: z.string(), temperature: z.string(),
+    reviewerRole: z.string(), learnedId: z.string(), learnedHash: z.string(), inputContract: z.string(), minimum: z.string(), maximum: z.string(),
+}).strict();
+export const TaskFormatAuthoringFieldsSchema = z.object({
+    name: z.string().max(500), description: z.string().max(10_000), instructions: z.string().max(20_000),
+    input: z.string(), output: z.string(), familyNamespace: z.string(),
+    sources: z.array(RewardBindingSourceSchema).max(100), recipeRef: RewardReleaseRefSchema.optional(),
+}).strict();
+export const CombinedRewardAuthoringFieldsSchema = z.object({
+    name: z.string().max(500), description: z.string().max(10_000), sources: z.array(RewardBindingSourceSchema).max(100),
+}).strict();
+export const AuthoringTargetKindSchema = z.enum(["definition", "reward", "binding"]);
+const base = z.object({ id: ReleaseIdSchema, targetId: ReleaseIdSchema, baseRelease: LearningRevisionRefSchema.nullable(), editorVersion: z.literal("openpond.modelsEditor.v1") });
+export const AuthoringDraftInputSchema = z.discriminatedUnion("targetKind", [
+    base.extend({ targetKind: z.literal("definition"), fields: TaskFormatAuthoringFieldsSchema }).strict(),
+    base.extend({ targetKind: z.literal("reward"), fields: RewardAuthoringFieldsSchema }).strict(),
+    base.extend({ targetKind: z.literal("binding"), fields: CombinedRewardAuthoringFieldsSchema }).strict(),
+]);
+const history = {
+    schemaVersion: z.literal("openpond.authoringDraft.v1"), revision: z.number().int().positive(),
+    status: z.enum(["draft", "archived", "published"]), publishedRelease: LearningRevisionRefSchema.nullable(),
+    createdAt: ReleaseTimestampSchema, updatedAt: ReleaseTimestampSchema,
+};
+export const AuthoringDraftContentSchema = z.discriminatedUnion("targetKind", [AuthoringDraftInputSchema.options[0].extend(history).strict(), AuthoringDraftInputSchema.options[1].extend(history).strict(), AuthoringDraftInputSchema.options[2].extend(history).strict()]);
+export const AuthoringDraftSchema = z.discriminatedUnion("targetKind", [AuthoringDraftContentSchema.options[0].extend({ contentHash: ReleaseHashSchema }).strict(), AuthoringDraftContentSchema.options[1].extend({ contentHash: ReleaseHashSchema }).strict(), AuthoringDraftContentSchema.options[2].extend({ contentHash: ReleaseHashSchema }).strict()]);
+/** Exact draft and resulting release are finalized in the publication transaction. */
+export const AuthoringDraftFinalizationSchema = z.object({ draft: LearningRevisionRefSchema, targetKind: AuthoringTargetKindSchema, release: LearningRevisionRefSchema }).strict();

package/dist/learning/index.js

@@ -7,3 +7,4 @@ export * from "./service.js";
 export * from "./grade-worker.js";
 export * from "./transport.js";
 export * from "./errors.js";
+export * from "./authoring.js";

package/dist/learning/operations.js

@@ -2,9 +2,10 @@ import { z } from "zod";
 import { ReleaseIdSchema } from "@openpond/harness";
 import { LearningJsonObjectSchema, LearningRevisionRefSchema, LearningSourceContentSchema, TaskDefinitionContentSchema, TaskExampleSubmissionSchema, TaskFeedbackSubmissionSchema, LearningPolicyContentSchema } from "./contracts.js";
 import { RewardBindingContentSchema, RewardReleaseContentSchema } from "../rewards.js";
+import { AuthoringDraftInputSchema, AuthoringDraftFinalizationSchema } from "./authoring.js";
 import { LearningTextAssetContentSchema } from "./assets.js";
 const command = z.object({ operationId: ReleaseIdSchema });
-const publish = command.extend({ action: z.literal("publish"), expectedRevision: z.number().int().nonnegative() });
+const publish = command.extend({ action: z.literal("publish"), expectedRevision: z.number().int().nonnegative(), finalizeDraft: AuthoringDraftFinalizationSchema.optional() });
 export const PublishLearningResourceCommandSchema = z.discriminatedUnion("kind", [
     publish.extend({ kind: z.literal("asset"), content: LearningTextAssetContentSchema }).strict(),
     publish.extend({ kind: z.literal("definition"), content: TaskDefinitionContentSchema }).strict(),
@@ -15,7 +16,8 @@ export const PublishLearningResourceCommandSchema = z.discriminatedUnion("kind",
 ]);
 export const PublishLearningResourcesCommandSchema = command.extend({
     action: z.literal("publish_resources"),
-    resources: z.array(z.union(PublishLearningResourceCommandSchema.options.map((schema) => schema.omit({ operationId: true, action: true })))).min(1).max(20),
+    finalizeDraft: AuthoringDraftFinalizationSchema.optional(),
+    resources: z.array(z.union(PublishLearningResourceCommandSchema.options.map((schema) => schema.omit({ operationId: true, action: true, finalizeDraft: true })))).min(1).max(20),
 }).strict();
 export const SubmitTaskExampleCommandSchema = command.extend({ action: z.literal("submit_example"), example: TaskExampleSubmissionSchema }).strict();
 export const SubmitTaskFeedbackCommandSchema = command.extend({ action: z.literal("submit_feedback"), feedback: TaskFeedbackSubmissionSchema }).strict();
@@ -30,4 +32,6 @@ export const ReviewTaskEvidenceCommandSchema = command.extend({
 }).strict();
 export const SealTaskBatchCommandSchema = command.extend({ action: z.literal("seal_batch"), batchId: ReleaseIdSchema, taskDefinition: LearningRevisionRefSchema, purpose: z.enum(["supervised_training", "reward_training", "evaluation"]), evidence: z.array(LearningRevisionRefSchema).min(1).max(10_000), decisions: z.array(LearningRevisionRefSchema).min(1).max(10_000) }).strict();
 export const CancelTaskGradeCommandSchema = command.extend({ action: z.literal("cancel_grade"), gradeId: ReleaseIdSchema, expectedRevision: z.number().int().positive() }).strict();
-export const LearningCommandSchema = z.union([PublishLearningResourceCommandSchema, PublishLearningResourcesCommandSchema, SubmitTaskExampleCommandSchema, SubmitTaskFeedbackCommandSchema, ApplyTaskCorrectionCommandSchema, ResolveTaskFeedbackCommandSchema, QueueTaskGradeCommandSchema, ReviewTaskEvidenceCommandSchema, SealTaskBatchCommandSchema, CancelTaskGradeCommandSchema]);
+export const SaveAuthoringDraftCommandSchema = command.extend({ action: z.literal("save_draft"), expectedRevision: z.number().int().nonnegative(), draft: AuthoringDraftInputSchema }).strict();
+export const ArchiveAuthoringDraftCommandSchema = command.extend({ action: z.literal("archive_draft"), draft: LearningRevisionRefSchema }).strict();
+export const LearningCommandSchema = z.union([SaveAuthoringDraftCommandSchema, ArchiveAuthoringDraftCommandSchema, PublishLearningResourceCommandSchema, PublishLearningResourcesCommandSchema, SubmitTaskExampleCommandSchema, SubmitTaskFeedbackCommandSchema, ApplyTaskCorrectionCommandSchema, ResolveTaskFeedbackCommandSchema, QueueTaskGradeCommandSchema, ReviewTaskEvidenceCommandSchema, SealTaskBatchCommandSchema, CancelTaskGradeCommandSchema]);

package/dist/learning/repository.js

@@ -4,8 +4,10 @@ import { assertLearningContentHash, LearningSourceSchema, TaskAdmissionDecisionS
 import { RewardBindingSchema, RewardReleaseSchema } from "../rewards.js";
 import { TasksetReleaseSchema } from "../tasksets.js";
 import { LearningDomainError } from "./errors.js";
+import { AuthoringDraftSchema } from "./authoring.js";
 import { LearningTextAssetSchema } from "./assets.js";
 export const learningResourceSchemas = {
+    draft: AuthoringDraftSchema,
     asset: LearningTextAssetSchema,
     definition: TaskDefinitionSchema, reward: RewardReleaseSchema, binding: RewardBindingSchema,
     source: LearningSourceSchema, evidence: TaskEvidenceSchema, feedback: TaskFeedbackSchema,

package/dist/learning/service.js

@@ -1,3 +1,4 @@
+import { saveAuthoringDraft, archiveAuthoringDraft, finalizeAuthoringDraft } from "./authoring-service.js";
 import { LearningDomainError } from "./errors.js";
 import { contentHash } from "@openpond/harness";
 import { createRewardBinding, createRewardRelease, resolveBoundRewards } from "../rewards.js";
@@ -27,6 +28,12 @@ export function createLearningService(repository, options = {}) {
             }
             let pointers;
             switch (input.action) {
+                case "save_draft":
+                    pointers = [await saveAuthoringDraft(transaction, input, now())];
+                    break;
+                case "archive_draft":
+                    pointers = [await archiveAuthoringDraft(transaction, input.draft, now())];
+                    break;
                 case "publish":
                     pointers = [await publish(transaction, input)];
                     break;
@@ -61,6 +68,11 @@ export function createLearningService(repository, options = {}) {
                     pointers = await seal(transaction, input, context.actor.id);
                     break;
             }
+            if (input.action === "publish" || input.action === "publish_resources") {
+                const finalized = await finalizeAuthoringDraft(transaction, input, pointers, now());
+                if (finalized)
+                    pointers.push(finalized);
+            }
             await transaction.saveOperation(operationId, { requestHash, resources: pointers });
             return { operationId: input.operationId, resources: await Promise.all(pointers.map((pointer) => requireLearningResource(transaction, pointer.kind, pointer.id, pointer.revision))) };
         });

package/dist/types/javascript-environment-attempt.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { type ToolDeclaration } from "@openpond/harness";
+import { createJavaScriptEnvironmentSession, type JavaScriptEnvironmentSnapshot } from "./javascript-environment.js";
+declare const ToolCallSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+declare const PolicyTurnSchema: z.ZodObject<{
+    text: z.ZodString;
+    toolCalls: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type JavaScriptEnvironmentToolCall = z.infer<typeof ToolCallSchema>;
+export type JavaScriptEnvironmentPolicyTurn = z.infer<typeof PolicyTurnSchema>;
+export type JavaScriptEnvironmentPolicyMessage = {
+    role: "system" | "user";
+    text: string;
+} | {
+    role: "assistant";
+    text: string;
+    toolCalls: JavaScriptEnvironmentToolCall[];
+} | {
+    role: "tool";
+    callId: string;
+    name: string;
+    observation: Record<string, unknown>;
+};
+export interface JavaScriptEnvironmentAttempt {
+    schemaVersion: "openpond.javascriptEnvironmentAttempt.v1";
+    taskId: string;
+    status: "completed" | "budget_exhausted" | "cancelled" | "timed_out" | "policy_failure" | "environment_failure";
+    output: string | null;
+    snapshot: JavaScriptEnvironmentSnapshot | null;
+    collected: boolean;
+    environmentCleanupComplete: boolean;
+    messages: JavaScriptEnvironmentPolicyMessage[];
+    error: string | null;
+    contentHash: string;
+}
+/** The policy receives observations, never source, initial state or evaluator
+ * targets. Its final text cannot replace state recorded by the environment.
+ * The policy adapter must honor signal and settle after its own cancellation. */
+export declare function runJavaScriptEnvironmentAttempt(input: Parameters<typeof createJavaScriptEnvironmentSession>[0] & {
+    taskId: string;
+    instructions: string;
+    timeoutMs: number;
+    policy: (input: {
+        messages: JavaScriptEnvironmentPolicyMessage[];
+        tools: ToolDeclaration[];
+        signal: AbortSignal;
+    }) => Promise<JavaScriptEnvironmentPolicyTurn>;
+}): Promise<JavaScriptEnvironmentAttempt>;
+export {};
+//# sourceMappingURL=javascript-environment-attempt.d.ts.map

package/dist/types/javascript-environment-attempt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-environment-attempt.d.ts","sourceRoot":"","sources":["../../../../src/javascript-environment-attempt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,KAAK,eAAe,EAAe,MAAM,mBAAmB,CAAC;AAEtE,OAAO,EAAE,kCAAkC,EAAoC,KAAK,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AAEvJ,QAAA,MAAM,cAAc;;;;kBAAuI,CAAC;AAC5J,QAAA,MAAM,gBAAgB;;;;;;;kBAAoG,CAAC;AAC3H,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAC3E,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/E,MAAM,MAAM,kCAAkC,GAC1C;IAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,6BAA6B,EAAE,CAAA;CAAE,GAC/E;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC;AAEzF,MAAM,WAAW,4BAA4B;IAC3C,aAAa,EAAE,0CAA0C,CAAC;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,GAAG,kBAAkB,GAAG,WAAW,GAAG,WAAW,GAAG,gBAAgB,GAAG,qBAAqB,CAAC;IAChH,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,EAAE,6BAA6B,GAAG,IAAI,CAAC;IAC/C,SAAS,EAAE,OAAO,CAAC;IACnB,0BAA0B,EAAE,OAAO,CAAC;IACpC,QAAQ,EAAE,kCAAkC,EAAE,CAAC;IAC/C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;iFAEiF;AACjF,wBAAsB,+BAA+B,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,kCAAkC,CAAC,CAAC,CAAC,CAAC,GAAG;IACtH,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE,kCAAkC,EAAE,CAAC;QAAC,KAAK,EAAE,eAAe,EAAE,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,+BAA+B,CAAC,CAAC;CAChK,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAiFxC"}

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

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export declare const JavaScriptEnvironmentDefinitionContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.javascriptEnvironment.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    module: z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        mediaType: z.ZodString;
+        visibility: z.ZodEnum<{
+            policy: "policy";
+            verifier: "verifier";
+            host_private: "host_private";
+        }>;
+    }, z.core.$strict>;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        inputSchemaHash: z.ZodString;
+        sideEffect: z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>>;
+    maxSteps: z.ZodNumber;
+    maxStateBytes: z.ZodNumber;
+    maxObservationBytes: z.ZodNumber;
+    operationTimeoutMs: z.ZodNumber;
+}, z.core.$strict>;
+export declare const JavaScriptEnvironmentDefinitionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.javascriptEnvironment.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    module: z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        mediaType: z.ZodString;
+        visibility: z.ZodEnum<{
+            policy: "policy";
+            verifier: "verifier";
+            host_private: "host_private";
+        }>;
+    }, z.core.$strict>;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        inputSchemaHash: z.ZodString;
+        sideEffect: z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>>;
+    maxSteps: z.ZodNumber;
+    maxStateBytes: z.ZodNumber;
+    maxObservationBytes: z.ZodNumber;
+    operationTimeoutMs: z.ZodNumber;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type JavaScriptEnvironmentDefinition = z.infer<typeof JavaScriptEnvironmentDefinitionSchema>;
+export declare const JavaScriptEnvironmentOperationSchema: z.ZodEnum<{
+    create: "create";
+    reset: "reset";
+    step: "step";
+    collect: "collect";
+    destroy: "destroy";
+}>;
+export declare const JavaScriptEnvironmentResultSchema: z.ZodObject<{
+    state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    observation: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+export type JavaScriptEnvironmentResult = z.infer<typeof JavaScriptEnvironmentResultSchema>;
+export type JavaScriptEnvironmentOperation = z.infer<typeof JavaScriptEnvironmentOperationSchema>;
+export declare function assertJavaScriptEnvironmentDefinition(value: unknown): JavaScriptEnvironmentDefinition;
+//# sourceMappingURL=javascript-environment-contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-environment-contract.d.ts","sourceRoot":"","sources":["../../../../src/javascript-environment-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgBvD,CAAC;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA+G,CAAC;AAClK,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAEpG,eAAO,MAAM,oCAAoC;;;;;;EAA4D,CAAC;AAC9G,eAAO,MAAM,iCAAiC;;;kBAGnC,CAAC;AACZ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAC5F,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAElG,wBAAgB,qCAAqC,CAAC,KAAK,EAAE,OAAO,GAAG,+BAA+B,CAMrG"}

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

@@ -0,0 +1,5 @@
+import type { JavaScriptEnvironmentExecutionInput } from "./javascript-environment.js";
+import { type JavaScriptEnvironmentResult } from "./javascript-environment-contract.js";
+/** The execution owner awaits termination before recording a step or cleanup. */
+export declare function executeJavaScriptEnvironmentInWorker(input: JavaScriptEnvironmentExecutionInput): Promise<JavaScriptEnvironmentResult>;
+//# sourceMappingURL=javascript-environment-node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-environment-node.d.ts","sourceRoot":"","sources":["../../../../src/javascript-environment-node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,6BAA6B,CAAC;AACvF,OAAO,EAA2E,KAAK,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAGjK,iFAAiF;AACjF,wBAAsB,oCAAoC,CAAC,KAAK,EAAE,mCAAmC,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAG3I"}

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

@@ -0,0 +1,100 @@
+import { type LearningTextAsset } from "./learning/assets.js";
+import { type JavaScriptEnvironmentDefinition, type JavaScriptEnvironmentOperation, type JavaScriptEnvironmentResult } from "./javascript-environment-contract.js";
+export * from "./javascript-environment-contract.js";
+export interface JavaScriptEnvironmentExecutionInput {
+    source: string;
+    operation: JavaScriptEnvironmentOperation;
+    value: Record<string, unknown>;
+    timeoutMs: number;
+    signal?: AbortSignal;
+}
+/** Pure, bounded module execution. Server hosts should provide the worker runner. */
+export declare function executeJavaScriptEnvironment(input: JavaScriptEnvironmentExecutionInput): Promise<JavaScriptEnvironmentResult>;
+export interface JavaScriptEnvironmentEvent {
+    sequence: number;
+    operation: JavaScriptEnvironmentOperation;
+    toolName: string | null;
+    arguments: Record<string, unknown> | null;
+    observation: Record<string, unknown> | null;
+    beforeStateHash: string;
+    afterStateHash: string;
+    error: string | null;
+}
+export interface JavaScriptEnvironmentSnapshot {
+    definition: {
+        id: string;
+        revision: number;
+        contentHash: string;
+    };
+    inputHash: string;
+    seed: number;
+    initialStateHash: string;
+    finalStateHash: string;
+    state: Record<string, unknown>;
+    events: JavaScriptEnvironmentEvent[];
+}
+export declare class JavaScriptEnvironmentActionError extends Error {
+    readonly code: "unknown_tool" | "invalid_arguments" | "step_budget_exhausted";
+    constructor(code: "unknown_tool" | "invalid_arguments" | "step_budget_exhausted");
+}
+type Runner = (input: JavaScriptEnvironmentExecutionInput) => Promise<JavaScriptEnvironmentResult>;
+/** One episode, with owner-held state that is never accepted from model output.
+ * Read-only tools and collection cannot change it. Call destroy in a finally block. */
+export declare function createJavaScriptEnvironmentSession(input: {
+    definition: JavaScriptEnvironmentDefinition;
+    asset: LearningTextAsset;
+    input: Record<string, unknown>;
+    initialState: Record<string, unknown>;
+    seed: number;
+    execute?: Runner;
+    signal?: AbortSignal;
+}): Promise<{
+    definition: {
+        schemaVersion: "openpond.javascriptEnvironment.v1";
+        id: string;
+        revision: number;
+        module: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "policy" | "verifier" | "host_private";
+        };
+        tools: {
+            name: string;
+            description: string;
+            inputSchema: Record<string, unknown>;
+            inputSchemaHash: string;
+            sideEffect: "read" | "write";
+            timeoutMs: number;
+        }[];
+        maxSteps: number;
+        maxStateBytes: number;
+        maxObservationBytes: number;
+        operationTimeoutMs: number;
+        contentHash: string;
+    };
+    observation: Record<string, unknown>;
+    step(action: {
+        name: string;
+        arguments: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+    collect(): Promise<{
+        observation: Record<string, unknown>;
+        definition: {
+            id: string;
+            revision: number;
+            contentHash: string;
+        };
+        inputHash: string;
+        seed: number;
+        initialStateHash: string;
+        finalStateHash: string;
+        state: Record<string, unknown>;
+        events: JavaScriptEnvironmentEvent[];
+    }>;
+    snapshot: () => JavaScriptEnvironmentSnapshot;
+    destroy: () => Promise<void>;
+}>;
+//# sourceMappingURL=javascript-environment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-environment.d.ts","sourceRoot":"","sources":["../../../../src/javascript-environment.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAGvF,OAAO,EAAkH,KAAK,+BAA+B,EAAE,KAAK,8BAA8B,EAAE,KAAK,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnR,cAAc,sCAAsC,CAAC;AAErD,MAAM,WAAW,mCAAmC;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,8BAA8B,CAAC;IAC1C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,qFAAqF;AACrF,wBAAsB,4BAA4B,CAAC,KAAK,EAAE,mCAAmC,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAGnI;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,8BAA8B,CAAC;IAC1C,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5C,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,6BAA6B;IAC5C,UAAU,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,MAAM,EAAE,0BAA0B,EAAE,CAAC;CACtC;AAED,qBAAa,gCAAiC,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,mBAAmB,GAAG,uBAAuB;gBAApE,IAAI,EAAE,cAAc,GAAG,mBAAmB,GAAG,uBAAuB;CAI1F;AAED,KAAK,MAAM,GAAG,CAAC,KAAK,EAAE,mCAAmC,KAAK,OAAO,CAAC,2BAA2B,CAAC,CAAC;AAEnG;uFACuF;AACvF,wBAAsB,kCAAkC,CAAC,KAAK,EAAE;IAC9D,UAAU,EAAE,+BAA+B,CAAC;IAC5C,KAAK,EAAE,iBAAiB,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0EwB;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE;;;oBAtG/D;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAA;SAAE;mBACtD,MAAM;cACX,MAAM;0BACM,MAAM;wBACR,MAAM;eACf,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBACtB,0BAA0B,EAAE;;oBAyFb,6BAA6B;mBAlB1B,OAAO,CAAC,IAAI,CAAC;GAqCxC"}

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

@@ -0,0 +1,4 @@
+import { type JavaScriptIsolateInput } from "./javascript-isolate.js";
+/** Both environment steps and graders settle only after their worker stops. */
+export declare function executeJavaScriptIsolateInWorker(input: JavaScriptIsolateInput): Promise<unknown>;
+//# sourceMappingURL=javascript-isolate-node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-isolate-node.d.ts","sourceRoot":"","sources":["../../../../src/javascript-isolate-node.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkC,KAAK,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAGtG,+EAA+E;AAC/E,wBAAsB,gCAAgC,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,CAsCtG"}

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

@@ -0,0 +1,14 @@
+export interface JavaScriptIsolateInput {
+    source: string;
+    exportName: string;
+    value: unknown;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    maxResultBytes: number;
+    deterministic?: boolean;
+    errorPrefix: "verifier" | "environment";
+}
+/** Authored code is interpreter data, with no host functions or module loader. */
+export declare function executeJavaScriptIsolate(input: JavaScriptIsolateInput): Promise<unknown>;
+export declare function validateJavaScriptIsolateInput(input: JavaScriptIsolateInput): void;
+//# sourceMappingURL=javascript-isolate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-isolate.d.ts","sourceRoot":"","sources":["../../../../src/javascript-isolate.ts"],"names":[],"mappings":"AAIA,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,CAAC;CACzC;AAED,kFAAkF;AAClF,wBAAsB,wBAAwB,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,CAkC9F;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAKlF"}

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":"AACA,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,CAqCjJ"}
+{"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;AAGlH,8EAA8E;AAC9E,wBAAsB,iCAAiC,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAEjJ"}

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

@@ -1,10 +1,7 @@
 import { type JavaScriptVerifierResult } from "./javascript-verifier-contract.js";
 export { JavaScriptVerifierResultSchema, type JavaScriptVerifierResult } from "./javascript-verifier-contract.js";
-/**
- * A fresh WebAssembly interpreter with no host functions, filesystem, network,
- * timers, or module loader. Hosts should run this on a worker to remain responsive
- * and terminate that worker when cancellation is requested.
- */
+/** A fresh interpreter with no filesystem, network, timers or module loader.
+ * Hosts should use the worker entrypoint for cancellation and responsiveness. */
 export declare function executeJavaScriptVerifier(input: {
     source: string;
     exportName?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"javascript-verifier.d.ts","sourceRoot":"","sources":["../../../../src/javascript-verifier.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkC,KAAK,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAClH,OAAO,EAAE,8BAA8B,EAAE,KAAK,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAElH;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,KAAK,EAAE;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAgCpC"}
+{"version":3,"file":"javascript-verifier.d.ts","sourceRoot":"","sources":["../../../../src/javascript-verifier.ts"],"names":[],"mappings":"AACA,OAAO,EAAkC,KAAK,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAClH,OAAO,EAAE,8BAA8B,EAAE,KAAK,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAElH;iFACiF;AACjF,wBAAsB,yBAAyB,CAAC,KAAK,EAAE;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAGpC"}

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

@@ -0,0 +1,25 @@
+import { type AuthoringDraftInput } from "./authoring.js";
+import { type LearningRevisionRef } from "./contracts.js";
+import { type LearningResourcePointer, type LearningTransaction } from "./repository.js";
+import type { LearningCommand } from "./operations.js";
+export declare function saveAuthoringDraft(tx: LearningTransaction, input: {
+    draft: AuthoringDraftInput;
+    expectedRevision: number;
+}, now: string): Promise<{
+    kind: "draft";
+    id: string;
+    revision: number;
+}>;
+export declare function archiveAuthoringDraft(tx: LearningTransaction, ref: LearningRevisionRef, now: string): Promise<{
+    kind: "draft";
+    id: string;
+    revision: number;
+}>;
+export declare function finalizeAuthoringDraft(tx: LearningTransaction, input: Extract<LearningCommand, {
+    action: "publish" | "publish_resources";
+}>, published: LearningResourcePointer[], now: string): Promise<{
+    kind: "draft";
+    id: string;
+    revision: number;
+} | null>;
+//# sourceMappingURL=authoring-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"authoring-service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/authoring-service.ts"],"names":[],"mappings":"AACA,OAAO,EAAwB,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAEhF,OAAO,EAAqD,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC7G,OAAO,EAA0B,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACjH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,wBAAsB,kBAAkB,CAAC,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE;IAAE,KAAK,EAAE,mBAAmB,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,EAAE,MAAM;;;;GAY7I;AAED,wBAAsB,qBAAqB,CAAC,EAAE,EAAE,mBAAmB,EAAE,GAAG,EAAE,mBAAmB,EAAE,GAAG,EAAE,MAAM;;;;GAMzG;AAED,wBAAsB,sBAAsB,CAAC,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,SAAS,GAAG,mBAAmB,CAAA;CAAE,CAAC,EAAE,SAAS,EAAE,uBAAuB,EAAE,EAAE,GAAG,EAAE,MAAM;;;;UAUpM"}