@nylorun/runtime 0.26.0-beta → 0.28.0-beta

package/dist/artifacts/folder-upload.js

@@ -0,0 +1,263 @@
+/**
+ * A folder version a harness writes over the artifact seam (`artifact.write` with
+ * `kind: "folder"`, protocol 15): our engine's outputs folder, or any harness's. The harness
+ * sends each file (`file`, then `chunk`s naming it by hash), and `commit` stores the version
+ * (`commitFolderVersion`) with its content epoch, quotas and dedupe.
+ *
+ * - **No existence oracle.** Core takes every byte of every file. A file whose content the store
+ *   already holds (or this upload took already) is hashed and its bytes dropped; any other is
+ *   streamed to a key of its own, and copied to its content-addressed key (`contentKey`) only
+ *   once its hash is checked. Answering "already stored" would let a session name content it
+ *   does not hold; writing to the content key before the check would let a false hash replace
+ *   another session's file.
+ * - **A hash that does not match** ends the upload: what it stored is collected, and the file's
+ *   request is `invalid`.
+ * - **Unchanged.** A version whose files are the folder's latest is not added: `commit` answers
+ *   that version, `unchanged`.
+ * - **Bounded.** At most `limits.folderEntries` files, each within the Tenant's per-file limit,
+ *   together within its totals' limits (`commit` checks the room after dedupe, and answers
+ *   `refused` past one).
+ */
+import { createHash, randomUUID } from "node:crypto";
+import { posix } from "node:path";
+import { ARTIFACT_PATH_MAX, contentTypeFor, limitExceededMessage, normalizeContentType, } from "@nylorun/core/contracts";
+import { HarnessApiError } from "@nylorun/core/harness-api";
+import { collectContent, commitFolderVersion, contentKey, encodeManifest, FolderCommitRefused, sha256Hex, } from "./folders.js";
+import { Pipe } from "./pipe.js";
+const invalid = (message) => new HarnessApiError("invalid", message);
+/** A folder file's path: relative, `/`-separated, without empty, `.` or `..` segments. */
+export function checkFolderPath(path) {
+    const segments = path.split("/");
+    if (path.length > ARTIFACT_PATH_MAX ||
+        path.startsWith("/") ||
+        /[\\\u0000-\u001f\u007f]/u.test(path) ||
+        segments.some((segment) => segment === "" || segment === "." || segment === ".."))
+        throw invalid(`${JSON.stringify(path)} is not a path in a folder: relative, /-separated, no . or .. segments`);
+}
+export class FolderUpload {
+    ctx;
+    target;
+    id = randomUUID();
+    /** The most bytes its files may hold together, and one file. */
+    maxBytes;
+    maxFileBytes;
+    maxEntries;
+    entries = [];
+    paths = new Set();
+    /** Content taken whole and checked in this upload. */
+    taken = new Set();
+    /** Content this upload stored at its content key: collected again if nothing commits. */
+    stored = [];
+    bytes = 0;
+    files = 0;
+    current;
+    ended = false;
+    constructor(ctx, target) {
+        this.ctx = ctx;
+        this.target = target;
+        this.maxBytes = Math.min(...target.quota.totals.map((total) => total.limitBytes));
+        this.maxFileBytes = target.quota.fileBytes;
+        this.maxEntries = target.limits.folderEntries;
+    }
+    /** Starts a file; its bytes come with it (`base64`) or in `chunk`s. Answers the bytes received. */
+    async file(params, signal) {
+        this.live();
+        if (this.current)
+            throw invalid(`${this.current.path} has ${this.current.received} of its ${this.current.size} bytes; send the rest first`);
+        checkFolderPath(params.path);
+        if (this.paths.has(params.path))
+            throw invalid(`The folder has ${params.path} already`);
+        if (this.entries.length >= this.maxEntries)
+            throw new HarnessApiError("limit_exceeded", limitExceededMessage("The folder", this.entries.length + 1, "folderEntries", this.maxEntries));
+        if (params.size > this.maxFileBytes)
+            throw new HarnessApiError("limit_exceeded", `${params.path} is ${params.size} bytes; a file may hold at most ${this.maxFileBytes} (limitBytes ${this.maxFileBytes})`);
+        if (this.bytes + params.size > this.maxBytes)
+            throw new HarnessApiError("limit_exceeded", `The folder would hold ${this.bytes + params.size} bytes; it may hold at most ${this.maxBytes} (limitBytes ${this.maxBytes})`);
+        const contentType = normalizeContentType(params.contentType) ?? contentTypeFor(posix.basename(params.path));
+        const known = this.taken.has(params.sha256) || (await this.ctx.blobs.head(contentKey(params.sha256))) !== undefined;
+        let sink;
+        if (!known) {
+            const pipe = new Pipe();
+            const key = `artifacts/uploads/${this.id}/${(this.files += 1)}`;
+            const done = this.ctx.blobs.put(key, pipe, { contentType, maxBytes: params.size, signal });
+            // A failed put fails the chunk waiting on it; no rejection is lost.
+            done.catch((error) => pipe.fail(error));
+            sink = { key, pipe, done };
+        }
+        this.paths.add(params.path);
+        this.bytes += params.size;
+        this.current = {
+            path: params.path,
+            size: params.size,
+            sha256: params.sha256,
+            contentType,
+            hash: createHash("sha256"),
+            received: 0,
+            ...(sink ? { sink } : {}),
+        };
+        if (params.base64 !== undefined && params.base64 !== "")
+            return this.take(0, params.base64);
+        if (params.size === 0)
+            await this.finish();
+        return this.current?.received ?? 0;
+    }
+    /** Bytes of the file in progress from `offset`. Answers the bytes received of it. */
+    async chunk(params) {
+        this.live();
+        const current = this.current;
+        if (!current || params.sha256 !== current.sha256) {
+            // A repeat of a file's last chunk whose answer was lost: that file is complete.
+            if (params.sha256 !== undefined && this.taken.has(params.sha256))
+                return 0;
+            throw invalid(`No file ${params.sha256 ?? "(unnamed)"} is in progress in this upload`);
+        }
+        return this.take(params.offset, params.base64);
+    }
+    /** Stores the version, unless it is the folder's latest; collects what it stored when not. */
+    async commit(signal) {
+        this.live();
+        if (this.current)
+            throw invalid(`${this.current.path} has ${this.current.received} of its ${this.current.size} bytes`);
+        if (this.entries.length === 0)
+            throw invalid("A folder version holds at least one file");
+        this.ended = true;
+        const { target } = this;
+        const latest = target.prior?.latest;
+        if (latest !== undefined && sha256Hex(encodeManifest(this.entries)) === latest.sha256)
+            return { kind: "written", row: target.prior.row, version: latest, created: false, unchanged: true };
+        try {
+            signal.throwIfAborted();
+            const { artifact, version } = await commitFolderVersion(this.ctx, {
+                sessionId: target.sessionId,
+                turnId: target.turnId,
+                ...(target.prior ? { artifactId: target.prior.row.id } : {}),
+                name: target.name,
+                entries: this.entries,
+                epoch: target.epoch,
+                quota: target.quota,
+                source: "engine",
+                writeKey: target.writeKey,
+            });
+            return { kind: "written", row: artifact, version, created: true };
+        }
+        catch (error) {
+            await this.collect();
+            if (error instanceof FolderCommitRefused) {
+                if ((error.reason === "tenant_total" || error.reason === "environment_total") && error.limit !== undefined)
+                    return { kind: "refused", reason: error.reason, message: error.message, limit: error.limit };
+                throw invalid(error.message);
+            }
+            throw error;
+        }
+    }
+    /** Ends the upload: nothing commits, and what it stored is collected. Never throws. */
+    async abort(reason) {
+        if (this.ended)
+            return;
+        this.ended = true;
+        await this.dropCurrent(reason);
+        await this.collect().catch(() => undefined);
+    }
+    live() {
+        if (this.ended)
+            throw invalid("The upload ended");
+    }
+    async take(offset, base64) {
+        const current = this.current;
+        const bytes = chunkOf(base64, this.target.limits);
+        // A repeat of the last chunk (its answer was lost) is acknowledged, not taken again.
+        if (current.last &&
+            offset === current.last.offset &&
+            bytes.byteLength === current.last.length &&
+            offset + bytes.byteLength === current.received)
+            return current.received;
+        if (offset !== current.received)
+            throw invalid(`The chunk starts at ${offset}; ${current.path} has ${current.received} bytes, so the next chunk starts there`);
+        if (current.received + bytes.byteLength > current.size)
+            throw invalid(`${current.path} is ${current.size} bytes; this chunk passes its end`);
+        current.received += bytes.byteLength;
+        current.last = { offset, length: bytes.byteLength };
+        current.hash.update(bytes);
+        if (current.sink) {
+            try {
+                await current.sink.pipe.push(bytes);
+            }
+            catch (error) {
+                await this.abort("the store refused the file");
+                throw error;
+            }
+        }
+        if (current.received === current.size)
+            await this.finish();
+        return current.received;
+    }
+    /** The file in progress is whole: check its hash, then keep its content once. */
+    async finish() {
+        const current = this.current;
+        this.current = undefined;
+        const { sink } = current;
+        try {
+            if (sink) {
+                sink.pipe.close();
+                await sink.done;
+            }
+            if (current.hash.digest("hex") !== current.sha256) {
+                await this.abort("a file's bytes did not match its hash");
+                throw invalid(`The bytes of ${current.path} do not match its sha256 ${current.sha256}`);
+            }
+            if (sink && !this.taken.has(current.sha256)) {
+                const key = contentKey(current.sha256);
+                if (!(await this.ctx.blobs.head(key))) {
+                    const got = await this.ctx.blobs.get(sink.key);
+                    if (!got)
+                        throw new Error(`The upload of ${current.path} is missing from the Object store`);
+                    this.stored.push(current.sha256);
+                    await this.ctx.blobs.put(key, got.body, { contentType: current.contentType });
+                }
+            }
+        }
+        catch (error) {
+            if (!this.ended)
+                await this.abort("a file could not be stored");
+            throw error;
+        }
+        finally {
+            if (sink)
+                await this.ctx.blobs.delete(sink.key).catch(() => undefined);
+        }
+        this.taken.add(current.sha256);
+        this.entries.push({
+            path: current.path,
+            size: current.size,
+            sha256: current.sha256,
+            contentType: current.contentType,
+        });
+    }
+    async dropCurrent(reason) {
+        const current = this.current;
+        this.current = undefined;
+        const sink = current?.sink;
+        if (!sink)
+            return;
+        sink.pipe.fail(invalid(`The upload ended: ${reason}`));
+        await sink.done.catch(() => undefined);
+        await this.ctx.blobs.delete(sink.key).catch(() => undefined);
+    }
+    /** Content this upload stored that no committed version names is removed again. */
+    async collect() {
+        if (this.stored.length === 0)
+            return;
+        const shas = this.stored.splice(0);
+        await this.ctx.store.tx(async (t) => {
+            await t.lockArtifactQuota();
+            await collectContent(this.ctx.blobs, t, shas);
+        });
+    }
+}
+/** One chunk's bytes, at most the run's `chunkBytes`. */
+function chunkOf(base64, limits) {
+    const bytes = Buffer.from(base64, "base64");
+    if (bytes.byteLength > limits.chunkBytes)
+        throw new HarnessApiError("limit_exceeded", limitExceededMessage("The chunk", bytes.byteLength, "chunkBytes", limits.chunkBytes));
+    return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}

package/dist/artifacts/folders.d.ts

@@ -1,7 +1,8 @@
-import type { ArtifactDiff, FolderEntry, FolderManifest } from "@nylorun/core/contracts";
+import type { ArtifactDiff, ArtifactSource, FolderEntry, FolderManifest } from "@nylorun/core/contracts";
 import type { BlobStore } from "../blob/index.js";
 import type { ArtifactRow, ArtifactVersionRow, Tx } from "../store/types.js";
 import { type TenantContext } from "../tenant/context.js";
+import { type ArtifactQuota } from "./quota.js";
 /** Where a folder file's bytes are: content-addressed by their SHA-256. */
 export declare function contentKey(sha256: string): string;
 export declare function sha256Hex(bytes: Uint8Array): string;
@@ -32,11 +33,11 @@ export declare function contentEpoch(t: Tx): Promise<number>;
  * named them are gone: the deletes happen before the transaction commits, under the lock.
  */
 export declare function collectContent(blobs: BlobStore, t: Tx, shas: readonly string[]): Promise<number>;
-/** The commit could not go ahead: a limit, or content removed while the export ran. */
+/** The commit could not go ahead: a limit, or content removed while the folder was written. */
 export declare class FolderCommitRefused extends Error {
-    readonly reason: "tenant_total" | "content_gone" | "artifact_gone";
+    readonly reason: "tenant_total" | "environment_total" | "content_gone" | "artifact_gone";
     readonly limit?: number | undefined;
-    constructor(message: string, reason: "tenant_total" | "content_gone" | "artifact_gone", limit?: number | undefined);
+    constructor(message: string, reason: "tenant_total" | "environment_total" | "content_gone" | "artifact_gone", limit?: number | undefined);
 }
 export interface FolderVersionInput {
     readonly sessionId: string;
@@ -48,14 +49,19 @@ export interface FolderVersionInput {
     readonly entries: readonly FolderEntry[];
     /** The content epoch read before the first `head` of those bytes. */
     readonly epoch: number;
-    /** The Tenant total in force. */
-    readonly totalBytes: number;
+    /** The totals the version counts towards (`./quota.ts`). */
+    readonly quota: ArtifactQuota;
+    /** Who wrote the files: a harness over the artifact seam (`engine`). */
+    readonly source: ArtifactSource;
+    /** The write's key in the session (`writeKeyOf`): a repeat of the write answers this version. */
+    readonly writeKey?: string;
 }
 /**
  * Commits a folder version whose files are already stored: its manifest to the Object store,
  * then, in one transaction under the session and quota locks, the version row, its content rows
- * and `artifact.created` or `artifact.version.created` (`claimed: true`, source `export`).
- * Throws `FolderCommitRefused` when the Tenant total would be passed or a file is gone.
+ * and `artifact.created` or `artifact.version.created` (`claimed: true`, with its source).
+ * Throws `FolderCommitRefused` when a total (the Tenant's, or the session's Environment's) would
+ * be passed or a file is gone.
  */
 export declare function commitFolderVersion(ctx: TenantContext, input: FolderVersionInput): Promise<{
     artifact: ArtifactRow;

package/dist/artifacts/folders.js

@@ -22,6 +22,7 @@ import { FOLDER_CONTENT_TYPE, FOLDER_MANIFEST_FORMAT, FolderManifestSchema, } fr
 import { newArtifactId } from "@nylorun/core/compatibility";
 import { lockedSession } from "../tenant/context.js";
 import { fail } from "../tenant/http.js";
+import { totalSubject } from "./quota.js";
 const CONTENT_EPOCH_SETTING = "artifacts.content_epoch";
 /** Where a folder file's bytes are: content-addressed by their SHA-256. */
 export function contentKey(sha256) {
@@ -111,7 +112,7 @@ export async function collectContent(blobs, t, shas) {
         await blobs.delete(contentKey(sha));
     return orphans.length;
 }
-/** The commit could not go ahead: a limit, or content removed while the export ran. */
+/** The commit could not go ahead: a limit, or content removed while the folder was written. */
 export class FolderCommitRefused extends Error {
     reason;
     limit;
@@ -125,8 +126,9 @@ export class FolderCommitRefused extends Error {
 /**
  * Commits a folder version whose files are already stored: its manifest to the Object store,
  * then, in one transaction under the session and quota locks, the version row, its content rows
- * and `artifact.created` or `artifact.version.created` (`claimed: true`, source `export`).
- * Throws `FolderCommitRefused` when the Tenant total would be passed or a file is gone.
+ * and `artifact.created` or `artifact.version.created` (`claimed: true`, with its source).
+ * Throws `FolderCommitRefused` when a total (the Tenant's, or the session's Environment's) would
+ * be passed or a file is gone.
  */
 export async function commitFolderVersion(ctx, input) {
     const entries = sortEntries(input.entries);
@@ -151,11 +153,16 @@ export async function commitFolderVersion(ctx, input) {
             if ((await contentEpoch(t)) !== input.epoch)
                 for (const sha of fresh)
                     if (!(await ctx.blobs.head(contentKey(sha))))
-                        throw new FolderCommitRefused("A file's bytes were removed while the export ran", "content_gone");
-            const added = fresh.reduce((sum, sha) => sum + files.get(sha), 0);
-            const total = await t.artifactBytes();
-            if (total + added > input.totalBytes)
-                throw new FolderCommitRefused(`The Tenant's artifacts may hold at most ${input.totalBytes} bytes; these outputs add ${added} to ${total}`, "tenant_total", input.totalBytes);
+                        throw new FolderCommitRefused("A file's bytes were removed while the folder was written", "content_gone");
+            for (const total of input.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)
+                    throw new FolderCommitRefused(`${totalSubject(total)} may hold at most ${total.limitBytes} bytes; this folder version adds ${added} to ${used}`, scope === undefined ? "tenant_total" : "environment_total", total.limitBytes);
+            }
             let row;
             const version = {
                 artifactId,
@@ -164,13 +171,14 @@ export async function commitFolderVersion(ctx, input) {
                 size,
                 sha256,
                 contentType: FOLDER_CONTENT_TYPE,
-                source: "export",
+                source: input.source,
                 createdAt,
+                writeKey: input.writeKey ?? null,
             };
             if (input.artifactId !== undefined) {
                 const prior = await t.artifact(input.artifactId, { lock: true });
                 if (!prior || prior.kind !== "folder" || prior.sessionId !== input.sessionId)
-                    throw new FolderCommitRefused("The folder was deleted while the export ran", "artifact_gone");
+                    throw new FolderCommitRefused("The folder was deleted while it was written", "artifact_gone");
                 version.version = prior.latestVersion + 1;
                 await t.insertArtifactVersion(version);
                 row = { ...prior, latestVersion: version.version, contentType: FOLDER_CONTENT_TYPE, updatedAt: createdAt };
@@ -199,7 +207,7 @@ export async function commitFolderVersion(ctx, input) {
                 version: version.version,
                 size,
                 sha256,
-                source: "export",
+                source: input.source,
                 fileCount: entries.length,
                 claimed: true,
             });

package/dist/artifacts/links.js

@@ -3,22 +3,23 @@
  * other credential, for UIs, `<img>` tags and sharing. The token in the path is an ES256 JWT
  * (`typ: nylorun-artifact+jwt`) signed with the Tenant's current signing key by the keys
  * service, like run tokens: `sub` is the artifact, `ver` the version, `aud`
- * `nylorun-artifact`, and it lives at most `ARTIFACT_LINK_MAX_TTL_SECONDS` (`TOKEN_TTL_MAX_SECONDS`,
+ * `nylorun-artifact`, and it lives at most `keys.tokenTtlMaxSeconds` (Host tuning,
  * so a key rotation never revokes a live link). A link opens nothing once its artifact
  * is deleted. A folder's link (F8.2) opens its zip, or with a `path` claim one of its files.
  */
 import { randomUUID } from "node:crypto";
 import { errors, jwtVerify } from "jose";
-import { ARTIFACT_LINK_DEFAULT_TTL_SECONDS, ARTIFACT_LINK_MAX_TTL_SECONDS, ARTIFACT_LINK_TOKEN_TYPE, tenantTokenIssuer, } from "@nylorun/core/contracts";
+import { ARTIFACT_LINK_DEFAULT_TTL_SECONDS, ARTIFACT_LINK_TOKEN_TYPE, tenantTokenIssuer, } from "@nylorun/core/contracts";
 import { isArtifactId } from "@nylorun/core/compatibility";
 import { failOpaque, HttpError } from "../tenant/http.js";
-import { CLOCK_TOLERANCE_SECONDS, tokenKeyId } from "../tenant/jwt.js";
+import { clockToleranceSeconds, tokenKeyId } from "../tenant/jwt.js";
+import { hostTuning } from "../tuning.js";
 /** The audience of every capability link. */
 export const ARTIFACT_LINK_AUDIENCE = "nylorun-artifact";
 /** Where a capability link is served: `GET /v1/artifact-links/<token>`. */
 export const ARTIFACT_LINK_PATH = "/v1/artifact-links";
 export async function mintArtifactLink(ctx, link) {
-    const ttl = Math.max(1, Math.min(Math.floor(link.expiresIn ?? ARTIFACT_LINK_DEFAULT_TTL_SECONDS), ARTIFACT_LINK_MAX_TTL_SECONDS));
+    const ttl = Math.max(1, Math.min(Math.floor(link.expiresIn ?? ARTIFACT_LINK_DEFAULT_TTL_SECONDS), hostTuning().keys.tokenTtlMaxSeconds));
     const iat = Math.floor(Date.now() / 1000);
     // Signed by the keys service (F4.2): this process never holds the private key.
     const { token } = await ctx.keys.sign({
@@ -60,7 +61,7 @@ export async function verifyArtifactLink(ctx, raw) {
             issuer: tenantTokenIssuer(ctx.config.tenantId),
             audience: ARTIFACT_LINK_AUDIENCE,
             typ: ARTIFACT_LINK_TOKEN_TYPE,
-            clockTolerance: CLOCK_TOLERANCE_SECONDS,
+            clockTolerance: clockToleranceSeconds(),
             requiredClaims: ["sub", "aud", "iat", "exp", "jti"],
         });
         claims = verified.payload;
@@ -78,7 +79,7 @@ export async function verifyArtifactLink(ctx, raw) {
         !Number.isInteger(ver) ||
         ver < 1 ||
         (path !== undefined && (typeof path !== "string" || path === "")) ||
-        exp - iat > ARTIFACT_LINK_MAX_TTL_SECONDS)
+        exp - iat > hostTuning().keys.tokenTtlMaxSeconds)
         return refused(ctx, "artifact_link_claims");
     return { artifactId: sub, version: ver, ...(typeof path === "string" ? { file: path } : {}) };
 }

package/dist/artifacts/parts.d.ts

@@ -2,10 +2,12 @@
  * Message `parts` (protocol 6): what a user message's text and file parts become for the
  * engine. A file part names an artifact the caller may read, of this session or Tenant-wide;
  * its version is pinned when the message is accepted (the latest when the part names none).
- * The engine gets an opaque media part whose `reference` is `{ artifactId, version }`: model-gate
- * resolves it to bytes (`./files.ts`), and the transcript and the record never hold them.
+ * The engine gets an opaque media part whose `reference` is `{ artifactId, version, name, size }`:
+ * the harness decides how the model sees it, the Model Gate resolves it to bytes (`./files.ts`),
+ * and the transcript and the record never hold them. Any file is accepted, whatever the model
+ * reads (protocol 15): its size was held to the artifact limits at upload.
  */
-import type { MessagePart, ModelInput } from "@nylorun/core/contracts";
+import type { MessagePart } from "@nylorun/core/contracts";
 import type { JsonObject, JsonValue } from "@nylorun/core/define";
 import type { Tx } from "../store/types.js";
 import { type ArtifactAccess } from "./service.js";
@@ -24,20 +26,13 @@ export interface FileReference {
     readonly version: number;
 }
 export declare function fileReferenceOf(value: JsonValue | undefined): FileReference | undefined;
-/** A file part the Tenant's model does not read (protocol 12, `attachment_unsupported`). */
-export interface RefusedPart {
-    readonly artifactId: string;
-    readonly name: string;
-    readonly mediaType: string;
-    readonly reason: string;
-}
 /**
  * The parts with each file pinned to a version: for the engine (`engine`) and for a workflow's
- * JSON input (`pinned`). Reads in the caller's transaction. With `inputs`, what the Tenant's model
- * reads, each file of a type it does not read is in `refused` (its type only: no size is checked).
+ * JSON input (`pinned`). Reads in the caller's transaction. A file part must name a file the
+ * caller may read, of this session or Tenant-wide, and a version that exists. A message carries at
+ * most the Tenant's Runtime limit `messageParts` of them.
  */
-export declare function resolveMessageParts(t: Tx, parts: readonly MessagePart[], sessionId: string, access: ArtifactAccess, inputs?: readonly ModelInput[]): Promise<{
+export declare function resolveMessageParts(t: Tx, parts: readonly MessagePart[], sessionId: string, access: ArtifactAccess): Promise<{
     engine: EnginePart[];
     pinned: MessagePart[];
-    refused: RefusedPart[];
 }>;

package/dist/artifacts/parts.js

@@ -1,5 +1,5 @@
 import { fail } from "../tenant/http.js";
-import { unreadableReason } from "./media-types.js";
+import { readRuntimeLimits } from "../tenant/runtime-limits.js";
 import { readableArtifact, versionOf } from "./service.js";
 export function fileReferenceOf(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
@@ -11,13 +11,18 @@ export function fileReferenceOf(value) {
 }
 /**
  * The parts with each file pinned to a version: for the engine (`engine`) and for a workflow's
- * JSON input (`pinned`). Reads in the caller's transaction. With `inputs`, what the Tenant's model
- * reads, each file of a type it does not read is in `refused` (its type only: no size is checked).
+ * JSON input (`pinned`). Reads in the caller's transaction. A file part must name a file the
+ * caller may read, of this session or Tenant-wide, and a version that exists. A message carries at
+ * most the Tenant's Runtime limit `messageParts` of them.
  */
-export async function resolveMessageParts(t, parts, sessionId, access, inputs) {
+export async function resolveMessageParts(t, parts, sessionId, access) {
+    const { messageParts } = await readRuntimeLimits(t);
+    if (parts.length > messageParts)
+        fail(400, `A message may carry at most ${messageParts} parts (the Runtime limit messageParts)`, {
+            code: "invalid_request",
+        });
     const engine = [];
     const pinned = [];
-    const refused = [];
     for (const part of parts) {
         if (part.type === "text") {
             engine.push({ type: "text", text: part.text });
@@ -30,9 +35,6 @@ export async function resolveMessageParts(t, parts, sessionId, access, inputs) {
         if (artifact.kind !== "file")
             fail(400, `Artifact ${artifact.id} is a folder; a file part names a file artifact`);
         const version = await versionOf(t, artifact, part.version);
-        const reason = inputs && unreadableReason(version.contentType, inputs);
-        if (reason)
-            refused.push({ artifactId: artifact.id, name: artifact.name, mediaType: version.contentType, reason });
         engine.push({
             type: "media",
             mediaType: version.contentType,
@@ -45,5 +47,5 @@ export async function resolveMessageParts(t, parts, sessionId, access, inputs) {
         });
         pinned.push({ type: "file", artifactId: artifact.id, version: version.version });
     }
-    return { engine, pinned, refused };
+    return { engine, pinned };
 }

package/dist/artifacts/pipe.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The body of an upload: chunks handed over one at a time. `push` resolves once the store took
+ * the chunk, so a harness's next chunk waits for the store (backpressure across frames, nothing
+ * held whole); `close` ends the body, `fail` ends it with an error on both sides.
+ */
+export declare class Pipe implements AsyncIterable<Uint8Array> {
+    private taker?;
+    private offered?;
+    private ended;
+    private error?;
+    push(bytes: Uint8Array): Promise<void>;
+    close(): void;
+    fail(error: unknown): void;
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+}

package/dist/artifacts/pipe.js

@@ -0,0 +1,71 @@
+/**
+ * An upload's body as it crosses the artifact seam (protocol 15): chunks handed over one at a
+ * time, so nothing is held whole.
+ */
+import { HarnessApiError } from "@nylorun/core/harness-api";
+/**
+ * The body of an upload: chunks handed over one at a time. `push` resolves once the store took
+ * the chunk, so a harness's next chunk waits for the store (backpressure across frames, nothing
+ * held whole); `close` ends the body, `fail` ends it with an error on both sides.
+ */
+export class Pipe {
+    taker;
+    offered;
+    ended = false;
+    error;
+    push(bytes) {
+        if (this.error)
+            return Promise.reject(this.error.value);
+        if (this.ended)
+            return Promise.reject(new HarnessApiError("invalid", "The upload is committing"));
+        if (this.taker) {
+            const taker = this.taker;
+            this.taker = undefined;
+            taker.resolve({ value: bytes, done: false });
+            return Promise.resolve();
+        }
+        return new Promise((taken, reject) => {
+            this.offered = { bytes, taken, reject };
+        });
+    }
+    close() {
+        this.ended = true;
+        if (this.taker && !this.offered) {
+            const taker = this.taker;
+            this.taker = undefined;
+            taker.resolve({ value: undefined, done: true });
+        }
+    }
+    fail(error) {
+        if (this.error)
+            return;
+        this.error = { value: error };
+        this.offered?.reject(error);
+        this.offered = undefined;
+        this.taker?.reject(error);
+        this.taker = undefined;
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.error)
+                    return Promise.reject(this.error.value);
+                if (this.offered) {
+                    const { bytes, taken } = this.offered;
+                    this.offered = undefined;
+                    taken();
+                    return Promise.resolve({ value: bytes, done: false });
+                }
+                if (this.ended)
+                    return Promise.resolve({ value: undefined, done: true });
+                return new Promise((resolve, reject) => {
+                    this.taker = { resolve, reject };
+                });
+            },
+            return: () => {
+                this.fail(new HarnessApiError("invalid", "The store stopped reading the upload"));
+                return Promise.resolve({ value: undefined, done: true });
+            },
+        };
+    }
+}

package/dist/artifacts/quota.d.ts

@@ -0,0 +1,36 @@
+/**
+ * What one artifact write must fit (`tenant/limits.ts`): the largest file, and each total its
+ * bytes count towards. The Tenant's total always applies; an artifact of an Environment (one of
+ * its sessions' artifacts, or one of its disk versions) also counts towards that Environment's
+ * total when its manifest sets `limits.artifacts.totalBytes`. Without one, the Environment's
+ * total is the Tenant's, which the Tenant's own check already enforces.
+ */
+import type { Tx } from "../store/types.js";
+/** One total a write counts towards: the Tenant's (no `environmentId`), or an Environment's. */
+export interface ArtifactTotal {
+    readonly environmentId?: string;
+    readonly limitBytes: number;
+}
+export interface ArtifactQuota {
+    /** The largest file the write may store. */
+    readonly fileBytes: number;
+    /** The Tenant's total first, then the Environment's when it sets one. */
+    readonly totals: readonly ArtifactTotal[];
+}
+/** A total, with the bytes it holds now. */
+export interface ArtifactUsage {
+    readonly total: ArtifactTotal;
+    readonly usedBytes: number;
+}
+/** The quota for an artifact of `environmentId`, or of the Tenant alone when undefined. */
+export declare function artifactQuota(t: Tx, environmentId: string | undefined): Promise<ArtifactQuota>;
+/** The bytes each of the quota's totals holds now. */
+export declare function artifactUsage(t: Tx, quota: ArtifactQuota): Promise<ArtifactUsage[]>;
+/** The total with the least room left, and that room (none left: zero or less). */
+export declare function tightest(usage: readonly ArtifactUsage[]): ArtifactUsage & {
+    readonly roomBytes: number;
+};
+/** Whose artifacts a total counts: `The Tenant's artifacts`, or `Agent <id>'s artifacts`. */
+export declare function totalSubject(total: ArtifactTotal): string;
+/** The Environment a session's artifacts belong to, if it names one. */
+export declare function environmentOfSession(t: Tx, sessionId: string | null): Promise<string | undefined>;