@nylorun/runtime 0.26.0-beta → 0.28.0-beta

package/dist/api/http/routes/environments.js

@@ -1,332 +0,0 @@
-import { z } from "zod";
-import { ENVIRONMENT_EVENT_TYPES, ForkEnvironmentRequestSchema, isEnvironmentId, PutEnvironmentRequestSchema, RestoreEnvironmentRequestSchema, } from "@nylorun/core/contracts";
-import { deleteEnvironmentVersion, environmentVersions, restoreEnvironment, snapshotEnvironment, } from "../../../artifacts/disk.js";
-import { DeleteEnvironmentResponse, DeletedResponse, EnvironmentPage, EnvironmentRestore, EnvironmentSnapshot, EnvironmentVersions, ForkEnvironmentRequest, ForkEnvironmentResponse, RestoreEnvironmentRequest, EnvironmentSecretView, EnvironmentView, ListEnvironmentEventsResponse, ListEnvironmentSecretsResponse, ListEnvironmentsResponse, PutEnvironmentRequest, PutEnvironmentSecretRequest, PutEnvironmentSecretValueRequest, } from "../../components.js";
-import { fail } from "../../../tenant/http.js";
-import { actorOf, assertReaches, deleteEnvironment, environmentEventsOf, forkEnvironment, getEnvironment, listEnvironments, putEnvironment, resetEnvironment, secretRequestFor, stopEnvironment, } from "../../../tenant/environments.js";
-import { readJson } from "../body.js";
-import { tenantRoute } from "../define.js";
-import { environmentPage, pageQuery } from "./reads.js";
-import { jsonResponse } from "../respond.js";
-/** Reading an Environment: any caller that may use sessions, or change Environments. */
-const READ = {
-    credentials: ["application", "subject", "token"],
-    scopes: ["sessions:own", "environments:write"],
-};
-/** Creating, changing or deleting one, and writing its secrets. */
-const WRITE = {
-    credentials: ["application", "subject", "token"],
-    scopes: ["environments:write"],
-};
-const json = (schema, description) => ({
-    description,
-    content: { "application/json": { schema } },
-});
-const environmentId = z.object({
-    environmentId: z
-        .string()
-        .meta({ description: "The Environment id, percent-encoded: `users%2Falice%2Fweb` for `users/alice/web`" }),
-});
-const secretPath = environmentId.extend({
-    name: z.string().meta({
-        description: "The secret's name: the variable for `environment_secret` and `environment_variable`, a label for `bearer` and `headers`",
-    }),
-});
-/** The path's Environment id, or a 400 naming the rule. */
-function idOf(value) {
-    if (!isEnvironmentId(value))
-        return fail(400, "An Environment id is up to 200 characters: /-separated segments of letters, digits, '.', '_' and '-'");
-    return value;
-}
-/** `label=k=v`, repeated: every one must match. */
-function labelsOf(values) {
-    const labels = {};
-    for (const value of values ?? []) {
-        const at = value.indexOf("=");
-        if (at <= 0)
-            fail(400, `label must be key=value, not ${value}`);
-        labels[value.slice(0, at)] = value.slice(at + 1);
-    }
-    return labels;
-}
-export function environmentRoutes(api) {
-    tenantRoute(api, READ, {
-        method: "get",
-        path: "/v1/environments",
-        tags: ["Environments"],
-        summary: "List Environments",
-        description: "Every Environment with all the labels asked for. A token caller sees only the Environments its grants reach.",
-        request: {
-            query: pageQuery.extend({
-                label: z
-                    .union([z.string(), z.array(z.string())])
-                    .optional()
-                    .meta({ description: "`key=value`; repeat it to require several labels" }),
-            }),
-        },
-        responses: {
-            200: json(z.union([ListEnvironmentsResponse, EnvironmentPage]), "The Environments; limit opts into pagination"),
-        },
-    }, async (c) => jsonResponse(200, c.req.query("limit") !== undefined
-        ? await environmentPage(c.env.tenant, c.get("scope"), c.req.query(), labelsOf(c.req.queries("label")))
-        : await listEnvironments(c.env.tenant, labelsOf(c.req.queries("label")), c.get("scope"))));
-    tenantRoute(api, WRITE, {
-        method: "put",
-        path: "/v1/environments/{environmentId}",
-        tags: ["Environments"],
-        summary: "Create, find or change an Environment",
-        description: "Creates the Environment and its vault within the Tenant's limits, or answers the one with this id, so get-or-create is one call. It is made from one version of an environment manifest (`manifest: \"name\"` takes the latest, `\"name@n\"` version n) or from the inline fields, and never changes what it runs after that (protocol 14, D63): on an existing one, labels replace, `ownerUserId` sets or (with `null`) clears the owner guard, fields that match what it runs are accepted, and anything else is `409 environment_immutable`, which names the fork that makes a new Environment instead. Kind `pod` needs sandbox pods (`nylorun local sandbox enable`) and is created at once.",
-        request: {
-            params: environmentId,
-            body: { required: true, content: { "application/json": { schema: PutEnvironmentRequest } } },
-        },
-        responses: {
-            200: json(EnvironmentView, "The Environment"),
-            409: {
-                description: "An Environment with this id runs something else (`environment_immutable`), the Tenant holds as many Environments as it allows (`limit_exceeded`), kind pod without sandbox pods (`environment_unavailable`), or it is being deleted (`environment_busy`)",
-            },
-        },
-    }, async (c) => {
-        const id = idOf(c.req.param("environmentId"));
-        const body = PutEnvironmentRequestSchema.parse(await readJson(c.req.raw));
-        return jsonResponse(200, await putEnvironment(c.env.tenant, id, body, c.get("scope")));
-    });
-    tenantRoute(api, READ, {
-        method: "get",
-        path: "/v1/environments/{environmentId}",
-        tags: ["Environments"],
-        summary: "Get an Environment",
-        description: "Its recipe, versions, labels, owner guard, state and the sessions that name it (acting for a person, only theirs).",
-        request: { params: environmentId },
-        responses: { 200: json(EnvironmentView, "The Environment") },
-    }, async (c) => jsonResponse(200, await getEnvironment(c.env.tenant, idOf(c.req.param("environmentId")), c.get("scope"))));
-    tenantRoute(api, READ, {
-        method: "get",
-        path: "/v1/environments/{environmentId}/events",
-        tags: ["Environments"],
-        summary: "Read an Environment's events",
-        description: "`environment.created`, `.attached`, `.detached`, `.deleted`, a pod's `.running`, `.suspended`, `.relaunched`, `.lost`, `.reset` and `.failed`, and `environment.egress` for every connection its sandbox opens through egress-gate, naming the turns that were running (D67), in order, numbered from 0, at most 1000 per call.",
-        request: {
-            params: environmentId,
-            query: z.object({
-                from: z.string().optional().meta({ description: "The first `seq` to return" }),
-                types: z.string().optional().meta({ description: "Only these event types, comma-separated (`environment.egress`)" }),
-                since: z.string().optional().meta({ description: "Only events recorded at or after this ISO time" }),
-                until: z.string().optional().meta({ description: "Only events recorded before this ISO time" }),
-            }),
-        },
-        responses: { 200: json(ListEnvironmentEventsResponse, "The events") },
-    }, async (c) => {
-        const from = c.req.query("from");
-        if (from !== undefined && !/^\d+$/.test(from))
-            fail(400, "from must be a seq");
-        const types = c.req.query("types")?.split(",").map((type) => type.trim()).filter(Boolean);
-        const unknown = types?.find((type) => !ENVIRONMENT_EVENT_TYPES.includes(type));
-        if (unknown !== undefined)
-            fail(400, `types: ${unknown} is not an Environment event type`);
-        const time = (name) => {
-            const value = c.req.query(name);
-            if (value === undefined)
-                return undefined;
-            const at = Date.parse(value);
-            if (!Number.isFinite(at))
-                fail(400, `${name} must be an ISO time`);
-            return new Date(at).toISOString();
-        };
-        const since = time("since");
-        const until = time("until");
-        return jsonResponse(200, await environmentEventsOf(c.env.tenant, idOf(c.req.param("environmentId")), c.get("scope"), {
-            ...(from === undefined ? {} : { fromSeq: Number(from) }),
-            ...(types === undefined || types.length === 0 ? {} : { types }),
-            ...(since === undefined ? {} : { since }),
-            ...(until === undefined ? {} : { until }),
-        }));
-    });
-    tenantRoute(api, WRITE, {
-        method: "delete",
-        path: "/v1/environments/{environmentId}",
-        tags: ["Environments"],
-        summary: "Delete an Environment",
-        description: "Deletes the Environment, its vault with every secret, and its files. Sessions that name it keep its id; their next turn is refused (`environment_unavailable`) until an Environment with this id exists again.",
-        request: { params: environmentId },
-        responses: {
-            200: json(DeleteEnvironmentResponse, "Deleted, or there was none"),
-            409: { description: "A session that names it has a turn running (`environment_busy`)" },
-        },
-    }, async (c) => jsonResponse(200, await deleteEnvironment(c.env.tenant, idOf(c.req.param("environmentId")), c.get("scope"))));
-    for (const [action, summary, description, run] of [
-        [
-            "stop",
-            "Stop a pod Environment",
-            "Suspends the pod: its volume is kept, and the next turn of a session that names it starts it again. Refused during a turn (`environment_busy`).",
-            stopEnvironment,
-        ],
-        [
-            "reset",
-            "Reset a pod Environment",
-            "A new pod on a new, empty volume with the recipe applied; the old pod and volume are deleted. The way out of `environment_lost`. Refused during a turn (`environment_busy`).",
-            resetEnvironment,
-        ],
-    ])
-        tenantRoute(api, WRITE, {
-            method: "post",
-            path: `/v1/environments/{environmentId}/${action}`,
-            tags: ["Environments"],
-            summary,
-            description,
-            request: { params: environmentId },
-            responses: {
-                200: json(EnvironmentView, "The Environment"),
-                400: { description: "The Environment is not of kind pod" },
-                409: {
-                    description: "A turn holds it (`environment_busy`), or no sandbox pods (`environment_unavailable`)",
-                },
-            },
-        }, async (c) => jsonResponse(200, await run(c.env.tenant, idOf(c.req.param("environmentId")), c.get("scope"))));
-    tenantRoute(api, WRITE, {
-        method: "post",
-        path: "/v1/environments/{environmentId}/snapshot",
-        tags: ["Environments"],
-        summary: "Snapshot an Environment's disk",
-        description: "Between turns, a new version of the Environment's disk (`/workspace`, and a pod's `/harness` but the engine's own files): files with their modes and modification times, links and empty directories, as a version of the folder artifact the Environment owns. Unchanged files are stored once; an unchanged disk makes no version (`unchanged`). A stopped pod is started first. Refused during a turn or another copy (`environment_busy`).",
-        request: { params: environmentId },
-        responses: {
-            201: json(EnvironmentSnapshot, "The version"),
-            400: { description: "The Environment is of kind none" },
-            409: { description: "A turn or another copy holds the disk (`environment_busy`), or the pod could not start (`environment_unavailable`)" },
-            413: { description: "Past the entries, bytes or Tenant total a version may hold (`limit_exceeded`)" },
-        },
-    }, async (c) => jsonResponse(201, await snapshotEnvironment(c.env.tenant, idOf(c.req.param("environmentId")), c.get("scope"))));
-    tenantRoute(api, WRITE, {
-        method: "post",
-        path: "/v1/environments/{environmentId}/restore",
-        tags: ["Environments"],
-        summary: "Restore a version of an Environment's disk",
-        description: "Puts disk version `version` (or `latest`) back. A virtual Environment's workspace is rewritten at once (`done`); a pod gets a new volume seeded from the version before any turn (`pending`, with `disk.operation` in the view until it ends). The Environment keeps its id, vault and sessions. Refused during a turn or another copy (`environment_busy`).",
-        request: {
-            params: environmentId,
-            body: { required: true, content: { "application/json": { schema: RestoreEnvironmentRequest } } },
-        },
-        responses: {
-            200: json(EnvironmentRestore, "Restored, or being restored"),
-            404: { description: "No such Environment, or no such version" },
-            409: { description: "A turn or another copy holds the disk (`environment_busy`)" },
-        },
-    }, async (c) => {
-        const body = RestoreEnvironmentRequestSchema.parse(await readJson(c.req.raw));
-        return jsonResponse(200, await restoreEnvironment(c.env.tenant, idOf(c.req.param("environmentId")), c.get("scope"), body.version));
-    });
-    tenantRoute(api, WRITE, {
-        method: "post",
-        path: "/v1/environments/{environmentId}/fork",
-        tags: ["Environments"],
-        summary: "Fork an Environment",
-        description: "How an Environment gets a new manifest version (Q15): a new Environment `id`, made from `manifest` (default the source's manifest at its latest version), its disk started from a version of this one's (`disk`: `latest`, the default, takes a snapshot first; a version number; or `empty`) and its secrets copied inside the Runtime (`secrets`: `copy`, the default, copies those the new manifest declares; `none`). On a fork onto other setup the new manifest's setup runs on the copied disk before its first turn. This Environment keeps what it runs, its disk and its sessions. `dryRun` answers the plan and makes nothing.",
-        request: {
-            params: environmentId,
-            body: { required: true, content: { "application/json": { schema: ForkEnvironmentRequest } } },
-        },
-        responses: {
-            200: json(ForkEnvironmentResponse, "The plan (`dryRun`)"),
-            201: json(ForkEnvironmentResponse, "The new Environment, and the plan it ran"),
-            400: { description: "The source was made from inline fields and no manifest is named, or the manifest does not resolve" },
-            404: { description: "No such Environment, manifest version (`manifest_not_found`) or disk version" },
-            409: { description: "The id exists, or a turn or another copy holds the source's disk (`environment_busy`)" },
-        },
-    }, async (c) => {
-        const body = ForkEnvironmentRequestSchema.parse(await readJson(c.req.raw));
-        const answer = await forkEnvironment(c.env.tenant, idOf(c.req.param("environmentId")), body, c.get("scope"));
-        return jsonResponse("dryRun" in answer ? 200 : 201, answer);
-    });
-    tenantRoute(api, READ, {
-        method: "get",
-        path: "/v1/environments/{environmentId}/versions",
-        tags: ["Environments"],
-        summary: "List an Environment's disk versions",
-        description: "Newest first. Read a version's tree, files, diff and zip through `/v1/artifacts/{artifactId}/versions/{version}/…`.",
-        request: { params: environmentId },
-        responses: { 200: json(EnvironmentVersions, "The versions") },
-    }, async (c) => jsonResponse(200, await environmentVersions(c.env.tenant, idOf(c.req.param("environmentId")), c.get("scope"))));
-    tenantRoute(api, WRITE, {
-        method: "delete",
-        path: "/v1/environments/{environmentId}/versions/{version}",
-        tags: ["Environments"],
-        summary: "Delete an Environment's disk version",
-        description: "Deletes the version, and the stored files no other version names. Refused while a seed reads it.",
-        request: { params: environmentId.extend({ version: z.string() }) },
-        responses: {
-            200: json(z.object({ environmentId: z.string(), version: z.number(), deleted: z.boolean() }), "Deleted, or there was none"),
-            409: { description: "A new volume is being seeded from it (`environment_busy`)" },
-        },
-    }, async (c) => {
-        const version = c.req.param("version") ?? "";
-        if (!/^[1-9]\d{0,8}$/.test(version))
-            fail(400, "version must be a version number");
-        return jsonResponse(200, await deleteEnvironmentVersion(c.env.tenant, idOf(c.req.param("environmentId")), c.get("scope"), Number(version)));
-    });
-    tenantRoute(api, READ, {
-        method: "get",
-        path: "/v1/environments/{environmentId}/secrets",
-        tags: ["Environments"],
-        summary: "List an Environment's secrets",
-        description: "Each secret's name, type and binding (its URL, or its hosts and header). Never a value.",
-        request: { params: environmentId },
-        responses: { 200: json(ListEnvironmentSecretsResponse, "The secrets") },
-    }, async (c) => {
-        const id = idOf(c.req.param("environmentId"));
-        assertReaches(c.get("scope"), id);
-        return jsonResponse(200, { secrets: await c.env.tenant.vault.listEnvironmentSecrets(id) });
-    });
-    tenantRoute(api, READ, {
-        method: "get",
-        path: "/v1/environments/{environmentId}/secrets/{name}",
-        tags: ["Environments"],
-        summary: "Get an Environment's secret",
-        description: "Its name, type and binding. Never its value.",
-        request: { params: secretPath },
-        responses: { 200: json(EnvironmentSecretView, "The secret") },
-    }, async (c) => {
-        const id = idOf(c.req.param("environmentId"));
-        assertReaches(c.get("scope"), id);
-        return jsonResponse(200, await c.env.tenant.vault.getEnvironmentSecret(id, c.req.param("name") ?? ""));
-    });
-    tenantRoute(api, WRITE, {
-        method: "put",
-        path: "/v1/environments/{environmentId}/secrets/{name}",
-        tags: ["Environments"],
-        summary: "Write an Environment's secret",
-        description: "Creates or replaces one credential of the Environment's vault: an `environment_secret` (the variable `name` reads the sentinel `nylorun-managed` in the sandbox, and egress-gate sets the value as a header on requests to `allowedHosts`), an `environment_variable` (a plain variable), or a `bearer` token or `headers` map for the MCP servers and HTTP tools at `url`. The same name and type re-seals the value and binding; another type replaces it. A rotated value is used from the next request. A second credential for a host or a URL is `409 credential_conflict`. When what the Environment runs declares secret slots (protocol 14, D64), send only the value (`{ value }`, or `{ headers }` for a `headers` slot): the type and binding come from the slot, and a name it does not declare is `409 secret_not_in_manifest`.",
-        request: {
-            params: secretPath,
-            body: {
-                required: true,
-                content: { "application/json": { schema: z.union([PutEnvironmentSecretRequest, PutEnvironmentSecretValueRequest]) } },
-            },
-        },
-        responses: {
-            200: json(EnvironmentSecretView, "The secret, without its value"),
-            409: { description: "Another credential is bound to one of its hosts or to its URL (`credential_conflict`)" },
-        },
-    }, async (c) => {
-        const id = idOf(c.req.param("environmentId"));
-        const scope = c.get("scope");
-        assertReaches(scope, id);
-        const name = c.req.param("name") ?? "";
-        const body = await secretRequestFor(c.env.tenant, id, name, await readJson(c.req.raw));
-        return jsonResponse(200, await c.env.tenant.keys.putEnvironmentSecret(id, name, body, actorOf(scope)));
-    });
-    tenantRoute(api, WRITE, {
-        method: "delete",
-        path: "/v1/environments/{environmentId}/secrets/{name}",
-        tags: ["Environments"],
-        summary: "Delete an Environment's secret",
-        description: "The next request that would have used it gets none.",
-        request: { params: secretPath },
-        responses: { 200: json(DeletedResponse, "Deleted") },
-    }, async (c) => {
-        const id = idOf(c.req.param("environmentId"));
-        const scope = c.get("scope");
-        assertReaches(scope, id);
-        return jsonResponse(200, await c.env.tenant.vault.deleteEnvironmentSecret(id, c.req.param("name") ?? "", actorOf(scope)));
-    });
-}

package/dist/artifacts/export.d.ts

@@ -1,8 +0,0 @@
-import type { TenantContext } from "../tenant/context.js";
-/** The directory every sandbox's outputs are exported from. */
-export declare const OUTPUTS_DIR = "/workspace/outputs";
-/**
- * Exports the outputs of turn `turnId` of session `sessionId`, if it completed and its sandbox
- * has any. Never throws.
- */
-export declare function exportOutputs(ctx: TenantContext, sessionId: string, turnId: string | null, signal: AbortSignal): Promise<void>;

package/dist/artifacts/export.js

@@ -1,204 +0,0 @@
-/**
- * The turn-end export (F8.2): when an agent's turn completes, core reads `/workspace/outputs` of
- * the session's sandbox through the `WorkspaceReader` seam and keeps it as a version of the
- * session's folder artifact `outputs` (the first export creates it; later turns add versions,
- * and a turn whose outputs did not change adds none).
- *
- * - **After the turn.** The advance calls `exportOutputs` once `settle` has committed the turn,
- *   outside its transaction and while it still holds the session's lease, so the next turn
- *   cannot change the workspace under it. Nothing here fails the turn: a sandbox or store
- *   failure is logged and recorded as `artifact.export.failed`.
- * - **Claimed.** The listing and the bytes are what the holder of the workspace supplied: the
- *   version's source is `export` and its event says `claimed: true`.
- * - **Bounded.** At most `EXPORT_MAX_FILES` files and `EXPORT_MAX_BYTES` bytes per export, each
- *   file within the Tenant's per-file limit, and the new bytes within its total; past any of
- *   them nothing is stored and `artifact.export.skipped` says why.
- * - **Deduplicated.** Each file is stored content-addressed (`folders.ts`); a file the store
- *   already holds is not stored again.
- *
- * No sandbox, a sandbox never created, or an empty or missing `/workspace/outputs` exports
- * nothing and records nothing. The package's declared outputs are left for later: the manifest
- * has no `outputs` field yet.
- */
-import { posix } from "node:path";
-import { EXPORT_MAX_BYTES, EXPORT_MAX_FILES, OUTPUTS_ARTIFACT_NAME, } from "@nylorun/core/contracts";
-import { SANDBOX_WORKSPACE } from "@nylorun/core/define";
-import { isWorkflowManifest } from "../core/flow-host.js";
-import { sandboxWorkspaceOf } from "../sandbox/share.js";
-import { SandboxFileTooLargeError } from "../sandbox/types.js";
-import { readArtifactLimits } from "./config.js";
-import { collectContent, commitFolderVersion, contentEpoch, contentKey, encodeManifest, FolderCommitRefused, sha256Hex, } from "./folders.js";
-import { contentTypeFor } from "./media-types.js";
-/** The directory every sandbox's outputs are exported from. */
-export const OUTPUTS_DIR = `${SANDBOX_WORKSPACE}/outputs`;
-/** Stops the export with `artifact.export.skipped`. */
-class Skip extends Error {
-    reason;
-    limit;
-    path;
-    constructor(reason, message, limit, path) {
-        super(message);
-        this.reason = reason;
-        this.limit = limit;
-        this.path = path;
-    }
-}
-/**
- * Exports the outputs of turn `turnId` of session `sessionId`, if it completed and its sandbox
- * has any. Never throws.
- */
-export async function exportOutputs(ctx, sessionId, turnId, signal) {
-    try {
-        await runExport(ctx, sessionId, turnId, signal);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (signal.aborted) {
-            ctx.config.logger.info("outputs export stopped", { sessionId, message });
-            return;
-        }
-        const skip = error instanceof Skip
-            ? error
-            : error instanceof FolderCommitRefused && error.reason === "tenant_total"
-                ? new Skip("tenant_total", error.message, error.limit)
-                : undefined;
-        if (!skip)
-            ctx.config.logger.warn("outputs export failed", { sessionId, message });
-        try {
-            await ctx.store.tx(async (t) => {
-                if (skip)
-                    await t.event(sessionId, turnId, "artifact.export.skipped", {
-                        name: OUTPUTS_ARTIFACT_NAME,
-                        reason: skip.reason,
-                        message: skip.message,
-                        ...(skip.limit === undefined ? {} : { limit: skip.limit }),
-                        ...(skip.path === undefined ? {} : { path: skip.path }),
-                    });
-                else
-                    await t.event(sessionId, turnId, "artifact.export.failed", {
-                        name: OUTPUTS_ARTIFACT_NAME,
-                        message,
-                    });
-            });
-        }
-        catch {
-            /* the session is gone (reset) or the store closed */
-        }
-    }
-}
-async function runExport(ctx, sessionId, turnId, signal) {
-    const found = await ctx.store.tx(async (t) => {
-        const s = await t.get("sessions", sessionId);
-        // Only a turn that completed, and only an agent's (a flow agent's sandbox is its agents').
-        if (!s || s.status !== "completed" || s.lastTurnId !== turnId || isWorkflowManifest(s.manifest))
-            return undefined;
-        const workspace = sandboxWorkspaceOf(s);
-        const prior = (await t.listArtifacts({ sessionId })).find((row) => row.kind === "folder" && row.name === OUTPUTS_ARTIFACT_NAME);
-        const latest = prior ? await t.artifactVersion(prior.id, prior.latestVersion) : undefined;
-        return {
-            session: {
-                sessionId,
-                turnId,
-                ownerId: workspace.ownerId,
-                ...(workspace.environmentId === undefined ? {} : { environmentId: workspace.environmentId }),
-                manifest: s.manifest,
-            },
-            limits: await readArtifactLimits(t),
-            priorId: prior?.id,
-            latestSha: latest?.sha256,
-            epoch: await contentEpoch(t),
-        };
-    });
-    if (!found)
-        return;
-    const { session, limits } = found;
-    const listing = await ctx.workspaces.list(session, OUTPUTS_DIR, {
-        maxEntries: EXPORT_MAX_FILES,
-        signal,
-    });
-    if (!listing || listing.entries.length === 0)
-        return;
-    if (listing.truncated)
-        throw new Skip("too_many_files", `${OUTPUTS_DIR} holds more than ${EXPORT_MAX_FILES} files`, EXPORT_MAX_FILES);
-    const large = listing.entries.find((entry) => entry.size > limits.fileBytes);
-    if (large)
-        throw tooLargeFile(large.path, large.size, limits.fileBytes);
-    const maxBytes = Math.min(EXPORT_MAX_BYTES, limits.totalBytes);
-    const listed = listing.entries.reduce((sum, entry) => sum + entry.size, 0);
-    if (listed > maxBytes)
-        throw tooLarge(listed, maxBytes);
-    // The files this export stored: removed again if it commits nothing, unless another version
-    // names them by then.
-    const put = [];
-    try {
-        await storeAndCommit(ctx, found, listing.entries, maxBytes, put, signal);
-    }
-    catch (error) {
-        if (put.length > 0)
-            await ctx.store
-                .tx(async (t) => {
-                await t.lockArtifactQuota();
-                await collectContent(ctx.blobs, t, put);
-            })
-                .catch(() => undefined);
-        throw error;
-    }
-}
-async function storeAndCommit(ctx, found, listed, maxBytes, put, signal) {
-    const { session, limits } = found;
-    const { sessionId, turnId } = session;
-    const entries = [];
-    const stored = new Set();
-    let read = 0;
-    for (const entry of listed) {
-        let bytes;
-        try {
-            bytes = await ctx.workspaces.readBytes(session, posix.join(OUTPUTS_DIR, entry.path), {
-                maxBytes: limits.fileBytes,
-                signal,
-            });
-        }
-        catch (error) {
-            if (error instanceof SandboxFileTooLargeError)
-                throw tooLargeFile(entry.path, error.size, limits.fileBytes);
-            throw error;
-        }
-        // Gone since the listing: the folder is what is there now.
-        if (bytes === undefined)
-            continue;
-        read += bytes.length;
-        if (read > maxBytes)
-            throw tooLarge(read, maxBytes);
-        const sha256 = sha256Hex(bytes);
-        const contentType = contentTypeFor(posix.basename(entry.path));
-        if (!stored.has(sha256)) {
-            stored.add(sha256);
-            const key = contentKey(sha256);
-            if (!(await ctx.blobs.head(key))) {
-                put.push(sha256);
-                await ctx.blobs.put(key, bytes, { contentType, signal });
-            }
-        }
-        entries.push({ path: entry.path, size: bytes.length, sha256, contentType });
-    }
-    // Every file vanished, or nothing changed since the last export: no new version.
-    if (entries.length === 0)
-        return;
-    if (found.latestSha !== undefined && sha256Hex(encodeManifest(entries)) === found.latestSha)
-        return;
-    await commitFolderVersion(ctx, {
-        sessionId,
-        turnId,
-        ...(found.priorId === undefined ? {} : { artifactId: found.priorId }),
-        name: OUTPUTS_ARTIFACT_NAME,
-        entries,
-        epoch: found.epoch,
-        totalBytes: limits.totalBytes,
-    });
-}
-function tooLargeFile(path, size, limit) {
-    return new Skip("file_too_large", `${OUTPUTS_DIR}/${path} is ${size} bytes; a file may hold at most ${limit}`, limit, path);
-}
-function tooLarge(bytes, limit) {
-    return new Skip("too_large", `${OUTPUTS_DIR} holds ${bytes} bytes; an export stores at most ${limit}`, limit);
-}

package/dist/artifacts/media-types.d.ts

@@ -1,30 +0,0 @@
-/**
- * Media types of file artifacts: what an upload may declare, what a name's extension implies,
- * and which model input a file is (`modelInputOf`, protocol 12): text, an image, a PDF, an Office
- * document, audio or video. A model reads a file only when its inputs include that one.
- */
-import type { ModelInput } from "@nylorun/core/contracts";
-/** Images the model reads as images. */
-export declare const MODEL_IMAGE_TYPES: readonly string[];
-/** The largest image or text file a model call carries inline. */
-export declare const MODEL_FILE_MAX_BYTES: number;
-/** The type part of a `Content-Type` value, lowercased, without parameters. */
-export declare function essence(contentType: string): string;
-/** A declared `Content-Type` as stored, or undefined when it is not a media type. */
-export declare function normalizeContentType(value: string | undefined): string | undefined;
-/** The media type a file name implies, or `application/octet-stream`. */
-export declare function contentTypeFor(name: string): string;
-export declare function isModelImage(contentType: string): boolean;
-/** Files the model reads as text: `text/*`, JSON, XML, YAML and their `+json`/`+xml` kin. */
-export declare function isText(contentType: string): boolean;
-/** The usual extension of a media type, for a name the Runtime gives a file; undefined if none. */
-export declare function extensionFor(contentType: string): string | undefined;
-/** The model input a file of `contentType` is, or undefined for a type no model reads. */
-export declare function modelInputOf(contentType: string): ModelInput | undefined;
-/** An input, in a sentence: "PDFs", "Office documents"; "files of this type" for none. */
-export declare function inputLabel(input: ModelInput | undefined): string;
-/**
- * Why a model that reads `inputs` cannot read a file of `contentType`, or undefined when it can.
- * An image must also be PNG, JPEG, GIF or WebP.
- */
-export declare function unreadableReason(contentType: string, inputs: readonly ModelInput[]): string | undefined;