spawnfile 0.1.14 → 0.1.18

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 {};

package/dist/manifest/volumeFeedSchemas.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { argvSchema, pinnedImageSchema } from "./commandSchemas.js";
+/** `${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 const FEED_REF_PLACEHOLDER = /\$\{date(?::([^}]*))?\}/gu;
+export const FEED_CLOCK_PATTERN = /^(?:[01]\d|2[0-3]):[0-5]\d$/u;
+export const isFeedTimeZone = (zone) => {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: zone });
+        return zone.trim() !== "";
+    }
+    catch {
+        return false;
+    }
+};
+const plainRelativePath = (entry) => !entry.startsWith("/") && !entry.split("/").some((segment) => segment === ".." || segment === "." || segment === "");
+/** Issues with the placeholders in a ref or path template: only `${date}` and `${date:<IANA zone>}` exist. */
+const templateIssues = (template, what) => {
+    const issues = [];
+    for (const match of template.matchAll(FEED_REF_PLACEHOLDER)) {
+        if (match[1] !== undefined && !isFeedTimeZone(match[1]))
+            issues.push(`${what} time zone ${JSON.stringify(match[1])} is not an IANA time zone`);
+    }
+    if (template.replace(FEED_REF_PLACEHOLDER, "").includes("${"))
+        issues.push(`${what}s know only \${date} and \${date:<time zone>}`);
+    return issues;
+};
+/** A ref resolved per refresh: a template or a command printing a ref, with an optional fallback when it does not exist yet. */
+const volumeFeedRefRuleSchema = z.object({
+    command: argvSchema.optional(),
+    fallback: z.string().trim().min(1).optional(),
+    template: z.string().trim().min(1).optional()
+}).strict().superRefine((value, context) => {
+    if ((value.command === undefined) === (value.template === undefined)) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "a volume feed ref rule must declare exactly one of template or command" });
+    }
+    if (value.template === undefined)
+        return;
+    for (const message of templateIssues(value.template, "volume feed ref template"))
+        context.addIssue({ code: z.ZodIssueCode.custom, message });
+});
+/**
+ * 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 const volumeFeedSchema = z.object({
+    directory: z.string().trim().min(1).optional(),
+    /** Once local time passes `after`, a volume that already landed this period's ref stops advancing until the period or the ref changes. */
+    freeze: z.object({
+        after: z.string().regex(FEED_CLOCK_PATTERN, "freeze.after must be HH:MM (24-hour)"),
+        timezone: z.string().trim().min(1).refine(isFeedTimeZone, "freeze.timezone must be an IANA time zone")
+    }).strict().optional(),
+    git: z.object({
+        fetch: z.boolean().optional(),
+        /** Directories to feed instead of the whole tree; each MAY carry `${date}` placeholders, expanded with the ref. */
+        paths: z.array(z.string().trim().min(1)).min(1).optional(),
+        ref: z.union([z.string().trim().min(1), volumeFeedRefRuleSchema]).optional(),
+        repo: z.string().trim().min(1)
+    }).strict().optional(),
+    /** Host directories (files not in the source, e.g. fonts) staged into the tree before `prepare`. */
+    include: z.array(z.object({
+        from: z.string().trim().min(1),
+        to: z.string().trim().min(1)
+    }).strict()).min(1).optional(),
+    keep: z.number().int().min(1).optional(),
+    owner: z.string().regex(/^\d+:\d+$/u, "owner must be <uid>:<gid>").optional(),
+    /** A command run inside the staged tree after fetch and before validate: in a digest-pinned image, or explicitly on the host. */
+    prepare: z.object({
+        command: argvSchema,
+        host: z.literal(true).optional(),
+        image: pinnedImageSchema.optional(),
+        network: z.boolean().optional(),
+        platform: z.enum(["linux/amd64", "linux/arm64"]).optional(),
+        timeout_seconds: z.number().int().positive().max(86_400).optional()
+    }).strict().superRefine((value, context) => {
+        if ((value.image === undefined) === (value.host === undefined)) {
+            context.addIssue({ code: z.ZodIssueCode.custom, message: "volume feed prepare must declare exactly one of image (digest-pinned) or host: true" });
+        }
+        if (value.host && (value.platform !== undefined || value.network !== undefined)) {
+            context.addIssue({ code: z.ZodIssueCode.custom, message: "volume feed prepare platform and network apply only to an image" });
+        }
+    }).optional(),
+    validate: z.array(z.string().min(1)).min(1).optional()
+}).strict().superRefine((value, context) => {
+    if ((value.directory === undefined) === (value.git === undefined)) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "volume feeds must declare exactly one of directory or git" });
+    }
+    for (const entry of value.git?.paths ?? []) {
+        const placeholders = templateIssues(entry, "volume feed git path template");
+        for (const message of placeholders)
+            context.addIssue({ code: z.ZodIssueCode.custom, message });
+        // A placeholder expands to YYYY-MM-DD, so the path is judged with one in its place.
+        if (placeholders.length === 0 && !plainRelativePath(entry.replace(FEED_REF_PLACEHOLDER, "0000-00-00"))) {
+            context.addIssue({ code: z.ZodIssueCode.custom, message: `volume feed git path ${entry} must be a plain repository-relative path` });
+        }
+    }
+    const targets = (value.include ?? []).map((entry) => entry.to);
+    for (const [index, to] of targets.entries()) {
+        if (!plainRelativePath(to))
+            context.addIssue({ code: z.ZodIssueCode.custom, message: `volume feed include target ${to} must be a plain tree-relative path` });
+        if (targets.some((other, at) => at !== index && (other === to || other.startsWith(`${to}/`)))) {
+            context.addIssue({ code: z.ZodIssueCode.custom, message: `volume feed include target ${to} overlaps another include` });
+        }
+    }
+});

package/dist/manifest/workspaceSchemas.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { volumeFeedSchema } from "./volumeFeedSchemas.js";
 export declare const teamWorkspaceDocsSchema: z.ZodObject<{
     extras: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     heartbeat: z.ZodOptional<z.ZodString>;
@@ -7,8 +8,49 @@ export declare const teamWorkspaceDocsSchema: z.ZodObject<{
     soul: z.ZodOptional<z.ZodString>;
     system: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-declare const teamWorkspaceResourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+/**
+ * Declared inputs Spawnfile builds into the bundle archive. Exactly one input kind per bundle:
+ * `files` (git-tracked files), `dependencies` (lockfile installed for the target platform in a
+ * pinned image) or `generated` (a declared command writing an output directory from declared inputs).
+ */
+declare const workspaceBundleBuildSchema: 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>;
+export declare const teamWorkspaceResourceSchema: 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;
@@ -24,6 +66,76 @@ declare const teamWorkspaceResourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     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;
@@ -53,7 +165,16 @@ export declare const teamWorkspaceSchema: z.ZodObject<{
         system: z.ZodOptional<z.ZodString>;
     }, 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;
@@ -69,6 +190,76 @@ export declare const teamWorkspaceSchema: z.ZodObject<{
         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;
@@ -92,5 +283,7 @@ export declare const teamWorkspaceSchema: z.ZodObject<{
 export type TeamWorkspace = z.infer<typeof teamWorkspaceSchema>;
 export type TeamWorkspaceDocs = z.infer<typeof teamWorkspaceDocsSchema>;
 export type TeamWorkspaceResource = z.infer<typeof teamWorkspaceResourceSchema>;
+export type WorkspaceBundleBuild = z.infer<typeof workspaceBundleBuildSchema>;
+export type VolumeFeed = z.infer<typeof volumeFeedSchema>;
 export type TeamWorkspaceSkill = z.infer<typeof workspaceSkillReferenceSchema>;
 export {};