@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/runtime/steps/request.js

@@ -0,0 +1,117 @@
+/*
+ * A step resolved to the request it sends: an operation named in the document, or a raw method
+ * and path for an endpoint the document does not describe, on the primary origin or a named one,
+ * with `{name}` placeholders filled (one nothing fills is refused, never sent as written) and the body
+ * encoded the way the operation documents it.
+ */
+import { isBytes, placeholderNames } from "../../config/types/placeholder.js";
+import { requestContent } from "../../spec/collection/request.js";
+import { encodeRequest } from "../body/encode.js";
+import { interpolate } from "./interpolate.js";
+/** True for a step that names an operation from the document. */
+export function isOperationStep(step) {
+    return "operationId" in step;
+}
+/** True for a step that gives a raw method and path. */
+export function isRequestStep(step) {
+    return "method" in step && "path" in step;
+}
+/** Step `index` of a chain resolved against `scope`; throws when it cannot be sent. */
+export async function resolveRequest(ctx, step, scope, index) {
+    const target = targetOf(ctx, step, index);
+    const fill = (value) => filled(value, { index, kept: ctx.kept ?? new Map(), scope });
+    /* Two shapes, distinguished structurally: name an operation from the document, or give a raw
+     * method and path for an endpoint the document does not describe. */
+    if (isOperationStep(step)) {
+        const op = target.model.byOperationId.get(step.operationId);
+        if (op === undefined) {
+            throw new Error(`testing api: auth step ${index + 1} names operation "${step.operationId}", which is not in the document`);
+        }
+        const raw = target.model.rawOperations.get(step.operationId);
+        const interpolated = step.body === undefined ? undefined : fill(step.body);
+        const encoded = await encodeAuthBody(raw, interpolated, {
+            mediaType: step.mediaType,
+            operationId: step.operationId,
+        });
+        return {
+            client: target.client,
+            method: op.method,
+            path: String(fill(op.path)),
+            ...encoded,
+            ...(step.headers === undefined ? {} : { headers: fill(step.headers) }),
+            ...(step.query === undefined ? {} : { query: fill(step.query) }),
+        };
+    }
+    if (!isRequestStep(step)) {
+        throw new Error(`testing api: auth step ${index + 1} declares neither an operationId nor a method and path`);
+    }
+    return {
+        client: target.client,
+        method: step.method,
+        path: String(fill(step.path)),
+        redirect: step.redirect ?? "follow",
+        ...(step.body === undefined ? {} : { body: fill(step.body) }),
+        ...(step.headers === undefined ? {} : { headers: fill(step.headers) }),
+        ...(step.query === undefined ? {} : { query: fill(step.query) }),
+    };
+}
+/*
+ * A `{name}` the step writes that nothing fills would reach the backend as written and read as its
+ * fault. Read from the step, not from what it sends: a bound value or a kept object may hold
+ * `{id}`-shaped text, a saved URL template say, and is sent as it is.
+ */
+function filled(value, at) {
+    const { index, kept, scope } = at;
+    const name = placeholderNames(value).find((each) => scope[each] === undefined && !kept.has(each));
+    if (name === undefined)
+        return interpolate(value, scope, kept);
+    throw new Error(`testing api: step ${index + 1}'s placeholder {${name}} has no value: no bind, saveAs or earlier step fills it`);
+}
+/** The named origin a step goes to, if it names one. */
+function stepOrigin(step) {
+    if ("outOfBand" in step)
+        return undefined;
+    if ("origin" in step && typeof step.origin === "string" && step.origin !== "")
+        return step.origin;
+    return undefined;
+}
+/** The client and document a step goes through: its named origin's, or the primary one. */
+function targetOf(ctx, step, index) {
+    const origin = stepOrigin(step);
+    if (origin === undefined)
+        return { client: ctx.client, model: ctx.model };
+    const named = ctx.originClients?.get(origin);
+    if (named === undefined) {
+        const known = [...(ctx.originClients?.keys() ?? [])].join(", ");
+        throw new Error(`testing api: auth step ${index + 1} names origin "${origin}", which is not in config.origins` +
+            (known === "" ? "" : ` (known: ${known})`));
+    }
+    return named;
+}
+/** A step body encoded as the operation documents it; anything it cannot encode goes as it is. */
+async function encodeAuthBody(raw, body, options) {
+    const { mediaType, operationId } = options;
+    if (body === undefined)
+        return {};
+    /* An upload goes as it is, under the media type the step names. */
+    if (isBytes(body))
+        return mediaType === undefined ? { body } : { body, contentType: mediaType };
+    const content = raw === undefined ? null : requestContent(raw, mediaType);
+    if (content === null || body === null || typeof body !== "object" || Array.isArray(body)) {
+        return { body };
+    }
+    const encoded = await encodeRequest({
+        fields: body,
+        index: 0,
+        mediaType: content.mediaType,
+        operationId,
+        schema: content.schema,
+        uploads: { seed: 1 },
+        variant: "baseline",
+        ...(content.encoding === undefined ? {} : { encoding: content.encoding }),
+    });
+    return encoded.contentType === undefined
+        ? { body: encoded.body }
+        : { body: encoded.body, contentType: encoded.contentType };
+}
+//# sourceMappingURL=request.js.map

package/dist/api/runtime/steps/runner.d.ts

@@ -0,0 +1,5 @@
+import type { StepRunner } from "../../credentials/ports.ts";
+import type { StepContext } from "./request.ts";
+/** A runner over `ctx`, running each call's steps as the principal it names. */
+export declare function stepRunner(ctx: Omit<StepContext, "principalId">): StepRunner;
+//# sourceMappingURL=runner.d.ts.map

package/dist/api/runtime/steps/runner.js

@@ -0,0 +1,19 @@
+/*
+ * The credentials StepRunner port, served by the step engine. `credentials` sits below the runtime
+ * and cannot import it, so `runtime/run` builds this runner and hands it down: a login or refresh
+ * recipe runs its steps through it and reads the credential out of the answer itself.
+ */
+import { runSteps } from "./engine.js";
+/** A runner over `ctx`, running each call's steps as the principal it names. */
+export function stepRunner(ctx) {
+    return {
+        run: async (steps, { principal, probe, scope }) => {
+            const out = await runSteps({ ...ctx, principalId: principal }, steps, { scope, ...(probe ? { probe } : {}) });
+            if (out.last === undefined) {
+                throw new Error(`testing api: principal "${principal}" ran its steps without sending a request, so there is no answer to read`);
+            }
+            return { answer: out.last, scope: out.scope };
+        },
+    };
+}
+//# sourceMappingURL=runner.js.map

package/dist/api/runtime/target-version.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Which build of the backend a run tested.
+ *
+ * Read once, after sign-in and before anything is created, from a version route: a JSON path into
+ * its body or a response header. It goes through the client like every request, so the fence and
+ * the allowlist apply. A version that cannot be read is noted in the report; it never changes the
+ * verdict, because it says nothing about the backend's behavior.
+ */
+import type { SpecModel } from "../spec/graph/types.ts";
+import type { Client } from "../client/client.ts";
+import type { TargetVersionSpec } from "../config/types/config.ts";
+export type { TargetVersionSpec } from "../config/types/config.ts";
+export type TargetVersion = {
+    value: string;
+} | {
+    error: string;
+};
+/**
+ * What the version read is stamped with. Its failure is the version's `error`, not a server error
+ * of the run: a documented version route is still called, and graded, by the contract floor.
+ */
+export declare const TARGET_VERSION_READ = "run.target-version";
+/** What reading the version needs: where it is, and how to ask as the writer. */
+export interface TargetVersionRead {
+    spec: TargetVersionSpec;
+    model: SpecModel;
+    client: Pick<Client, "get">;
+    /** The writer: an operation's security chooses its scheme; a path sends the configured `scheme`. */
+    principal: string;
+    /** Path ids for a version operation's parameters. */
+    roots: Record<string, string>;
+}
+export declare function readTargetVersion(read: TargetVersionRead): Promise<TargetVersion>;
+//# sourceMappingURL=target-version.d.ts.map

package/dist/api/runtime/target-version.js

@@ -0,0 +1,68 @@
+/**
+ * Which build of the backend a run tested.
+ *
+ * Read once, after sign-in and before anything is created, from a version route: a JSON path into
+ * its body or a response header. It goes through the client like every request, so the fence and
+ * the allowlist apply. A version that cannot be read is noted in the report; it never changes the
+ * verdict, because it says nothing about the backend's behavior.
+ */
+import { readPath } from "../client/read-path.js";
+import { fillPath } from "./fill-path.js";
+import { headerValue } from "./headers.js";
+import { messageOf } from "../errors/message.js";
+/**
+ * What the version read is stamped with. Its failure is the version's `error`, not a server error
+ * of the run: a documented version route is still called, and graded, by the contract floor.
+ */
+export const TARGET_VERSION_READ = "run.target-version";
+export async function readTargetVersion(read) {
+    const { client, principal, spec } = read;
+    const target = versionPath(read);
+    if ("error" in target)
+        return target;
+    const { path } = target;
+    let exchange;
+    try {
+        exchange = await client.get(path, versionRequest(spec, principal));
+    }
+    catch (error) {
+        return { error: messageOf(error) };
+    }
+    if (exchange.status < 200 || exchange.status >= 300)
+        return { error: `GET ${path} returned ${exchange.status}` };
+    const value = versionIn(exchange, spec.from);
+    if (typeof value === "string" || typeof value === "number")
+        return { value: String(value) };
+    return { error: `${spec.from} is not in the response of GET ${path}` };
+}
+/*
+ * Who reads the version. A documented operation's security picks the writer's scheme. An
+ * undocumented path has no security to resolve, so it names its scheme or is read anonymously.
+ */
+function versionRequest(spec, principal) {
+    if (spec.operationId !== undefined)
+        return { as: { principal }, operationId: spec.operationId };
+    return { as: spec.scheme === undefined ? { anonymous: true } : { principal, scheme: spec.scheme } };
+}
+/** The path the version is read from: the operation's, filled from the roots, or the configured one. */
+function versionPath(read) {
+    const { model, roots, spec } = read;
+    if (spec.operationId === undefined) {
+        return spec.path === undefined ? { error: "targetVersion needs an operationId or a path" } : { path: spec.path };
+    }
+    const op = model.byOperationId.get(spec.operationId);
+    if (op === undefined)
+        return { error: `targetVersion.operationId "${spec.operationId}" names no operation` };
+    try {
+        return { path: fillPath(op.path, roots) };
+    }
+    catch (error) {
+        return { error: messageOf(error) };
+    }
+}
+/** The value `from` names: a response header (`header:<name>`), or a JSON path into the body. */
+function versionIn(exchange, from) {
+    const header = /^header:(.+)$/i.exec(from)?.[1]?.trim();
+    return header === undefined ? readPath(exchange.responseBody, from) : headerValue(exchange.responseHeaders, header);
+}
+//# sourceMappingURL=target-version.js.map

package/dist/api/runtime/teardown/ledger.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Teardown of everything a run created.
+ *
+ * A tester that leaves its fixtures behind is a tester nobody runs twice against anything real.
+ * Records are unwound newest-first so children go before the parents they depend on, and every
+ * failure is collected rather than thrown — a teardown that aborts halfway is worse than one that
+ * reports exactly what it could not remove.
+ */
+import type { SpecModel } from "../../spec/graph/types.ts";
+import type { Client } from "../../client/client.ts";
+import type { Exchange } from "../exchange.ts";
+import type { Created, Disposable, Owner, TeardownReport, UnidentifiedCreate, UnwindOptions } from "./types.ts";
+/** How the ledger is unwound: who else may remove a record, and the unwind's options. */
+export interface LedgerUnwind {
+    fallbacks: (owner: Owner) => Owner[];
+    options?: UnwindOptions;
+}
+/**
+ * Registry of what a run brought into existence, recorded the moment each record is created.
+ *
+ * Entries carry their creator. Removing a record with somebody else's credential is at best a
+ * 403 and at worst a 404 that reads as success while the record sits on in the creator's tenant —
+ * so the creator deletes first, and a 404 counts as removal only when the creator sees it.
+ * Entities are recorded in creation order so the unwind can reverse it. A record the API tester adopted
+ * rather than created must never be recorded here: it was not the API tester's to remove.
+ */
+export declare class Ledger {
+    private readonly items;
+    private readonly seen;
+    private readonly unknown;
+    private readonly movedAway;
+    private readonly sightings;
+    private readonly deletes;
+    private readonly held;
+    record({ entity, id, scope, inferred }: Created, owner: Owner): void;
+    /** Whether any principal's record of `entity` with `id` was ever ledgered, removed since or not. */
+    holds(entity: string, id: string): boolean;
+    /** A create that answered 2xx without an id the API tester could read: nothing can remove its record. */
+    unidentified(entity: string, operationId: string, exchange: Exchange): void;
+    /**
+     * A write the backend accepted moved a ledgered record — changed a tenant or parent key, say —
+     * so its creator's 404 no longer shows it gone: it may sit on wherever the write put it.
+     */
+    moved(entity: string, id: string, reason: string): void;
+    /**
+     * A principal read the record back: a read under its id, or a row of a listing. Only its
+     * creator's sighting counts toward showing it gone; a create's own answer is not one.
+     */
+    sighted(entity: string, id: string, principal: string): void;
+    /**
+     * A principal's read under the record's id answered that it is not there. Only the latest read
+     * counts: once its creator lost sight of a record the API tester never deleted, a later 404 shows nothing.
+     * After a delete the backend accepted for it, the 404 is that delete, and the sighting stands.
+     */
+    unsighted(entity: string, id: string, principal: string): void;
+    /** A delete the backend accepted for the record, under any path and as anyone. */
+    deleted(entity: string, id: string): void;
+    private seenByCreator;
+    /** Every create reported unidentified so far, in the order the API tester sent them. */
+    get unidentifiedCreates(): UnidentifiedCreate[];
+    /** Records waiting to be removed. */
+    get size(): number;
+    /** Every record the run made, removed or not. */
+    get recorded(): number;
+    entries(): readonly Disposable[];
+    unwind(model: SpecModel, client: Client, { fallbacks, options }: LedgerUnwind): Promise<TeardownReport>;
+}
+//# sourceMappingURL=ledger.d.ts.map

package/dist/api/runtime/teardown/ledger.js

@@ -0,0 +1,124 @@
+/**
+ * Teardown of everything a run created.
+ *
+ * A tester that leaves its fixtures behind is a tester nobody runs twice against anything real.
+ * Records are unwound newest-first so children go before the parents they depend on, and every
+ * failure is collected rather than thrown — a teardown that aborts halfway is worse than one that
+ * reports exactly what it could not remove.
+ */
+import { keyOf, recordKey } from "./routes.js";
+import { unwindQueue } from "./unwind.js";
+/**
+ * Registry of what a run brought into existence, recorded the moment each record is created.
+ *
+ * Entries carry their creator. Removing a record with somebody else's credential is at best a
+ * 403 and at worst a 404 that reads as success while the record sits on in the creator's tenant —
+ * so the creator deletes first, and a 404 counts as removal only when the creator sees it.
+ * Entities are recorded in creation order so the unwind can reverse it. A record the API tester adopted
+ * rather than created must never be recorded here: it was not the API tester's to remove.
+ */
+export class Ledger {
+    items = [];
+    seen = new Set();
+    /* By exchange: one create is reported once, whichever path saw it. */
+    unknown = new Map();
+    /* Records an accepted write moved, by entity and id, with what moved them. */
+    movedAway = new Map();
+    /* Records a principal read back — `entity, id, principal` — wherever the read came from. */
+    sightings = new Set();
+    /* Records a delete the backend accepted removed, by entity and id, whoever sent it. */
+    deletes = new Set();
+    /* Every record ever ledgered, by entity and id, whoever created it. */
+    held = new Set();
+    record({ entity, id, scope, inferred }, owner) {
+        if (id === "" || id === "undefined")
+            return;
+        /* By principal too: ids are often unique only within a tenant, and each tenant's is its own. */
+        const key = recordKey(entity, id, owner.id);
+        if (this.seen.has(key))
+            return;
+        this.seen.add(key);
+        this.held.add(`${entity}\u0000${id}`);
+        this.items.push({ entity, id, owner, scope: { ...scope }, ...(inferred === true ? { inferred } : {}) });
+    }
+    /** Whether any principal's record of `entity` with `id` was ever ledgered, removed since or not. */
+    holds(entity, id) {
+        return this.held.has(`${entity}\u0000${id}`);
+    }
+    /** A create that answered 2xx without an id the API tester could read: nothing can remove its record. */
+    unidentified(entity, operationId, exchange) {
+        if (this.unknown.has(exchange.seq))
+            return;
+        this.unknown.set(exchange.seq, {
+            entity,
+            method: exchange.method,
+            operationId,
+            seq: exchange.seq,
+            status: exchange.status,
+            url: exchange.url,
+        });
+    }
+    /**
+     * A write the backend accepted moved a ledgered record — changed a tenant or parent key, say —
+     * so its creator's 404 no longer shows it gone: it may sit on wherever the write put it.
+     */
+    moved(entity, id, reason) {
+        this.movedAway.set(`${entity}\u0000${id}`, reason);
+    }
+    /**
+     * A principal read the record back: a read under its id, or a row of a listing. Only its
+     * creator's sighting counts toward showing it gone; a create's own answer is not one.
+     */
+    sighted(entity, id, principal) {
+        this.sightings.add(recordKey(entity, id, principal));
+    }
+    /**
+     * A principal's read under the record's id answered that it is not there. Only the latest read
+     * counts: once its creator lost sight of a record the API tester never deleted, a later 404 shows nothing.
+     * After a delete the backend accepted for it, the 404 is that delete, and the sighting stands.
+     */
+    unsighted(entity, id, principal) {
+        if (this.deletes.has(`${entity}\u0000${id}`))
+            return;
+        this.sightings.delete(recordKey(entity, id, principal));
+    }
+    /** A delete the backend accepted for the record, under any path and as anyone. */
+    deleted(entity, id) {
+        this.deletes.add(`${entity}\u0000${id}`);
+    }
+    seenByCreator(item) {
+        return this.sightings.has(keyOf(item));
+    }
+    /** Every create reported unidentified so far, in the order the API tester sent them. */
+    get unidentifiedCreates() {
+        return [...this.unknown.values()].sort((a, b) => a.seq - b.seq);
+    }
+    /** Records waiting to be removed. */
+    get size() {
+        return this.items.length;
+    }
+    /** Every record the run made, removed or not. */
+    get recorded() {
+        return this.seen.size;
+    }
+    entries() {
+        return this.items;
+    }
+    unwind(model, client, { fallbacks, options = {} }) {
+        /* Takes what is ledgered now; a later unwind removes only what was recorded after this one. */
+        const queue = this.items.splice(0).toReversed();
+        return unwindQueue({
+            client,
+            fallbacks,
+            ledger: {
+                movedAway: (item) => this.movedAway.get(`${item.entity}\u0000${item.id}`),
+                seenByCreator: (item) => this.seenByCreator(item),
+                sighted: (entity, id, principal) => this.sighted(entity, id, principal),
+            },
+            model,
+            options,
+            queue,
+        });
+    }
+}
+//# sourceMappingURL=ledger.js.map

package/dist/api/runtime/teardown/never-seen.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A record gone by every sign HTTP gives, yet its creator never saw it: no sign could have shown
+ * it gone, so it is not counted removed.
+ */
+import { type Unwind } from "./remove.ts";
+import type { Disposable } from "./types.ts";
+export declare const NEVER_SEEN = "its creator could never read it back, so teardown cannot tell whether it is gone";
+/** Moves each such record from removed to leftover; returns them. */
+export declare function markNeverSeen(state: Unwind, queue: readonly Disposable[]): Set<Disposable>;
+//# sourceMappingURL=never-seen.d.ts.map

package/dist/api/runtime/teardown/never-seen.js

@@ -0,0 +1,27 @@
+/**
+ * A record gone by every sign HTTP gives, yet its creator never saw it: no sign could have shown
+ * it gone, so it is not counted removed.
+ */
+import { leftover } from "./remove.js";
+import { readPathOf } from "./routes.js";
+export const NEVER_SEEN = "its creator could never read it back, so teardown cannot tell whether it is gone";
+/** Moves each such record from removed to leftover; returns them. */
+export function markNeverSeen(state, queue) {
+    const { model, report } = state;
+    const neverSeen = new Set();
+    for (const item of queue) {
+        /* Every record the unwind was given has its line. */
+        const record = state.records.get(item);
+        if (!record.removed || state.ledger.seenByCreator(item) || readPathOf(model, item) === null)
+            continue;
+        /* A removed record was sent its delete. */
+        if (state.deletedEarlier(state.paths.get(item)))
+            continue;
+        record.removed = false;
+        report.removed -= 1;
+        report.failed.push(leftover(item, NEVER_SEEN));
+        neverSeen.add(item);
+    }
+    return neverSeen;
+}
+//# sourceMappingURL=never-seen.js.map

package/dist/api/runtime/teardown/remove.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Removing one record: its delete sent by its creator first, then by each principal allowed to
+ * remove what the creator was refused. Gone is the goal, not a successful call.
+ */
+import type { SpecModel } from "../../spec/graph/types.ts";
+import type { Client } from "../../client/client.ts";
+import type { Disposable, LedgerView, Owner, RecordState, TeardownReport, UnwindOptions } from "./types.ts";
+/** An unwind in progress: what it removes with, and what it has learned so far. */
+export interface Unwind {
+    model: SpecModel;
+    client: Client;
+    fallbacks: (owner: Owner) => Owner[];
+    ledger: LedgerView;
+    onItem: UnwindOptions["onItem"];
+    report: TeardownReport;
+    records: ReadonlyMap<Disposable, RecordState>;
+    /** The delete path each record was sent to. */
+    paths: Map<Disposable, string>;
+    unsupported: Set<string>;
+    deletedEarlier: (path: string) => boolean;
+    done: number;
+    total: number;
+}
+/** A record still in place, as the report lists it. */
+export declare function leftover(item: Disposable, reason: string): TeardownReport["failed"][number];
+export declare function removeOne(state: Unwind, item: Disposable): Promise<void>;
+//# sourceMappingURL=remove.d.ts.map

package/dist/api/runtime/teardown/remove.js

@@ -0,0 +1,110 @@
+/**
+ * Removing one record: its delete sent by its creator first, then by each principal allowed to
+ * remove what the creator was refused. Gone is the goal, not a successful call.
+ */
+import { UnsatisfiedSecurity } from "../../client/credential-source.js";
+import { fillPath } from "../fill-path.js";
+import { deleteOperationFor } from "./routes.js";
+/** A record still in place, as the report lists it. */
+export function leftover(item, reason) {
+    return { entity: item.entity, id: item.id, principal: item.owner.id, reason };
+}
+const messageOf = (error) => (error instanceof Error ? error.message : String(error));
+/**
+ * Whether an answer shows the record gone. Only the creator's 404 says so — anyone else's may just
+ * mean they cannot see it — and not once a write moved the record away.
+ */
+function shownGone(exchange, byCreator, moved) {
+    return (exchange.status < 300 || (byCreator && moved === undefined && (exchange.status === 404 || exchange.status === 410)));
+}
+/*
+ * A record whose entity has no delete. A declared create's entity is listed once as unsupported; an
+ * inferred record is named, since no create in the document warns its reader that the record exists.
+ */
+function undeletable(state, item) {
+    if (item.inferred === true) {
+        const reason = `inferred from an answer that named a new ${item.entity}_id; the document declares no delete for ${item.entity}`;
+        state.report.failed.push(leftover(item, reason));
+    }
+    else
+        state.unsupported.add(item.entity);
+    state.done += 1;
+}
+export async function removeOne(state, item) {
+    const { report } = state;
+    const deleteOp = deleteOperationFor(item.entity, state.model);
+    if (deleteOp === null) {
+        undeletable(state, item);
+        return;
+    }
+    const param = deleteOp.pathParams.at(-1);
+    const scope = param === undefined ? item.scope : { ...item.scope, [param]: item.id };
+    let path;
+    try {
+        path = fillPath(deleteOp.path, scope);
+    }
+    catch (error) {
+        report.failed.push(leftover(item, messageOf(error)));
+        state.done += 1;
+        return;
+    }
+    state.paths.set(item, path);
+    const moved = state.ledger.movedAway(item);
+    try {
+        const attempts = [];
+        let removed = false;
+        for (const [index, deleter] of [item.owner, ...state.fallbacks(item.owner)].entries()) {
+            /* An x-cleanup route may remove with another method than DELETE: its own is sent. */
+            const exchange = await deleteAs(state, { method: deleteOp.method, path }, deleter.id);
+            if (typeof exchange === "string") {
+                attempts.push(`${deleter.id}: ${exchange}`);
+                continue;
+            }
+            attempts.push(`${deleter.id}: ${exchange.status}`);
+            if (shownGone(exchange, index === 0, moved)) {
+                removed = true;
+                break;
+            }
+            /* Only a denial is worth retrying with a stronger credential. */
+            if (exchange.status !== 401 && exchange.status !== 403)
+                break;
+        }
+        /* A delete earlier in the run already removed it: a tenant the creator then left may refuse
+         * every later request, its own delete included. The call above still goes first, so a
+         * record restored since is removed rather than assumed gone. */
+        if (!removed && state.deletedEarlier(path))
+            removed = true;
+        settle(state, item, removed ? null : `${moved === undefined ? "" : `${moved}; `}DELETE ${path} returned ${attempts.join(", ")}`);
+    }
+    catch (error) {
+        report.failed.push(leftover(item, messageOf(error)));
+    }
+    state.done += 1;
+    state.onItem?.(state.done, state.total, item);
+}
+/*
+ * One deleter's request: its exchange, or why it could not be sent, a credential the deleter cannot
+ * hold (BLOCKED by a failed login or renewal) say, so the next deleter is tried as after a denial.
+ */
+async function deleteAs(state, route, principal) {
+    try {
+        return await state.client.request(route.method, route.path, { as: { principal } });
+    }
+    catch (error) {
+        if (!(error instanceof UnsatisfiedSecurity))
+            throw error;
+        return `not sent (${error.reason})`;
+    }
+}
+/** Counts the record removed, or a leftover for `reason`. */
+function settle(state, item, reason) {
+    if (reason !== null) {
+        state.report.failed.push(leftover(item, reason));
+        return;
+    }
+    state.report.removed += 1;
+    /* Every record the unwind was given has its line. */
+    const record = state.records.get(item);
+    record.removed = true;
+}
+//# sourceMappingURL=remove.js.map

package/dist/api/runtime/teardown/render.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Teardown's lines in the console report: what was cleaned up, and every record left behind.
+ */
+import type { TeardownReport } from "./types.ts";
+/** `report` is null when no teardown ran: `keepFixtures`, or nothing was made. */
+export declare function renderTeardown(report: TeardownReport | null, created: number): string[];
+//# sourceMappingURL=render.d.ts.map