@nylorun/runtime 0.25.0-beta → 0.27.0-beta

package/dist/artifacts/disk.js

@@ -25,22 +25,27 @@ import { newArtifactId } from "@nylorun/core/compatibility";
 import { FOLDER_CONTENT_TYPE, FOLDER_MANIFEST_FORMAT_V2, } from "@nylorun/core/contracts";
 import { sandboxSpecOf } from "../sandbox/resolve.js";
 import { effectiveSandboxConfig, readSandboxConfig } from "../sandbox/tenant-config.js";
-import { assertReaches, diskHeld, liveEnvironment, newVolume, SEED_LEASE_MS, wakePod, } from "../tenant/environments.js";
-import { fail } from "../tenant/http.js";
-import { readArtifactLimits } from "./config.js";
+import { assertReaches, diskHeld, liveEnvironment, newVolume, wakePod, } from "../tenant/environments.js";
+import { fail, failRetryLater } from "../tenant/http.js";
+import { hostTuning } from "../tuning.js";
+import { artifactQuota, totalSubject } from "./quota.js";
+import { limitsInForce, readTenantLimits } from "../tenant/limits.js";
+import { readRuntimeLimits } from "../tenant/runtime-limits.js";
 import { collectContent, contentEpoch, contentKey, encodeManifest, readManifest, sha256Hex } from "./folders.js";
-import { contentTypeFor } from "./media-types.js";
-/** The most entries one version holds (R6 Q11). */
-export const DISK_MAX_ENTRIES = 200_000;
-/** The most bytes one version's files hold. */
-export const DISK_MAX_BYTES = 10 * 1024 ** 3;
-/** One range of a file moved at a time, well inside a Harness API frame after base64. */
-const RANGE_BYTES = 8 * 1024 * 1024;
-/** A lease lasts this long unless renewed; a copy renews it every `HEARTBEAT_MS`. */
-const LEASE_MS = 2 * 60_000;
-const HEARTBEAT_MS = 30_000;
-/** How long a snapshot waits for a pod's engine to connect. */
-const ENGINE_WAIT_MS = 60_000;
+import { contentTypeFor } from "@nylorun/core/contracts";
+async function copyLimits(ctx, environment) {
+    return ctx.store.tx(async (t) => {
+        const runtime = await readRuntimeLimits(t);
+        const disk = limitsInForce(await readTenantLimits(t), environment?.applied.limits).disk;
+        return {
+            versionEntries: disk.versionEntries,
+            versionBytes: disk.versionBytes,
+            chunkBytes: runtime.chunkBytes,
+            leaseMs: runtime.diskLeaseMs,
+            podWaitMs: runtime.diskPodWaitMs,
+        };
+    });
+}
 /** The name of an Environment's disk artifact. */
 export const DISK_ARTIFACT_NAME = "disk";
 /** What the disk operations of Environment `environment` act through: a ref and its spec. */
@@ -51,7 +56,6 @@ async function diskTarget(ctx, environment) {
         ref: {
             id: `disk:${environment.id}`,
             activeTurnId: null,
-            manifest: { manifestSchemaVersion: 7, id: "disk" },
             environmentId: environment.id,
             // Not through a host a restore or a lost volume retired: its connection outlives the commit.
             ...(environment.pod === undefined ? {} : { hostEpoch: environment.pod.hostEpoch }),
@@ -70,30 +74,30 @@ async function diskOp(ctx, target, op) {
  * Takes the disk lease of Environment `id` for `kind`: refused (`409 environment_busy`) while a
  * turn runs or another copy holds it; `400` for kind `none`, which has no disk.
  */
-async function lease(ctx, id, kind, version) {
+async function lease(ctx, id, kind, leaseMs, version) {
     return ctx.store.tx(async (t) => {
         const environment = (await liveEnvironment(t, id, { lock: true })) ?? fail(404, "Environment not found");
         if (environment.kind === "none")
             fail(400, `Environment ${id} is of kind none: it has no disk.`);
         const busy = (await t.sessionsOnEnvironment(id)).some((session) => session.activeTurnId);
         if (busy || diskHeld(environment))
-            fail(409, `Environment ${id} has a turn running or its disk is being copied. Try again shortly.`, {
-                code: "environment_busy",
-                details: { retryAfterSeconds: 5 },
-            }, { "retry-after": "5" });
+            failRetryLater(`Environment ${id} has a turn running or its disk is being copied. Try again shortly.`, "environment_busy");
         const now = new Date();
         const operation = {
             kind,
             ...(version === undefined ? {} : { version }),
             startedAt: now.toISOString(),
-            until: new Date(now.getTime() + LEASE_MS).toISOString(),
+            until: new Date(now.getTime() + leaseMs).toISOString(),
         };
         await t.updateEnvironment(id, { diskOp: operation }, now.toISOString());
         return { ...environment, diskOp: operation };
     });
 }
-/** Renews the lease every `HEARTBEAT_MS` until `stop()`, which ends it (and, with `seed`, the seed). */
-function heartbeat(ctx, id, ms = LEASE_MS) {
+/**
+ * Renews the lease for `ms` more every quarter of `limits.leaseMs` until `stop()`, which ends it
+ * (and, with `seed`, the seed).
+ */
+function heartbeat(ctx, id, limits, ms = limits.leaseMs) {
     const timer = setInterval(() => {
         void ctx.store
             .tx(async (t) => {
@@ -104,7 +108,7 @@ function heartbeat(ctx, id, ms = LEASE_MS) {
             await t.updateEnvironment(id, { diskOp: { ...environment.diskOp, until: new Date(now.getTime() + ms).toISOString() } }, now.toISOString());
         })
             .catch(() => undefined);
-    }, HEARTBEAT_MS);
+    }, limits.leaseMs / 4);
     timer.unref();
     return {
         async stop(options = {}) {
@@ -125,25 +129,22 @@ function heartbeat(ctx, id, ms = LEASE_MS) {
     };
 }
 /** Waits until the engine of pod Environment `id` is connected, starting the pod when it is stopped. */
-async function awaitEngine(ctx, id) {
+async function awaitEngine(ctx, id, waitMs) {
     await wakePod(ctx, id);
-    const deadline = Date.now() + ENGINE_WAIT_MS;
+    const deadline = Date.now() + waitMs;
     while (!ctx.harness.hosting(id)) {
         if (Date.now() > deadline)
-            fail(409, `Environment ${id}'s pod did not start within ${ENGINE_WAIT_MS / 1000} s.`, {
-                code: "environment_unavailable",
-                details: { retryAfterSeconds: 5 },
-            }, { "retry-after": "5" });
-        await new Promise((resolve) => setTimeout(resolve, 250));
+            failRetryLater(`Environment ${id}'s pod did not start within ${waitMs / 1000} s (the Runtime limit diskPodWaitMs).`, "environment_unavailable");
+        await new Promise((resolve) => setTimeout(resolve, hostTuning().pods.enginePollMs));
     }
 }
 /** A file's bytes and their hash, read in ranges. */
-async function readFile(ctx, target, path) {
+async function readFile(ctx, target, path, rangeBytes) {
     const hash = createHash("sha256");
     const chunks = [];
     let offset = 0;
     for (;;) {
-        const answer = await diskOp(ctx, target, { read: { path, offset, length: RANGE_BYTES } });
+        const answer = await diskOp(ctx, target, { read: { path, offset, length: rangeBytes } });
         if (answer.kind === "missing")
             return undefined;
         if (answer.kind !== "read")
@@ -163,25 +164,26 @@ async function readFile(ctx, target, path) {
 export async function snapshotEnvironment(ctx, id, scope) {
     assertReaches(scope, id);
     const started = Date.now();
-    const environment = await lease(ctx, id, "snapshot");
-    const beat = heartbeat(ctx, id);
+    const limits = await copyLimits(ctx, await ctx.store.tx((t) => liveEnvironment(t, id)));
+    const environment = await lease(ctx, id, "snapshot", limits.leaseMs);
+    const beat = heartbeat(ctx, id, limits);
     try {
         if (environment.kind === "pod")
-            await awaitEngine(ctx, id);
+            await awaitEngine(ctx, id, limits.podWaitMs);
         const target = await diskTarget(ctx, environment);
-        const listed = await diskOp(ctx, target, { list: { maxEntries: DISK_MAX_ENTRIES } });
+        const listed = await diskOp(ctx, target, { list: { maxEntries: limits.versionEntries } });
         if (listed.kind !== "listed")
             throw new Error("The disk was not listed");
         if (listed.truncated)
-            fail(413, `The disk holds more than ${DISK_MAX_ENTRIES} entries.`, {
+            fail(413, `The disk holds more than ${limits.versionEntries} entries (the limit diskVersionEntries).`, {
                 code: "limit_exceeded",
-                details: { limit: "files", max: DISK_MAX_ENTRIES },
+                details: { limit: "files", max: limits.versionEntries },
             });
         const bytes = listed.entries.reduce((sum, entry) => sum + (entry.type === "file" ? entry.size : 0), 0);
-        if (bytes > DISK_MAX_BYTES)
-            fail(413, `The disk holds ${bytes} bytes; a version holds at most ${DISK_MAX_BYTES}.`, {
+        if (bytes > limits.versionBytes)
+            fail(413, `The disk holds ${bytes} bytes; a version holds at most ${limits.versionBytes} (the limit diskVersionBytes).`, {
                 code: "limit_exceeded",
-                details: { limit: "bytes", max: DISK_MAX_BYTES },
+                details: { limit: "bytes", max: limits.versionBytes },
             });
         const epoch = await ctx.store.tx((t) => contentEpoch(t));
         const entries = [];
@@ -198,7 +200,7 @@ export async function snapshotEnvironment(ctx, id, scope) {
                 continue;
             }
             const base = { path: entry.path, mode: entry.mode, mtimeMs: entry.mtimeMs };
-            const read = await readFile(ctx, target, entry.path);
+            const read = await readFile(ctx, target, entry.path, limits.chunkBytes);
             if (!read)
                 continue; // removed while it was copied (a background process)
             const key = contentKey(read.sha256);
@@ -262,9 +264,9 @@ async function commitDiskVersion(ctx, id, entries, epoch) {
     const artifactId = prior?.id ?? newArtifactId();
     const key = `artifacts/${artifactId}/${randomUUID()}`;
     await ctx.blobs.put(key, manifest, { contentType: FOLDER_CONTENT_TYPE });
-    const totalBytes = (await ctx.store.tx((t) => readArtifactLimits(t))).totalBytes;
     return ctx.store.tx(async (t) => {
         (await liveEnvironment(t, id, { lock: true })) ?? fail(404, "Environment not found");
+        const quota = await artifactQuota(t, id);
         await t.lockArtifactQuota();
         const shas = [...files.keys()];
         const referenced = await t.referencedArtifactContent(shas);
@@ -273,13 +275,18 @@ async function commitDiskVersion(ctx, id, entries, epoch) {
             for (const sha of fresh)
                 if (!(await ctx.blobs.head(contentKey(sha))))
                     fail(409, "A file's bytes were removed while the snapshot ran; try again.", { code: "environment_busy" });
-        const added = fresh.reduce((sum, sha) => sum + files.get(sha), 0);
-        const total = await t.artifactBytes();
-        if (total + added > totalBytes)
-            fail(413, `The Tenant's artifacts may hold at most ${totalBytes} bytes; this version adds ${added} to ${total}.`, {
-                code: "limit_exceeded",
-                details: { limit: "tenant_total", max: totalBytes },
-            });
+        for (const total of quota.totals) {
+            // A file adds bytes to a total unless an artifact it counts already holds the file.
+            const scope = total.environmentId === undefined ? undefined : { environmentId: total.environmentId };
+            const held = scope === undefined ? referenced : await t.referencedArtifactContent(shas, scope);
+            const added = shas.filter((sha) => !held.has(sha)).reduce((sum, sha) => sum + files.get(sha), 0);
+            const used = await t.artifactBytes(scope);
+            if (used + added > total.limitBytes)
+                fail(413, `${totalSubject(total)} may hold at most ${total.limitBytes} bytes; this version adds ${added} to ${used}.`, {
+                    code: "limit_exceeded",
+                    details: { limit: scope === undefined ? "tenant_total" : "environment_total", max: total.limitBytes },
+                });
+        }
         const createdAt = new Date().toISOString();
         const current = await t.diskArtifact(id, { lock: true });
         const version = {
@@ -291,6 +298,7 @@ async function commitDiskVersion(ctx, id, entries, epoch) {
             contentType: FOLDER_CONTENT_TYPE,
             source: "snapshot",
             createdAt,
+            writeKey: null,
         };
         let artifact;
         if (current) {
@@ -320,7 +328,7 @@ async function commitDiskVersion(ctx, id, entries, epoch) {
  * Writes disk version `seed` into Environment `id`'s workspace: empties it (the engine's files
  * stay), then directories, files (large ones in ranges) and links. Its caller holds the lease.
  */
-async function writeVersion(ctx, environment, seed) {
+async function writeVersion(ctx, environment, seed, rangeBytes) {
     const version = await ctx.store.tx((t) => t.artifactVersion(seed.artifactId, seed.version));
     if (!version)
         throw new Error(`Disk version ${seed.version} of ${seed.artifactId} is gone`);
@@ -354,22 +362,22 @@ async function writeVersion(ctx, environment, seed) {
             ...(entry.mode === undefined ? {} : { mode: entry.mode }),
             ...(entry.mtimeMs === undefined ? {} : { mtimeMs: entry.mtimeMs }),
         };
-        if (content.length <= RANGE_BYTES) {
-            if (batchBytes + content.length > RANGE_BYTES)
+        if (content.length <= rangeBytes) {
+            if (batchBytes + content.length > rangeBytes)
                 await flush();
             batch.push({ path: entry.path, type: "file", bytes: content, ...meta });
             batchBytes += content.length;
             continue;
         }
         await flush();
-        for (let offset = 0; offset < content.length; offset += RANGE_BYTES) {
-            const last = offset + RANGE_BYTES >= content.length;
+        for (let offset = 0; offset < content.length; offset += rangeBytes) {
+            const last = offset + rangeBytes >= content.length;
             await diskOp(ctx, target, {
                 put: [
                     {
                         path: entry.path,
                         type: "file",
-                        bytes: content.subarray(offset, offset + RANGE_BYTES),
+                        bytes: content.subarray(offset, offset + rangeBytes),
                         ...(offset > 0 ? { append: true } : {}),
                         ...(last ? meta : {}),
                     },
@@ -408,18 +416,16 @@ export async function restoreEnvironment(ctx, id, scope, version) {
             const environment = (await liveEnvironment(t, id, { lock: true })) ?? fail(404, "Environment not found");
             const busy = (await t.sessionsOnEnvironment(id)).some((session) => session.activeTurnId);
             if (busy || diskHeld(environment) || environment.pod.retiring !== undefined)
-                fail(409, `Environment ${id} has a turn running, its disk is being copied or its last volume is still being deleted.`, {
-                    code: "environment_busy",
-                    details: { retryAfterSeconds: 5 },
-                }, { "retry-after": "5" });
+                failRetryLater(`Environment ${id} has a turn running, its disk is being copied or its last volume is still being deleted.`, "environment_busy");
             return newVolume(ctx, t, environment, { seed, reason: "restore" });
         });
         return { environmentId: id, restored: seed.version, status: "pending", volumeGeneration };
     }
-    const environment = await lease(ctx, id, "restore", seed.version);
-    const beat = heartbeat(ctx, id);
+    const limits = await copyLimits(ctx, found);
+    const environment = await lease(ctx, id, "restore", limits.leaseMs, seed.version);
+    const beat = heartbeat(ctx, id, limits);
     try {
-        await writeVersion(ctx, environment, seed);
+        await writeVersion(ctx, environment, seed, limits.chunkBytes);
     }
     finally {
         await beat.stop();
@@ -444,20 +450,21 @@ export async function runPendingSeed(ctx, id) {
         const seed = environment?.diskSeed;
         if (!environment || !seed || seed.written)
             return;
+        const limits = await copyLimits(ctx, environment);
         if (environment.kind === "pod") {
-            const deadline = Date.now() + ENGINE_WAIT_MS;
+            const deadline = Date.now() + limits.podWaitMs;
             // The engine on the new volume: the old one's connection may still be open.
             while (!ctx.harness.hosting(id, environment.pod?.hostEpoch)) {
                 if (Date.now() > deadline)
                     return;
-                await new Promise((resolve) => setTimeout(resolve, 250));
+                await new Promise((resolve) => setTimeout(resolve, hostTuning().pods.enginePollMs));
             }
         }
-        const beat = heartbeat(ctx, id, SEED_LEASE_MS);
+        const beat = heartbeat(ctx, id, limits, hostTuning().tenant.seedLeaseMs);
         let done = false;
         try {
             const started = Date.now();
-            const written = await writeVersion(ctx, environment, seed);
+            const written = await writeVersion(ctx, environment, seed, limits.chunkBytes);
             done = true;
             ctx.config.logger.info("disk_seed", { environmentId: id, version: seed.version, ...written, durationMs: Date.now() - started });
         }
@@ -538,10 +545,7 @@ export async function deleteEnvironmentVersion(ctx, id, scope, version) {
         if (!artifact)
             return undefined;
         if (environment.diskSeed?.artifactId === artifact.id && environment.diskSeed.version === version)
-            fail(409, `A new volume of Environment ${id} is being seeded from version ${version}.`, {
-                code: "environment_busy",
-                details: { retryAfterSeconds: 5 },
-            }, { "retry-after": "5" });
+            failRetryLater(`A new volume of Environment ${id} is being seeded from version ${version}.`, "environment_busy");
         await t.lockArtifactQuota();
         const content = await t.artifactContentShas({ artifactId: artifact.id });
         const key = await t.deleteArtifactVersion(artifact.id, version);

package/dist/artifacts/files.d.ts

@@ -8,7 +8,8 @@
  */
 import type { JsonValue } from "@nylorun/core/define";
 import type { BlobStore } from "../blob/index.js";
-import type { SessionStore } from "../store/types.js";
+import type { ArtifactRow, SessionStore } from "../store/types.js";
+import type { Session } from "../tenant/context.js";
 /** A file a prompt names, with its bytes. */
 export interface ResolvedFile {
     readonly name: string;
@@ -22,15 +23,23 @@ export declare class FileUnavailableError extends Error {
 }
 /** Resolves a media part's reference to the file's bytes, or throws `FileUnavailableError`. */
 export type FileResolver = (reference: JsonValue) => Promise<ResolvedFile>;
+/**
+ * What a session may read of the Tenant's artifacts (the read rule): its own, and the Tenant-wide
+ * ones its messages named (`Session.fileArtifacts`); never another session's, and never an
+ * Environment's disk versions, which belong to no session. The Model Gate and the artifact seam
+ * (`artifact.read`) both read by it.
+ */
+export declare function sessionMayRead(session: Pick<Session, "id" | "fileArtifacts"> | undefined, artifact: Pick<ArtifactRow, "id" | "sessionId" | "environmentId">): boolean;
 /**
  * Files from the Tenant's artifacts: `store` for the version's row, `blobs` for its bytes, for
- * the call of session `sessionId`. An artifact of another session is refused (a Tenant-wide one
- * is not), and without a session every file is: the check is never skipped.
+ * the call of session `sessionId`. It reads by the read rule (`sessionMayRead`): another
+ * session's artifact, or a Tenant-wide one the session never named, is refused, and without a
+ * session every file is: the check is never skipped. A file larger than the Tenant's Runtime
+ * limit `modelFileBytes`, read with the row, is refused too.
  */
 export declare function artifactFiles(options: {
     readonly store: SessionStore;
     readonly blobs: BlobStore;
     /** The session the call is for: the run token's, over HTTP. */
     readonly sessionId: string | undefined;
-    readonly maxBytes?: number;
 }): FileResolver;

package/dist/artifacts/files.js

@@ -1,4 +1,4 @@
-import { MODEL_FILE_MAX_BYTES } from "./media-types.js";
+import { readRuntimeLimits } from "../tenant/runtime-limits.js";
 import { fileReferenceOf } from "./parts.js";
 /** Why a file cannot go to the model: the message is the outcome's, so it names no secret. */
 export class FileUnavailableError extends Error {
@@ -7,13 +7,27 @@ export class FileUnavailableError extends Error {
         this.name = "FileUnavailableError";
     }
 }
+/**
+ * What a session may read of the Tenant's artifacts (the read rule): its own, and the Tenant-wide
+ * ones its messages named (`Session.fileArtifacts`); never another session's, and never an
+ * Environment's disk versions, which belong to no session. The Model Gate and the artifact seam
+ * (`artifact.read`) both read by it.
+ */
+export function sessionMayRead(session, artifact) {
+    if (!session)
+        return false;
+    if (artifact.sessionId !== null)
+        return artifact.sessionId === session.id;
+    return artifact.environmentId === null && session.fileArtifacts?.includes(artifact.id) === true;
+}
 /**
  * Files from the Tenant's artifacts: `store` for the version's row, `blobs` for its bytes, for
- * the call of session `sessionId`. An artifact of another session is refused (a Tenant-wide one
- * is not), and without a session every file is: the check is never skipped.
+ * the call of session `sessionId`. It reads by the read rule (`sessionMayRead`): another
+ * session's artifact, or a Tenant-wide one the session never named, is refused, and without a
+ * session every file is: the check is never skipped. A file larger than the Tenant's Runtime
+ * limit `modelFileBytes`, read with the row, is refused too.
  */
 export function artifactFiles(options) {
-    const maxBytes = options.maxBytes ?? MODEL_FILE_MAX_BYTES;
     return async (value) => {
         const reference = fileReferenceOf(value);
         if (!reference)
@@ -25,17 +39,21 @@ export function artifactFiles(options) {
             const artifact = await t.artifact(reference.artifactId);
             if (!artifact)
                 return undefined;
+            const session = artifact.sessionId === null
+                ? await t.get("sessions", sessionId)
+                : { id: sessionId };
+            if (!sessionMayRead(session, artifact))
+                return undefined;
             const version = await t.artifactVersion(artifact.id, reference.version);
-            return version ? { artifact, version } : undefined;
+            return version ? { artifact, version, maxBytes: (await readRuntimeLimits(t)).modelFileBytes } : undefined;
         });
-        if (!found ||
-            (found.artifact.sessionId !== null && found.artifact.sessionId !== sessionId))
+        if (!found)
             throw new FileUnavailableError(`Artifact ${reference.artifactId} version ${reference.version} is not available.`);
-        const { artifact, version } = found;
+        const { artifact, version, maxBytes } = found;
         if (artifact.kind !== "file")
             throw new FileUnavailableError(`${artifact.name} is a folder; a model reads files only.`);
         if (version.size > maxBytes)
-            throw new FileUnavailableError(`${artifact.name} is ${version.size} bytes; a model reads files of at most ${maxBytes} bytes.`);
+            throw new FileUnavailableError(`${artifact.name} is ${version.size} bytes; a model reads files of at most ${maxBytes} bytes (the Runtime limit modelFileBytes).`);
         const got = await options.blobs.get(version.blobKey);
         if (!got)
             throw new FileUnavailableError(`The bytes of ${artifact.name} are missing from the Object store.`);

package/dist/artifacts/folder-upload.d.ts

@@ -0,0 +1,75 @@
+import { type HarnessLimits } from "@nylorun/core/contracts";
+import { type ParamsOf } from "@nylorun/core/harness-api";
+import type { ArtifactRow, ArtifactVersionRow } from "../store/types.js";
+import type { TenantContext } from "../tenant/context.js";
+import type { ArtifactQuota } from "./quota.js";
+/** What a folder upload writes: the session's folder, and what its version must fit. */
+export interface FolderTarget {
+    readonly sessionId: string;
+    readonly turnId: string;
+    readonly name: string;
+    /** The folder this upload adds a version to; absent: a new folder. */
+    readonly prior?: {
+        readonly row: ArtifactRow;
+        readonly latest?: ArtifactVersionRow;
+    };
+    readonly quota: ArtifactQuota;
+    /** The content epoch read at `begin`, before any `head` of this upload. */
+    readonly epoch: number;
+    readonly writeKey: string;
+    readonly limits: HarnessLimits;
+}
+/** How a folder upload's `commit` ended. */
+export type FolderCommit = {
+    readonly kind: "written";
+    readonly row: ArtifactRow;
+    readonly version: ArtifactVersionRow;
+    readonly created: boolean;
+    readonly unchanged?: true;
+} | {
+    readonly kind: "refused";
+    readonly reason: "tenant_total" | "environment_total";
+    readonly message: string;
+    readonly limit: number;
+};
+/** A folder file's path: relative, `/`-separated, without empty, `.` or `..` segments. */
+export declare function checkFolderPath(path: string): void;
+export declare class FolderUpload {
+    private readonly ctx;
+    readonly target: FolderTarget;
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    /** The most bytes its files may hold together, and one file. */
+    readonly maxBytes: number;
+    readonly maxFileBytes: number;
+    readonly maxEntries: number;
+    private readonly entries;
+    private readonly paths;
+    /** Content taken whole and checked in this upload. */
+    private readonly taken;
+    /** Content this upload stored at its content key: collected again if nothing commits. */
+    private readonly stored;
+    private bytes;
+    private files;
+    private current?;
+    private ended;
+    constructor(ctx: TenantContext, target: FolderTarget);
+    /** Starts a file; its bytes come with it (`base64`) or in `chunk`s. Answers the bytes received. */
+    file(params: Extract<ParamsOf<"artifact.write">, {
+        op: "file";
+    }>, signal: AbortSignal): Promise<number>;
+    /** Bytes of the file in progress from `offset`. Answers the bytes received of it. */
+    chunk(params: Extract<ParamsOf<"artifact.write">, {
+        op: "chunk";
+    }>): Promise<number>;
+    /** Stores the version, unless it is the folder's latest; collects what it stored when not. */
+    commit(signal: AbortSignal): Promise<FolderCommit>;
+    /** Ends the upload: nothing commits, and what it stored is collected. Never throws. */
+    abort(reason: string): Promise<void>;
+    private live;
+    private take;
+    /** The file in progress is whole: check its hash, then keep its content once. */
+    private finish;
+    private dropCurrent;
+    /** Content this upload stored that no committed version names is removed again. */
+    private collect;
+}