@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/runtime/effects/scope.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Parent-id binding for `x-effects` / `x-wait`.
+ *
+ * A write that creates A (a table) and appends children (rows) has no `table_id` in the write
+ * path. Later effects — and `x-wait` — fill the child list with the id from the write response
+ * or from A's list delta.
+ */
+import type { EffectSpec } from "../../spec/extensions/effects.ts";
+import type { SpecModel } from "../../spec/graph/types.ts";
+/** Path parameter that names an instance of this entity (`table` → `table_id`). */
+export declare function identityPathParam(model: SpecModel, entityName: string): string;
+/**
+ * Bind the created A id so a later child list can `fillPath`. Prefers the write body, then the
+ * first id added to A's list (same adopt idea as a 402 plan-limit reuse).
+ */
+/** What shows a created record's id: the write's response body, and the ids its list gained. */
+export interface CreatedEvidence {
+    body: unknown;
+    added?: readonly string[];
+}
+export declare function bindCreatedScope(model: SpecModel, entityName: string, { body: writeBody, added: addedIds }: CreatedEvidence): Record<string, string>;
+/** The seeded instance an action acts on: its entity, identity field, records and scope. */
+export interface InstanceScopeInput {
+    model: SpecModel;
+    entityName: string;
+    identity: string;
+    records: readonly Record<string, unknown>[];
+    scope: Record<string, string>;
+}
+/**
+ * An action on an existing row (`POST /tables/{table_id}/columns`) is not a create.
+ * The entity scope only has parent ids. Bind the seeded row's id when the path still needs it.
+ */
+export declare function bindInstanceScope(input: InstanceScopeInput): Record<string, string>;
+/** Fill poll-path params the write scope does not have, from the write body. */
+export declare function bindMissingPathParams(pathParams: readonly string[], scope: Record<string, string>, writeBody: unknown): Record<string, string>;
+/** What shows the ids a write's create effects made: its response body, and the ids each entity's list gained. */
+export interface EffectsEvidence {
+    body: unknown;
+    deltas?: ReadonlyMap<string, readonly string[]>;
+}
+export declare function bindAfterCreateEffects(model: SpecModel, effects: readonly EffectSpec[], { body, deltas }: EffectsEvidence): Record<string, string>;
+export declare function mergeScope(base: Record<string, string>, extra: Record<string, string>): Record<string, string>;
+export declare function canFillPath(template: string, values: Record<string, string>): boolean;
+//# sourceMappingURL=scope.d.ts.map

package/dist/api/runtime/effects/scope.js

@@ -0,0 +1,87 @@
+/**
+ * Parent-id binding for `x-effects` / `x-wait`.
+ *
+ * A write that creates A (a table) and appends children (rows) has no `table_id` in the write
+ * path. Later effects — and `x-wait` — fill the child list with the id from the write response
+ * or from A's list delta.
+ */
+import { fillPath } from "../fill-path.js";
+import { createdIdKeys, findCreatedId, scalarId } from "./ids.js";
+/** Path parameter that names an instance of this entity (`table` → `table_id`). */
+export function identityPathParam(model, entityName) {
+    const conventional = `${entityName}_id`;
+    const entity = model.entities.get(entityName);
+    if (entity === undefined)
+        return conventional;
+    for (const opId of [entity.read, entity.delete, entity.update]) {
+        if (opId === undefined)
+            continue;
+        const last = model.byOperationId.get(opId)?.pathParams.at(-1);
+        if (last)
+            return last;
+    }
+    return conventional;
+}
+export function bindCreatedScope(model, entityName, { body: writeBody, added: addedIds = [] }) {
+    const identity = model.entities.get(entityName)?.identity ?? "id";
+    const param = identityPathParam(model, entityName);
+    const id = findCreatedId(writeBody, createdIdKeys(entityName, identity)) ?? addedIds[0];
+    if (id === undefined)
+        return {};
+    const bound = { [param]: id };
+    const conventional = `${entityName}_id`;
+    if (param !== conventional)
+        bound[conventional] = id;
+    return bound;
+}
+/**
+ * An action on an existing row (`POST /tables/{table_id}/columns`) is not a create.
+ * The entity scope only has parent ids. Bind the seeded row's id when the path still needs it.
+ */
+export function bindInstanceScope(input) {
+    const { identity, records, scope } = input;
+    const param = identityPathParam(input.model, input.entityName);
+    if (scope[param] !== undefined)
+        return { ...scope };
+    for (const record of records) {
+        const id = scalarId(record[identity]) ?? scalarId(record["id"]) ?? scalarId(record[param]);
+        if (id === undefined)
+            continue;
+        return { ...scope, [param]: id };
+    }
+    return { ...scope };
+}
+/** Fill poll-path params the write scope does not have, from the write body. */
+export function bindMissingPathParams(pathParams, scope, writeBody) {
+    const bound = {};
+    for (const param of pathParams) {
+        if (scope[param] !== undefined || bound[param] !== undefined)
+            continue;
+        const id = findCreatedId(writeBody, [param]);
+        if (id !== undefined)
+            bound[param] = id;
+    }
+    return bound;
+}
+export function bindAfterCreateEffects(model, effects, { body, deltas = new Map() }) {
+    const bound = {};
+    for (const effect of effects) {
+        if (effect.op !== "create")
+            continue;
+        Object.assign(bound, bindCreatedScope(model, effect.entity, { added: deltas.get(effect.entity) ?? [], body }));
+    }
+    return bound;
+}
+export function mergeScope(base, extra) {
+    return { ...base, ...extra };
+}
+export function canFillPath(template, values) {
+    try {
+        fillPath(template, values);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=scope.js.map

package/dist/api/runtime/evidence.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The exchanges behind a matrix pass. A check that passed proved a property; the report also
+ * names the call and the later exchange that shows it, so a reader can audit the claim without
+ * trusting the API tester. Bodies are read through the client, which may have moved older ones to disk.
+ */
+import type { SpecModel } from "../spec/graph/types.ts";
+import type { Client } from "../client/client.ts";
+import type { GradeLedger } from "./grades.ts";
+/** Where a search stands: the JSON path walked so far and how deep it is. */
+interface Position {
+    prefix: string;
+    depth: number;
+}
+/** A JSON path (`[*]` for arrays) to a string node equal to `value`, or null. */
+export declare function pathTo(body: unknown, value: string, at?: Position): string | null;
+/**
+ * Evidence for every operation a check graded without naming its exchanges: the call, and the
+ * first exchange anywhere in the run that holds a value the call put into the world. A write no later read
+ * shows keeps only its call, and the report calls that pass `contract`.
+ */
+export declare function proveFromTranscript(input: {
+    model: SpecModel;
+    client: Client;
+    grades: GradeLedger;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=evidence.d.ts.map

package/dist/api/runtime/evidence.js

@@ -0,0 +1,246 @@
+/**
+ * The exchanges behind a matrix pass. A check that passed proved a property; the report also
+ * names the call and the later exchange that shows it, so a reader can audit the claim without
+ * trusting the API tester. Bodies are read through the client, which may have moved older ones to disk.
+ */
+import { READS } from "../spec/methods.js";
+function ok(exchange) {
+    return exchange.status >= 200 && exchange.status < 300;
+}
+function pathOf(url) {
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        return url;
+    }
+}
+function walk(node, depth, harvest) {
+    if (depth > 4 || node === null || typeof node !== "object")
+        return;
+    for (const [key, value] of Object.entries(node)) {
+        if (typeof value === "string" && value.length >= 6) {
+            if (!harvest.idsOnly || key === "id" || key.endsWith("_id"))
+                harvest.into.push(value);
+        }
+        else
+            walk(value, depth + 1, harvest);
+    }
+}
+/** Distinctive values a call put into the world: ids it returned, then long strings it sent. */
+function tokensOf(exchange) {
+    const ids = [];
+    const sent = [];
+    walk(exchange.responseBody, 0, { idsOnly: true, into: ids });
+    walk(exchange.requestBody, 0, { idsOnly: false, into: sent });
+    return [...new Set([...ids, ...sent])];
+}
+/** A JSON path (`[*]` for arrays) to a string node equal to `value`, or null. */
+export function pathTo(body, value, at = { depth: 0, prefix: "$" }) {
+    const { depth, prefix } = at;
+    if (depth > 6 || body === null || typeof body !== "object")
+        return null;
+    if (Array.isArray(body)) {
+        for (const item of body) {
+            if (item === value)
+                return `${prefix}[*]`;
+            const hit = pathTo(item, value, { depth: depth + 1, prefix: `${prefix}[*]` });
+            if (hit !== null)
+                return hit;
+        }
+        return null;
+    }
+    for (const [key, item] of Object.entries(body)) {
+        if (item === value)
+            return `${prefix}.${key}`;
+        const hit = pathTo(item, value, { depth: depth + 1, prefix: `${prefix}.${key}` });
+        if (hit !== null)
+            return hit;
+    }
+    return null;
+}
+/** `ancestor` is `path` or a path above it, segment by segment. */
+function isAncestor(ancestor, path) {
+    return ancestor === path || path.startsWith(`${ancestor}/`);
+}
+function isRead(exchange) {
+    return READS.has(exchange.method.toUpperCase());
+}
+/** A successful read: what can show a value is (or no longer is) in the world. */
+function isOkRead(exchange) {
+    return isRead(exchange) && ok(exchange);
+}
+/** Every string `pathTo` can reach in `body`. */
+function stringsIn(body, into = new Set(), depth = 0) {
+    if (depth > 6 || body === null || typeof body !== "object")
+        return into;
+    for (const item of Array.isArray(body) ? body : Object.values(body)) {
+        if (typeof item === "string")
+            into.add(item);
+        else
+            stringsIn(item, into, depth + 1);
+    }
+    return into;
+}
+/**
+ * Where each value sits in the run, found once. Lanes run side by side, so how many exchanges part
+ * a call from the one that shows it depends on what ran beside it, not on what the call did: every
+ * search spans the whole run, and the index reads each body once rather than once per search.
+ */
+class RunIndex {
+    transcript;
+    client;
+    #written;
+    #shown;
+    constructor(client) {
+        this.client = client;
+        /* Teardown reads check that cleanup worked; they are not evidence for what a check graded. */
+        this.transcript = client.transcript.filter((exchange) => exchange.purpose !== "teardown" || !isRead(exchange));
+    }
+    /** Where the ok writes that put each value into the world sit, ascending. */
+    written() {
+        return (this.#written ??= this.#gather((exchange) => !isRead(exchange) && ok(exchange), tokensOf));
+    }
+    /** Where the ok reads that show each string sit, ascending. */
+    shown() {
+        return (this.#shown ??= this.#gather(isOkRead, (whole) => stringsIn(whole.responseBody)));
+    }
+    async #gather(take, values) {
+        const at = new Map();
+        for (const [index, exchange] of this.transcript.entries()) {
+            if (!take(exchange))
+                continue;
+            for (const value of values(await this.client.hydrate(exchange))) {
+                const positions = at.get(value);
+                if (positions === undefined)
+                    at.set(value, [index]);
+                else
+                    positions.push(index);
+            }
+        }
+        return at;
+    }
+}
+function removalOf(call, index, shown) {
+    const path = pathOf(call.url);
+    const cut = path.lastIndexOf("/");
+    const id = decodeURIComponent(path.slice(cut + 1));
+    return { call, collection: path.slice(0, Math.max(cut, 0)), holding: new Set(shown.get(id)), id, index, path };
+}
+function absent(removal, read) {
+    return { call: removal.call.seq, observation: { absent: true, path: "$", seq: read.seq, value: removal.id } };
+}
+/** A later read of the item that is gone, or of its collection that no longer lists it. */
+function shownByOwnRead(transcript, removal) {
+    for (let index = removal.index + 1; index < transcript.length; index += 1) {
+        const read = transcript[index];
+        if (!isRead(read))
+            continue;
+        if ((read.status === 404 || read.status === 410) && pathOf(read.url) === removal.path) {
+            return { call: removal.call.seq, observation: { seq: read.seq, status: read.status } };
+        }
+        if (ok(read) && removal.id !== "" && pathOf(read.url) === removal.collection && !removal.holding.has(index)) {
+            return absent(removal, read);
+        }
+    }
+    return undefined;
+}
+/** Whether an earlier read of `path` held the id. */
+function heldBefore(transcript, removal, path) {
+    for (const prior of removal.holding) {
+        if (prior < removal.index && pathOf(transcript[prior].url) === path)
+            return true;
+    }
+    return false;
+}
+/**
+ * A nested item with no read of its own (a column inside its table) shows through an ancestor:
+ * the same ancestor read held the id before the call and lacks it after.
+ */
+function shownByAncestor(transcript, removal) {
+    if (removal.id === "")
+        return undefined;
+    for (let index = removal.index + 1; index < transcript.length; index += 1) {
+        const read = transcript[index];
+        if (!isOkRead(read) || removal.holding.has(index))
+            continue;
+        const path = pathOf(read.url);
+        if (isAncestor(path, removal.collection) && heldBefore(transcript, removal, path))
+            return absent(removal, read);
+    }
+    return undefined;
+}
+async function deleteShown(run, call, index) {
+    const removal = removalOf(call, index, await run.shown());
+    return shownByOwnRead(run.transcript, removal) ?? shownByAncestor(run.transcript, removal);
+}
+/** The earliest position any of `values` sits at in `at` that `fits`, or undefined. */
+function earliest(at, values, fits) {
+    let first;
+    for (const value of values) {
+        const index = at.get(value)?.find(fits);
+        if (index !== undefined && (first === undefined || index < first))
+            first = index;
+    }
+    return first;
+}
+/** A read shows a value an earlier write put into the world: the earliest such write. */
+async function readShown(run, call, index) {
+    const held = stringsIn(call.responseBody);
+    const first = earliest(await run.written(), held, (at) => at < index);
+    if (first === undefined)
+        return undefined;
+    const tokens = tokensOf(await run.client.hydrate(run.transcript[first]));
+    const value = tokens.find((token) => held.has(token));
+    return { call: call.seq, observation: { path: pathTo(call.responseBody, value), seq: call.seq, value } };
+}
+/** A later read shows a value the write put into the world: the first such read. */
+async function writeShown(run, call, index) {
+    const values = tokensOf(call);
+    if (values.length === 0)
+        return undefined;
+    const first = earliest(await run.shown(), values, (at) => at > index);
+    if (first === undefined)
+        return undefined;
+    const read = run.transcript[first];
+    const body = (await run.client.hydrate(read)).responseBody;
+    const held = stringsIn(body);
+    const value = values.find((token) => held.has(token));
+    return { call: call.seq, observation: { path: pathTo(body, value), seq: read.seq, value } };
+}
+function shownFor(method) {
+    if (method === "DELETE")
+        return deleteShown;
+    return READS.has(method) ? readShown : writeShown;
+}
+async function infer(op, run) {
+    const calls = run.transcript.flatMap((exchange, index) => exchange.operationId === op.operationId && ok(exchange) ? [{ exchange, index }] : []);
+    const last = calls.at(-1);
+    if (last === undefined)
+        return undefined;
+    const shown = shownFor(op.method.toUpperCase());
+    for (const { exchange, index } of calls.toReversed()) {
+        const evidence = await shown(run, await run.client.hydrate(exchange), index);
+        if (evidence !== undefined)
+            return evidence;
+    }
+    return { call: last.exchange.seq };
+}
+/**
+ * Evidence for every operation a check graded without naming its exchanges: the call, and the
+ * first exchange anywhere in the run that holds a value the call put into the world. A write no later read
+ * shows keeps only its call, and the report calls that pass `contract`.
+ */
+export async function proveFromTranscript(input) {
+    const run = new RunIndex(input.client);
+    for (const op of input.model.operations) {
+        if (!input.grades.judged(op.operationId))
+            continue;
+        if (input.grades.evidence.get(op.operationId)?.observation !== undefined)
+            continue;
+        const evidence = await infer(op, run);
+        if (evidence !== undefined)
+            input.grades.prove(op.operationId, evidence);
+    }
+}
+//# sourceMappingURL=evidence.js.map

package/dist/api/runtime/exchange.d.ts

@@ -0,0 +1,141 @@
+import type { NetworkKind } from "../errors/network.ts";
+import type { RedirectHop } from "./cookies/redirect.ts";
+/** The wait a server asked for and the longest the API tester accepts, both in ms. */
+export interface RetryAfterExceeded {
+    waitMs: number;
+    limitMs: number;
+}
+export interface Exchange {
+    seq: number;
+    method: string;
+    url: string;
+    requestHeaders: Record<string, string>;
+    requestBody: unknown;
+    status: number;
+    responseHeaders: Record<string, string>;
+    responseBody: unknown;
+    durationMs: number;
+    /** Wall clock when the response finished, unix ms. */
+    at: number;
+    /** Reconstructed HTTP/1.1 request size: start line, headers, body. */
+    requestBytes: number;
+    /** Reconstructed HTTP/1.1 response size: start line, headers, body. */
+    responseBytes: number;
+    /**
+     * `x-request-id` / `request-id` / `x-correlation-id` / `correlation-id`.
+     * Response header wins; otherwise what the API tester sent. Empty when neither side passed one.
+     */
+    requestId: string;
+    /** Rate-limit category this request was paced against, when one matched. */
+    rateLimitCategory?: string;
+    /** Where that category came from — a `spec.*` finding only ever cites a `"tag"` rejection. */
+    rateLimitSource?: "tag" | "config" | "implicit";
+    /** Whether the bucket had a token without waiting — the API tester believes it was under its own pace. */
+    rateLimitHadRoom?: boolean;
+    /** Size and hash of a large request body as sent; what a stored reference names. */
+    requestDigest?: {
+        bytes: number;
+        sha256: string;
+    };
+    /** Size and hash of a large response body as received; what a stored reference names. */
+    responseDigest?: {
+        bytes: number;
+        sha256: string;
+    };
+    /** Named operation, when the caller passed one. */
+    operationId?: string;
+    /** `uploads.each` filename, when this request is one cell of that matrix. */
+    fixture?: string;
+    /** Set when `fetch` threw — there was no HTTP status. */
+    network?: {
+        kind: NetworkKind;
+        attempt: number;
+        message: string;
+    };
+    /**
+     * Intermediate 3xx hops when this request followed redirects with a cookie jar.
+     * The exchange itself is the original URL + the final status/headers/body.
+     */
+    redirects?: RedirectHop[];
+    /** Landing URL when a followed redirect chain ended somewhere other than `url`. */
+    finalUrl?: string;
+    /** Cookie jar after this hop (this response + followed hops). */
+    cookies?: Record<string, string>;
+    /** The documented path template this request resolved to, e.g. `/v1/tables/{table_id}`. */
+    template?: string;
+    /** The value each of the template's path parameters took in this request, URI-decoded. */
+    pathParams?: Record<string, string>;
+    /** The principal whose credential the request carried, when one did. */
+    principal?: string;
+    /** The security schemes whose credentials the request carried, in the order its alternative names them. */
+    schemes?: string[];
+    /** Set when the credential was forged on purpose: a probe that expects the backend to refuse it. */
+    forged?: true;
+    /**
+     * Sent as a probe: meant to be refused (`probe: true`). A forged credential is a probe too, and says
+     * so in `forged`. A dedicated credential alone is not: the contract floor's calls with one are
+     * ordinary traffic. A probe's answer is the security checks' to judge.
+     */
+    probe?: true;
+    /** Why the API tester sent it — see `Purpose`. */
+    purpose?: Purpose;
+    /** Sent by the credential store's own ports (a login, a mint, a revoke): what it issues is the store's. */
+    issuedBy?: "credentials";
+    /** The check that issued it, when a check did. */
+    check?: string;
+    /** The entity under test when it was issued. */
+    subject?: string;
+    /**
+     * Set when this response was answered again: a 401 refreshed and retried, or a 429 waited out.
+     * Only the final answer is the backend's verdict on the request.
+     */
+    superseded?: true;
+    /** Set on a 429 or 503 whose `Retry-After` was longer than the API tester waits: it stood, never asked again. */
+    retryAfterExceeded?: RetryAfterExceeded;
+    /**
+     * How the response body held to the schema its operation documents for the status, taken when
+     * it was captured: set when the transcript keeps the body only by reference, as no later reader
+     * could validate it. A body kept whole is validated by the check that reads it.
+     */
+    schemaVerdict?: SchemaVerdict;
+}
+/** A body's validation against its documented schema: the errors, or why the schema could not compile. */
+export interface SchemaVerdict {
+    errors: string[];
+    unchecked?: string;
+}
+/**
+ * Why an exchange happened. Normal traffic — seeding, a check's assertions, auth, teardown — is
+ * what the document has to describe. A deliberate negative probe is the API tester sending something it
+ * expects to be refused, and what a backend answers it with is judged separately.
+ */
+export type Purpose = "seed" | "assertion" | "probe" | "auth" | "teardown";
+export interface BodyRef {
+    sha256: string;
+    bytes: number;
+    mediaType: string;
+}
+export type FormPart = {
+    field: string;
+    value: string;
+} | {
+    field: string;
+    filename: string;
+    mediaType: string;
+    bytes: number;
+    sha256: string;
+};
+export interface FormSnapshot {
+    parts: FormPart[];
+}
+export declare function isBodyRef(value: unknown): value is BodyRef;
+export declare function isFormSnapshot(value: unknown): value is FormSnapshot;
+export declare function isFormData(body: unknown): body is FormData;
+export declare function isURLSearchParams(body: unknown): body is URLSearchParams;
+export declare function isRawBytes(body: unknown): body is ArrayBuffer | ArrayBufferView | Blob;
+export declare function bodyByteLength(body: unknown): number;
+export declare function formDataBytes(form: FormData): number;
+export declare function utf8Bytes(text: string | undefined): number;
+/** Plain snapshot of a request body for reports — FormData is not JSON. */
+export declare function describeRequestBody(body: unknown): unknown;
+//# sourceMappingURL=exchange.d.ts.map

package/dist/api/runtime/exchange.js

@@ -0,0 +1,96 @@
+/*
+ * One request and its answer as the API tester records it, and how its body is described: a live FormData,
+ * a stored reference, a form snapshot or raw bytes. Every module that reads an exchange reads this
+ * one, so the client, the transcript and the journal share a shape without importing each other.
+ */
+import { isRaw } from "../config/types/raw.js";
+export function isBodyRef(value) {
+    if (!isRaw(value))
+        return false;
+    const rec = value;
+    if (typeof rec.sha256 !== "string" || typeof rec.bytes !== "number" || typeof rec.mediaType !== "string") {
+        return false;
+    }
+    for (const key of Object.keys(rec)) {
+        if (key !== "sha256" && key !== "bytes" && key !== "mediaType")
+            return false;
+    }
+    return true;
+}
+export function isFormSnapshot(value) {
+    if (!isRaw(value) || !Array.isArray(value.parts))
+        return false;
+    return Object.keys(value).every((key) => key === "parts");
+}
+export function isFormData(body) {
+    return body instanceof FormData;
+}
+export function isURLSearchParams(body) {
+    return body instanceof URLSearchParams;
+}
+export function isRawBytes(body) {
+    return body instanceof ArrayBuffer || ArrayBuffer.isView(body) || body instanceof Blob;
+}
+export function bodyByteLength(body) {
+    if (typeof body === "string")
+        return utf8Bytes(body);
+    if (isFormData(body))
+        return formDataBytes(body);
+    if (isURLSearchParams(body))
+        return utf8Bytes(body.toString());
+    if (body instanceof Blob)
+        return body.size;
+    if (body instanceof ArrayBuffer)
+        return body.byteLength;
+    if (ArrayBuffer.isView(body))
+        return body.byteLength;
+    return 0;
+}
+export function formDataBytes(form) {
+    let total = 0;
+    for (const [name, value] of form.entries()) {
+        total += utf8Bytes(name) + 80;
+        if (typeof value === "string")
+            total += utf8Bytes(value);
+        else
+            total += value.size + utf8Bytes(value.name);
+    }
+    return total;
+}
+export function utf8Bytes(text) {
+    /* Counted, not encoded: a copy of every body just to measure it is the cost to avoid. */
+    return text === undefined || text === "" ? 0 : Buffer.byteLength(text, "utf8");
+}
+/** Plain snapshot of a request body for reports — FormData is not JSON. */
+export function describeRequestBody(body) {
+    if (body === undefined)
+        return undefined;
+    if (isFormData(body)) {
+        const parts = {};
+        for (const [name, value] of body.entries()) {
+            if (typeof value === "string")
+                parts[name] = value;
+            else
+                parts[name] = { filename: value.name, mediaType: value.type, bytes: value.size };
+        }
+        return parts;
+    }
+    if (isFormSnapshot(body)) {
+        const parts = {};
+        for (const part of body.parts) {
+            if ("value" in part)
+                parts[part.field] = part.value;
+            else
+                parts[part.field] = { bytes: part.bytes, filename: part.filename, mediaType: part.mediaType };
+        }
+        return parts;
+    }
+    if (isURLSearchParams(body))
+        return body.toString();
+    if (isRawBytes(body))
+        return { bytes: bodyByteLength(body) };
+    if (isBodyRef(body))
+        return { bytes: body.bytes, mediaType: body.mediaType, sha256: body.sha256 };
+    return body;
+}
+//# sourceMappingURL=exchange.js.map

package/dist/api/runtime/exchanges/blobs.d.ts

@@ -0,0 +1,19 @@
+/** Content-addressed body storage under the journal's `blobs/`, and the inline-or-spill decision. */
+import type { Redactor } from "../../security/redact.ts";
+export interface StoredBlob {
+    sha256: string;
+    bytes: number;
+}
+export interface BlobStore {
+    readonly redactor: Redactor;
+    /** Writes the bytes once under their hash; a second put of the same bytes writes nothing. */
+    put(bytes: Uint8Array): Promise<StoredBlob>;
+    /** Text redacted by its media type, inline or by reference once it is past the inline limit. */
+    spillText(text: string, mediaType: string): Promise<string | (StoredBlob & {
+        mediaType: string;
+    })>;
+    /** A JSON value redacted, inline or by reference once its serialization is past the limit. */
+    persistJson(value: unknown, mediaType: string): Promise<unknown>;
+}
+export declare function createBlobStore(dir: string, redactor: Redactor): BlobStore;
+//# sourceMappingURL=blobs.d.ts.map