spawnfile 0.1.17 → 0.1.19

package/dist/manifest/schemas.js

@@ -2,8 +2,9 @@ import { z } from "zod";
 import { agentScheduleSchema } from "./scheduleSchemas.js";
 import { executionSchema } from "./executionSchemas.js";
 import { memoryBanksSchema } from "./memorySchemas.js";
-import { mcpServerSchema } from "./mcpSchemas.js";
+import { mcpServerEntrySchema, sharedMcpServerSchema } from "./mcpSchemas.js";
 import { surfacesSchema } from "./surfaceSchemas.js";
+import { trainingDeclarationSchema } from "./trainingSchemas.js";
 import { externalParticipantServiceSchema } from "./externalParticipantSchemas.js";
 import { isDeclaredPairedRemoteRoomMember, teamNetworkSchema, teamWorkspaceSchema } from "./teamNetworkSchemas.js";
 const skillRequirementSchema = z
@@ -62,10 +63,10 @@ const packageSchema = z
         });
     }
 });
-const environmentSchema = z
+const createEnvironmentSchema = (serverSchema) => z
     .object({
     env: z.record(z.string(), z.string()).optional(),
-    mcp_servers: z.array(mcpServerSchema).optional(),
+    mcp_servers: z.array(serverSchema).optional(),
     packages: z.array(packageSchema).optional(),
     secrets: z.array(secretSchema).optional()
 })
@@ -79,6 +80,10 @@ const environmentSchema = z
         });
     }
 });
+// Team `shared.environment` declares complete servers; agent scope may also
+// narrow an inherited server with a transport-less override entry.
+const sharedEnvironmentSchema = createEnvironmentSchema(sharedMcpServerSchema);
+const environmentSchema = createEnvironmentSchema(mcpServerEntrySchema);
 const commonManifestSchema = z
     .object({
     description: z.string().optional(),
@@ -102,7 +107,8 @@ const subagentSchema = z
     .strict();
 const sharedSurfaceSchema = z
     .object({
-    environment: environmentSchema.optional(),
+    environment: sharedEnvironmentSchema.optional(),
+    training: trainingDeclarationSchema.optional(),
     workspace: teamWorkspaceSchema.optional()
 })
     .strict();
@@ -134,6 +140,7 @@ const inlineAgentMemberSchema = z
     runtime: runtimeBindingSchema.optional(),
     schedule: agentScheduleSchema.optional(),
     surfaces: surfacesSchema.optional(),
+    training: trainingDeclarationSchema.optional(),
     workspace: teamWorkspaceSchema
 })
     .strict()
@@ -162,6 +169,7 @@ const agentManifestSchema = commonManifestSchema
     runtime: runtimeBindingSchema.optional(),
     schedule: agentScheduleSchema.optional(),
     subagents: z.array(subagentSchema).optional(),
+    training: trainingDeclarationSchema.optional(),
     workspace: teamWorkspaceSchema.optional()
 })
     .superRefine(refineAgentMemoryAccess)
@@ -258,7 +266,9 @@ export const manifestSchema = z.discriminatedUnion("kind", [
     agentManifestSchema,
     teamManifestSchema
 ]);
+export { isMcpServerDeclaration } from "./mcpSchemas.js";
 export { isDeclaredPairedRemoteRoomMember } from "./teamNetworkSchemas.js";
+export { FEED_CLOCK_PATTERN, FEED_REF_PLACEHOLDER, isFeedTimeZone } from "./volumeFeedSchemas.js";
 export const isAgentManifest = (manifest) => manifest.kind === "agent";
 export const isTeamManifest = (manifest) => manifest.kind === "team";
 export const isInlineAgentMember = (member) => !("ref" in member);

package/dist/manifest/teamNetworkSchemas.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 export { teamWorkspaceDocsSchema, teamWorkspaceSchema } from "./workspaceSchemas.js";
-export type { TeamWorkspace, TeamWorkspaceDocs, TeamWorkspaceResource, TeamWorkspaceResource as TeamNetworkResource } from "./workspaceSchemas.js";
+export type { TeamWorkspace, TeamWorkspaceDocs, TeamWorkspaceResource, TeamWorkspaceResource as TeamNetworkResource, WorkspaceBundleBuild } from "./workspaceSchemas.js";
 export type { TeamNetworkAuth } from "./teamNetworkAuthSchemas.js";
 export type { TeamNetworkServer, TeamNetworkStore } from "./teamNetworkServerSchemas.js";
 declare const teamNetworkRoomSchema: z.ZodObject<{

package/dist/manifest/trainingDataSchemas.d.ts

@@ -0,0 +1,357 @@
+import { z } from "zod";
+export declare const trainingInstantSchema: z.ZodISODateTime;
+export declare const trainingWakeSchema: z.ZodObject<{
+    surface: z.ZodLiteral<"moltnet">;
+    room: z.ZodString;
+    from: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>;
+export declare const trainingDatasetSchema: z.ZodObject<{
+    examples: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        at: z.ZodISODateTime;
+        wake: z.ZodObject<{
+            surface: z.ZodLiteral<"moltnet">;
+            room: z.ZodString;
+            from: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>;
+        memory: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            access: z.ZodOptional<z.ZodObject<{
+                members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            consolidation: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                    disabled: "disabled";
+                    on_threshold: "on_threshold";
+                    scheduled: "scheduled";
+                }>>>;
+                schedule: z.ZodOptional<z.ZodString>;
+                summarize_after_events: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            id: z.ZodString;
+            index: z.ZodOptional<z.ZodObject<{
+                graph: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                    kind: z.ZodOptional<z.ZodEnum<{
+                        entity_graph: "entity_graph";
+                        temporal_kg: "temporal_kg";
+                    }>>;
+                }, z.core.$strict>>;
+                lexical: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                    engine: z.ZodOptional<z.ZodEnum<{
+                        sqlite_fts: "sqlite_fts";
+                        bm25: "bm25";
+                    }>>;
+                }, z.core.$strict>>;
+                rerank: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                }, z.core.$strict>>;
+                vector: z.ZodOptional<z.ZodObject<{
+                    base_url: z.ZodOptional<z.ZodString>;
+                    dimensions: z.ZodOptional<z.ZodNumber>;
+                    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                    model: z.ZodOptional<z.ZodString>;
+                    provider: z.ZodOptional<z.ZodEnum<{
+                        ollama: "ollama";
+                    }>>;
+                    timeout_ms: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            retention: z.ZodOptional<z.ZodObject<{
+                forgetting: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                    manual: "manual";
+                    decay: "decay";
+                    ttl: "ttl";
+                }>>>;
+                ttl: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            store: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"sqlite">;
+                path: z.ZodOptional<z.ZodString>;
+                persistence: z.ZodOptional<z.ZodObject<{
+                    mode: z.ZodEnum<{
+                        durable: "durable";
+                        ephemeral: "ephemeral";
+                    }>;
+                    mount: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"json">;
+                path: z.ZodOptional<z.ZodString>;
+                persistence: z.ZodOptional<z.ZodObject<{
+                    mode: z.ZodEnum<{
+                        durable: "durable";
+                        ephemeral: "ephemeral";
+                    }>;
+                    mount: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"postgres">;
+                dsn_secret: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"memory">;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>>>;
+        resources: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            auth: z.ZodOptional<z.ZodObject<{
+                ssh_key: z.ZodOptional<z.ZodString>;
+                ssh_key_env: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            branch: z.ZodOptional<z.ZodString>;
+            exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fetch: z.ZodOptional<z.ZodEnum<{
+                start: "start";
+                build: "build";
+            }>>;
+            id: z.ZodString;
+            kind: z.ZodLiteral<"git">;
+            mount: z.ZodString;
+            mode: z.ZodEnum<{
+                readonly: "readonly";
+                mutable: "mutable";
+            }>;
+            ref: z.ZodOptional<z.ZodString>;
+            sharing: z.ZodOptional<z.ZodEnum<{
+                per_agent: "per_agent";
+                team: "team";
+            }>>;
+            tag: z.ZodOptional<z.ZodString>;
+            url: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            build: z.ZodOptional<z.ZodObject<{
+                dependencies: z.ZodOptional<z.ZodObject<{
+                    check: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    dev: z.ZodOptional<z.ZodBoolean>;
+                    directory: z.ZodString;
+                    image: z.ZodString;
+                    manager: z.ZodOptional<z.ZodLiteral<"npm">>;
+                    scripts: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+                files: z.ZodOptional<z.ZodObject<{
+                    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    ref: z.ZodOptional<z.ZodString>;
+                    root: z.ZodString;
+                }, z.core.$strict>>;
+                generated: z.ZodOptional<z.ZodObject<{
+                    command: z.ZodArray<z.ZodString>;
+                    cwd: z.ZodOptional<z.ZodString>;
+                    image: z.ZodOptional<z.ZodString>;
+                    inputs: z.ZodArray<z.ZodObject<{
+                        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        ref: z.ZodOptional<z.ZodString>;
+                        root: z.ZodString;
+                    }, z.core.$strict>>;
+                    timeout_seconds: z.ZodOptional<z.ZodNumber>;
+                    tools: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            id: z.ZodString;
+            kind: z.ZodLiteral<"bundle">;
+            mount: z.ZodString;
+            mode: z.ZodLiteral<"readonly">;
+            sha256: z.ZodOptional<z.ZodString>;
+            sharing: z.ZodOptional<z.ZodLiteral<"per_agent">>;
+            source: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            feed: z.ZodOptional<z.ZodObject<{
+                directory: z.ZodOptional<z.ZodString>;
+                freeze: z.ZodOptional<z.ZodObject<{
+                    after: z.ZodString;
+                    timezone: z.ZodString;
+                }, z.core.$strict>>;
+                git: z.ZodOptional<z.ZodObject<{
+                    fetch: z.ZodOptional<z.ZodBoolean>;
+                    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    ref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        command: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        fallback: z.ZodOptional<z.ZodString>;
+                        template: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>]>>;
+                    repo: z.ZodString;
+                }, z.core.$strict>>;
+                include: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    from: z.ZodString;
+                    to: z.ZodString;
+                }, z.core.$strict>>>;
+                keep: z.ZodOptional<z.ZodNumber>;
+                owner: z.ZodOptional<z.ZodString>;
+                prepare: z.ZodOptional<z.ZodObject<{
+                    command: z.ZodArray<z.ZodString>;
+                    host: z.ZodOptional<z.ZodLiteral<true>>;
+                    image: z.ZodOptional<z.ZodString>;
+                    network: z.ZodOptional<z.ZodBoolean>;
+                    platform: z.ZodOptional<z.ZodEnum<{
+                        "linux/amd64": "linux/amd64";
+                        "linux/arm64": "linux/arm64";
+                    }>>;
+                    timeout_seconds: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+                validate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            id: z.ZodString;
+            kind: z.ZodLiteral<"volume">;
+            mount: z.ZodString;
+            mode: z.ZodEnum<{
+                readonly: "readonly";
+                mutable: "mutable";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            sharing: z.ZodOptional<z.ZodEnum<{
+                per_agent: "per_agent";
+                team: "team";
+            }>>;
+        }, z.core.$strict>], "kind">>>;
+        networks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            provider: z.ZodLiteral<"moltnet">;
+            rooms: z.ZodArray<z.ZodObject<{
+                federation: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                    none: "none";
+                    all: "all";
+                }>, z.ZodArray<z.ZodString>]>>;
+                id: z.ZodString;
+                members: z.ZodArray<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                visibility: z.ZodOptional<z.ZodEnum<{
+                    private: "private";
+                    public: "public";
+                }>>;
+                write_policy: z.ZodOptional<z.ZodEnum<{
+                    members: "members";
+                    registered_agents: "registered_agents";
+                    operators: "operators";
+                }>>;
+            }, z.core.$strict>>;
+            server: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                allowed_origins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                auth: z.ZodObject<{
+                    agent_registration: z.ZodOptional<z.ZodEnum<{
+                        disabled: "disabled";
+                        token: "token";
+                        open: "open";
+                    }>>;
+                    client: z.ZodOptional<z.ZodObject<{
+                        static_token: z.ZodOptional<z.ZodBoolean>;
+                        token_env: z.ZodOptional<z.ZodString>;
+                        token_id: z.ZodOptional<z.ZodString>;
+                        token_path: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    mode: z.ZodEnum<{
+                        none: "none";
+                        bearer: "bearer";
+                        open: "open";
+                    }>;
+                    public_read: z.ZodOptional<z.ZodBoolean>;
+                    tokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        id: z.ZodString;
+                        secret: z.ZodString;
+                        scopes: z.ZodArray<z.ZodEnum<{
+                            observe: "observe";
+                            write: "write";
+                            admin: "admin";
+                            attach: "attach";
+                            pair: "pair";
+                        }>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>;
+                console: z.ZodOptional<z.ZodObject<{
+                    analytics: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        provider: z.ZodLiteral<"google">;
+                        measurement_id: z.ZodString;
+                    }, z.core.$strict>], "provider">>;
+                }, z.core.$strict>>;
+                debug_events: z.ZodOptional<z.ZodBoolean>;
+                direct_messages: z.ZodOptional<z.ZodBoolean>;
+                human_ingress: z.ZodOptional<z.ZodBoolean>;
+                listen: z.ZodObject<{
+                    bind: z.ZodString;
+                    port: z.ZodNumber;
+                }, z.core.$strict>;
+                mode: z.ZodLiteral<"managed">;
+                pairings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    relay: z.ZodOptional<z.ZodObject<{
+                        room: z.ZodString;
+                        token_secret: z.ZodString;
+                        url: z.ZodString;
+                    }, z.core.$strict>>;
+                    remote_base_url: z.ZodOptional<z.ZodString>;
+                    remote_network_id: z.ZodString;
+                    remote_network_name: z.ZodString;
+                    token_secret: z.ZodString;
+                }, z.core.$strict>>>;
+                store: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    path: z.ZodOptional<z.ZodString>;
+                    persistence: z.ZodOptional<z.ZodObject<{
+                        mode: z.ZodEnum<{
+                            durable: "durable";
+                            ephemeral: "ephemeral";
+                        }>;
+                        mount: z.ZodOptional<z.ZodString>;
+                        name: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    kind: z.ZodLiteral<"sqlite">;
+                }, z.core.$strict>, z.ZodObject<{
+                    path: z.ZodOptional<z.ZodString>;
+                    persistence: z.ZodOptional<z.ZodObject<{
+                        mode: z.ZodEnum<{
+                            durable: "durable";
+                            ephemeral: "ephemeral";
+                        }>;
+                        mount: z.ZodOptional<z.ZodString>;
+                        name: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    kind: z.ZodLiteral<"json">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"postgres">;
+                    dsn_secret: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"memory">;
+                }, z.core.$strict>], "kind">;
+                trust_forwarded_proto: z.ZodOptional<z.ZodBoolean>;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                auth: z.ZodObject<{
+                    agent_registration: z.ZodOptional<z.ZodEnum<{
+                        disabled: "disabled";
+                        token: "token";
+                        open: "open";
+                    }>>;
+                    client: z.ZodOptional<z.ZodObject<{
+                        static_token: z.ZodOptional<z.ZodBoolean>;
+                        token_env: z.ZodOptional<z.ZodString>;
+                        token_id: z.ZodOptional<z.ZodString>;
+                        token_path: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    mode: z.ZodEnum<{
+                        none: "none";
+                        bearer: "bearer";
+                        open: "open";
+                    }>;
+                    public_read: z.ZodOptional<z.ZodBoolean>;
+                    tokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        id: z.ZodString;
+                        secret: z.ZodString;
+                        scopes: z.ZodArray<z.ZodEnum<{
+                            observe: "observe";
+                            write: "write";
+                            admin: "admin";
+                            attach: "attach";
+                            pair: "pair";
+                        }>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>;
+                mode: z.ZodLiteral<"external">;
+                url: z.ZodString;
+            }, z.core.$strict>], "mode">>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TrainingDataset = z.infer<typeof trainingDatasetSchema>;

package/dist/manifest/trainingDataSchemas.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { memoryBankSchema } from "./memorySchemas.js";
+import { teamNetworkSchema } from "./teamNetworkSchemas.js";
+import { teamWorkspaceResourceSchema } from "./workspaceSchemas.js";
+const uniqueIds = (entries, context) => {
+    const ids = new Set();
+    entries.forEach((entry, index) => {
+        if (ids.has(entry.id)) {
+            context.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate id ${entry.id}`, path: [index, "id"] });
+        }
+        ids.add(entry.id);
+    });
+};
+export const trainingInstantSchema = z.iso.datetime({ offset: true });
+export const trainingWakeSchema = z.object({
+    surface: z.literal("moltnet"),
+    room: z.string(),
+    from: z.string(),
+    text: z.string()
+}).strict();
+const trainingExampleSchema = z.object({
+    id: z.string().regex(/^[A-Za-z0-9._-]+$/u),
+    at: trainingInstantSchema,
+    wake: trainingWakeSchema,
+    memory: z.array(memoryBankSchema).optional(),
+    resources: z.array(teamWorkspaceResourceSchema).optional(),
+    networks: z.array(teamNetworkSchema).optional()
+}).strict();
+export const trainingDatasetSchema = z.object({
+    examples: z.array(trainingExampleSchema).min(1).superRefine(uniqueIds)
+}).strict();

package/dist/manifest/trainingSchemas.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export declare const trainingNameSchema: z.ZodString;
+/** Zod records skip __proto__ before validating keys, so inspect the authored map first. */
+export declare const trainingNamedMapSchema: <T extends z.ZodType>(valueSchema: T) => z.ZodPipe<z.ZodUnknown, z.ZodRecord<z.ZodString, T>>;
+export declare const trainingRelativePathSchema: z.ZodString;
+export declare const trainingTargetSchema: z.ZodObject<{
+    files: z.ZodArray<z.ZodString>;
+    grader: z.ZodString;
+    datasets: z.ZodObject<{
+        train: z.ZodString;
+        validation: z.ZodOptional<z.ZodString>;
+        test: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const trainingDeclarationSchema: z.ZodObject<{
+    deadlines: z.ZodOptional<z.ZodObject<{
+        experiment_ms: z.ZodOptional<z.ZodNumber>;
+        trial_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    preparation: z.ZodOptional<z.ZodObject<{
+        hook: z.ZodString;
+        history: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    record: z.ZodOptional<z.ZodObject<{
+        keep: z.ZodOptional<z.ZodString>;
+        volumes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    optimizer: z.ZodOptional<z.ZodObject<{
+        method: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        variants: z.ZodOptional<z.ZodNumber>;
+        keep: z.ZodOptional<z.ZodNumber>;
+        budget: z.ZodOptional<z.ZodObject<{
+            rounds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    graders: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodRecord<z.ZodString, z.ZodString>>>;
+    targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        files: z.ZodArray<z.ZodString>;
+        grader: z.ZodString;
+        datasets: z.ZodObject<{
+            train: z.ZodString;
+            validation: z.ZodOptional<z.ZodString>;
+            test: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type TrainingDeclaration = z.infer<typeof trainingDeclarationSchema>;
+export type TrainingTarget = z.infer<typeof trainingTargetSchema>;

package/dist/manifest/trainingSchemas.js

@@ -0,0 +1,44 @@
+import { posix, win32 } from "node:path";
+import { z } from "zod";
+export const trainingNameSchema = z.string().regex(/^[A-Za-z0-9_-]+$/u);
+/** Zod records skip __proto__ before validating keys, so inspect the authored map first. */
+export const trainingNamedMapSchema = (valueSchema) => z.unknown().superRefine((value, context) => {
+    if (typeof value === "object" && value !== null && Object.hasOwn(value, "__proto__")) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom, path: ["__proto__"], message: "training map key __proto__ is reserved"
+        });
+    }
+}).pipe(z.record(trainingNameSchema, valueSchema));
+export const trainingRelativePathSchema = z.string().min(1).refine((value) => !posix.isAbsolute(value) && !win32.isAbsolute(value) && !value.includes("\\"), { message: "training paths must be relative to the declaring file and use forward slashes" });
+const uniqueStrings = (schema, message) => z.array(schema).refine((values) => new Set(values).size === values.length, { message });
+const trainingRecordSchema = z.object({
+    keep: z.string().regex(/^[1-9][0-9]*[mhd]$/u, "keep must be a positive duration in m, h, or d").optional(),
+    volumes: uniqueStrings(z.string().min(1), "record volume ids must be unique").optional()
+}).strict();
+const trainingOptimizerSchema = z.object({
+    method: z.string().min(1).optional(),
+    model: z.string().min(1).optional(),
+    variants: z.number().int().min(1).optional(),
+    keep: z.number().int().min(1).optional(),
+    budget: z.object({ rounds: z.number().int().min(1).optional() }).strict().optional()
+}).strict();
+export const trainingTargetSchema = z.object({
+    files: uniqueStrings(trainingRelativePathSchema.endsWith(".md", "training target files must end in .md"), "training target files must be unique").min(1),
+    grader: trainingNameSchema,
+    datasets: z.object({
+        train: trainingRelativePathSchema,
+        validation: trainingRelativePathSchema.optional(),
+        test: trainingRelativePathSchema
+    }).strict()
+}).strict();
+export const trainingDeclarationSchema = z.object({
+    deadlines: z.object({
+        experiment_ms: z.number().int().min(1).max(604_800_000).optional(),
+        trial_ms: z.number().int().min(1).max(86_400_000).optional()
+    }).strict().optional(),
+    preparation: z.object({ hook: z.string().min(1), history: trainingRelativePathSchema.optional() }).strict().optional(),
+    record: trainingRecordSchema.optional(),
+    optimizer: trainingOptimizerSchema.optional(),
+    graders: trainingNamedMapSchema(trainingRelativePathSchema).optional(),
+    targets: z.array(trainingTargetSchema).optional()
+}).strict();

package/dist/manifest/volumeFeedSchemas.d.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+/** `${date}` (UTC) or `${date:<IANA zone>}`: the local date (YYYY-MM-DD) at refresh time. The only placeholder a ref or path template knows. */
+export declare const FEED_REF_PLACEHOLDER: RegExp;
+export declare const FEED_CLOCK_PATTERN: RegExp;
+export declare const isFeedTimeZone: (zone: string) => boolean;
+/** A ref resolved per refresh: a template or a command printing a ref, with an optional fallback when it does not exist yet. */
+declare const volumeFeedRefRuleSchema: z.ZodObject<{
+    command: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fallback: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Host-fed content for a volume: a host directory or a git ref Spawnfile copies into the volume by atomic
+ * swap (`spawnfile volume refresh`), never through the image. Exactly one source per feed.
+ */
+export declare const volumeFeedSchema: z.ZodObject<{
+    directory: z.ZodOptional<z.ZodString>;
+    freeze: z.ZodOptional<z.ZodObject<{
+        after: z.ZodString;
+        timezone: z.ZodString;
+    }, z.core.$strict>>;
+    git: z.ZodOptional<z.ZodObject<{
+        fetch: z.ZodOptional<z.ZodBoolean>;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        ref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            command: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fallback: z.ZodOptional<z.ZodString>;
+            template: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+        repo: z.ZodString;
+    }, z.core.$strict>>;
+    include: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strict>>>;
+    keep: z.ZodOptional<z.ZodNumber>;
+    owner: z.ZodOptional<z.ZodString>;
+    prepare: z.ZodOptional<z.ZodObject<{
+        command: z.ZodArray<z.ZodString>;
+        host: z.ZodOptional<z.ZodLiteral<true>>;
+        image: z.ZodOptional<z.ZodString>;
+        network: z.ZodOptional<z.ZodBoolean>;
+        platform: z.ZodOptional<z.ZodEnum<{
+            "linux/amd64": "linux/amd64";
+            "linux/arm64": "linux/arm64";
+        }>>;
+        timeout_seconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    validate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type VolumeFeedRefRule = z.infer<typeof volumeFeedRefRuleSchema>;
+export {};