@workerstack/testing 0.0.0-stage → 0.31.0

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

@@ -0,0 +1,51 @@
+/**
+ * Teardown's lines in the console report: what was cleaned up, and every record left behind.
+ */
+/** `report` is null when no teardown ran: `keepFixtures`, or nothing was made. */
+export function renderTeardown(report, created) {
+    if (report === null)
+        return created === 0 ? [] : [`  left ${created} created record(s) in place: teardown did not run`];
+    const lines = renderUnidentified(report.unidentified);
+    if (created === 0)
+        return lines;
+    if (report.failed.length === 0 && report.unsupported.length === 0) {
+        lines.push(`  cleaned up ${report.removed}/${created} created record(s)`);
+        return [...lines, ...renderInferred(report.records)];
+    }
+    lines.push(`  cleanup: removed ${report.removed}/${created} created record(s)`);
+    if (report.unsupported.length > 0) {
+        lines.push(`    ${report.unsupported.join(", ")} — no delete operation in the document, so records ` +
+            "created for these entities remain. Declare x-cleanup to make them removable.");
+    }
+    for (const failure of report.failed.slice(0, 5)) {
+        lines.push(`    ${failure.entity} ${failure.id} (as ${failure.principal}): ${failure.reason}`);
+    }
+    if (report.failed.length > 5)
+        lines.push(`    … and ${report.failed.length - 5} more`);
+    return [...lines, ...renderInferred(report.records)];
+}
+/* Each record ledgered from an answer rather than a declared create, so a reader can check it. */
+function renderInferred(records) {
+    const inferred = records.filter((record) => record.inferred === true);
+    if (inferred.length === 0)
+        return [];
+    return [
+        `  inferred: ${inferred.length} record(s) ledgered from an answer that named a new id, not from a declared create`,
+        ...inferred.map((record) => `    ${record.entity} ${record.id} (as ${record.principal}): ${record.removed ? "removed" : "left in place"}`),
+    ];
+}
+/* Each one a record the API tester made and cannot remove: listed by the request that made it. */
+function renderUnidentified(unidentified) {
+    if (unidentified.length === 0)
+        return [];
+    const lines = [
+        `  leftovers: ${unidentified.length} create(s) answered 2xx but no id could be read; the record may remain`,
+    ];
+    for (const create of unidentified.slice(0, 5)) {
+        lines.push(`    ${create.operationId} ${create.method} ${create.url} → ${create.status} (#${create.seq})`);
+    }
+    if (unidentified.length > 5)
+        lines.push(`    … and ${unidentified.length - 5} more`);
+    return lines;
+}
+//# sourceMappingURL=render.js.map

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

@@ -0,0 +1,26 @@
+/**
+ * The routes teardown removes and reads records by, and what the run already deleted.
+ */
+import type { OperationModel, SpecModel } from "../../spec/graph/types.ts";
+import type { Exchange } from "../exchange.ts";
+import type { Disposable } from "./types.ts";
+/** A record as each principal holds it: two tenants may each have their own `row 1`. */
+export declare function recordKey(entity: string, id: string, principal: string): string;
+export declare function keyOf(item: Disposable): string;
+/**
+ * Whether a path, or an ancestor of it, was removed by a 2xx delete earlier in the run — compared
+ * by segments, so `/tables/1` is never `/tables/11`. Earlier paths carry the base path; the path
+ * asked about does not.
+ */
+export declare function deletedEarlierIn(transcript: readonly Exchange[]): (path: string) => boolean;
+/** The record's own read path, or `null` when its entity has no read it can fill. */
+export declare function readPathOf(model: SpecModel, item: Disposable): {
+    op: OperationModel;
+    path: string;
+} | null;
+/**
+ * The operation that removes an instance: the entity's own delete, or an explicit `x-cleanup`
+ * route for entities whose removal lives somewhere the graph does not connect.
+ */
+export declare function deleteOperationFor(entityName: string, model: SpecModel): OperationModel | null;
+//# sourceMappingURL=routes.d.ts.map

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

@@ -0,0 +1,83 @@
+/**
+ * The routes teardown removes and reads records by, and what the run already deleted.
+ */
+import { parseRouteRef } from "../../spec/routes.js";
+import { fillPath } from "../fill-path.js";
+/** A record as each principal holds it: two tenants may each have their own `row 1`. */
+export function recordKey(entity, id, principal) {
+    return `${entity}\u0000${id}\u0000${principal}`;
+}
+export function keyOf(item) {
+    return recordKey(item.entity, item.id, item.owner.id);
+}
+/** Path segments, decoded, without empty ones. */
+function segmentsOf(pathname) {
+    return pathname
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => {
+        try {
+            return decodeURIComponent(segment);
+        }
+        catch {
+            return segment;
+        }
+    });
+}
+/**
+ * Whether a path, or an ancestor of it, was removed by a 2xx delete earlier in the run — compared
+ * by segments, so `/tables/1` is never `/tables/11`. Earlier paths carry the base path; the path
+ * asked about does not.
+ */
+export function deletedEarlierIn(transcript) {
+    const earlierDeletes = new Set(transcript
+        .filter((exchange) => exchange.method === "DELETE" && exchange.status >= 200 && exchange.status < 300)
+        .map((exchange) => new URL(exchange.url).pathname));
+    const earlierSegments = [...earlierDeletes].map(segmentsOf);
+    return (path) => {
+        const target = segmentsOf(path.split("?")[0]);
+        return earlierSegments.some((done) => {
+            for (let k = target.length; k >= 1; k--) {
+                if (done.length >= k && done.slice(-k).every((segment, at) => segment === target[at]))
+                    return true;
+            }
+            return false;
+        });
+    };
+}
+/** The record's own read path, or `null` when its entity has no read it can fill. */
+export function readPathOf(model, item) {
+    const readId = model.entities.get(item.entity)?.read;
+    const op = readId === undefined ? undefined : model.byOperationId.get(readId);
+    const param = op?.pathParams.at(-1);
+    if (op === undefined || param === undefined)
+        return null;
+    try {
+        return { op, path: fillPath(op.path, { ...item.scope, [param]: item.id }) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The operation that removes an instance: the entity's own delete, or an explicit `x-cleanup`
+ * route for entities whose removal lives somewhere the graph does not connect.
+ */
+export function deleteOperationFor(entityName, model) {
+    const entity = model.entities.get(entityName);
+    /* An entity's delete is one of the model's operations. */
+    if (entity?.delete !== undefined)
+        return model.byOperationId.get(entity.delete);
+    for (const op of model.operations) {
+        if (op.entity !== entityName || op.cleanup === null)
+            continue;
+        const parsed = parseRouteRef(op.cleanup);
+        if (parsed === null)
+            continue;
+        const target = model.byRoute.get(`${parsed.method} ${parsed.path}`);
+        if (target !== undefined)
+            return target;
+    }
+    return null;
+}
+//# sourceMappingURL=routes.js.map

package/dist/api/runtime/teardown/still-listed.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Which of a group's records its list still holds, read page by page as the list declares its
+ * paging, until the list ends or every one of them has been seen.
+ */
+import type { OperationModel, SpecModel } from "../../spec/graph/types.ts";
+import type { Client } from "../../client/client.ts";
+import type { Disposable, Owner } from "./types.ts";
+/** Removed records that lived in one list, as one creator reads it. */
+export interface ListGroup {
+    identity: string;
+    listOp: OperationModel;
+    owner: Owner;
+    path: string;
+    items: Disposable[];
+}
+/** What a re-list saw: the records still listed, and whether it read to the list's proven end. */
+export interface Listing {
+    listed: Set<string>;
+    /**
+     * The last page read showed the list ends there: it was empty, shorter than a full page already
+     * served, or its envelope said no more follow. Only then is a record it did not list shown absent.
+     */
+    complete: boolean;
+}
+/** The group's records still listed; `null` when the first page could not be read: nothing is claimed either way. */
+export declare function stillListed(model: SpecModel, client: Client, group: ListGroup): Promise<Set<string> | null>;
+/** The group's list, read as stillListed reads it, and whether that read reached the list's end. */
+export declare function listing(model: SpecModel, client: Client, group: ListGroup): Promise<Listing | null>;
+//# sourceMappingURL=still-listed.d.ts.map

package/dist/api/runtime/teardown/still-listed.js

@@ -0,0 +1,116 @@
+/**
+ * Which of a group's records its list still holds, read page by page as the list declares its
+ * paging, until the list ends or every one of them has been seen.
+ */
+import { UnsatisfiedSecurity } from "../../client/credential-source.js";
+import { nextCursorOf } from "../../spec/collection/cursor.js";
+import { largestPageQuery } from "../../spec/graph/paging.js";
+import { FencedError } from "../fence.js";
+import { isNetworkError } from "../../errors/network.js";
+import { readPath } from "../../client/read-path.js";
+import { idOf, recordsFromList } from "../world/records.js";
+/* The most pages one re-list reads: teardown looks for its own records, it does not crawl. */
+const VERIFY_PAGES = 50;
+/** The group's records still listed; `null` when the first page could not be read: nothing is claimed either way. */
+export async function stillListed(model, client, group) {
+    return (await listing(model, client, group))?.listed ?? null;
+}
+/** The group's list, read as stillListed reads it, and whether that read reached the list's end. */
+export async function listing(model, client, group) {
+    const paging = group.listOp.conventions;
+    const first = largestPageQuery(model, group.listOp);
+    const walk = {
+        cursor: undefined,
+        ended: false,
+        fullPage: 0,
+        listed: new Set(),
+        seen: new Set(),
+        served: 0,
+        wanted: new Set(group.items.map((item) => item.id)),
+    };
+    for (let index = 0; index < VERIFY_PAGES; index++) {
+        const query = pageQuery(paging, first, { ...walk, index });
+        if (query === null)
+            break;
+        let exchange;
+        try {
+            exchange = await client.get(group.path, {
+                as: { principal: group.owner.id },
+                operationId: group.listOp.operationId,
+                query,
+            });
+        }
+        catch (error) {
+            /* A list that could not be asked shows nothing: fenced, offline, or an owner's BLOCKED credential. */
+            if (!(error instanceof FencedError) && !(error instanceof UnsatisfiedSecurity) && !isNetworkError(error)) {
+                throw error;
+            }
+            return index === 0 ? null : unended(walk);
+        }
+        if (exchange.status >= 300)
+            return index === 0 ? null : unended(walk);
+        if (!takePage(walk, group, exchange))
+            break;
+    }
+    return { complete: walk.ended, listed: walk.listed };
+}
+/* A walk cut short by a page it could not read: what it listed, with no end shown. */
+function unended(walk) {
+    return { complete: false, listed: walk.listed };
+}
+/** The query for page `index`, or `null` when the list declares no way to ask for it. */
+function pageQuery(paging, first, at) {
+    const query = { ...first };
+    if (at.index === 0)
+        return query;
+    if (paging.page !== undefined)
+        query[paging.page] = at.index + 1;
+    else if (paging.offset !== undefined)
+        query[paging.offset] = at.served;
+    else if (paging.cursor !== undefined && at.cursor !== undefined)
+        query[paging.cursor] = at.cursor;
+    else
+        return null;
+    return query;
+}
+/**
+ * Reads one page into the walk; false once the list has ended: an empty page, the same page
+ * again, one shorter than a full page already served, or every record seen.
+ */
+function takePage(walk, group, exchange) {
+    const paging = group.listOp.conventions;
+    const rows = recordsFromList(exchange.responseBody, group.listOp.collection);
+    walk.served += rows.length;
+    walk.ended = endsHere(walk, paging.envelope, { body: exchange.responseBody, rows: rows.length });
+    const ids = rows.flatMap((row) => idOf(row, group.identity) ?? []);
+    const fresh = ids.filter((id) => !walk.seen.has(id));
+    for (const id of ids) {
+        walk.seen.add(id);
+        if (walk.wanted.has(id))
+            walk.listed.add(id);
+    }
+    if (fresh.length === 0 || walk.listed.size === walk.wanted.size)
+        return false;
+    if (walk.fullPage > 0 && rows.length < walk.fullPage)
+        return false;
+    walk.fullPage = Math.max(walk.fullPage, rows.length);
+    const next = paging.envelope.nextCursor === undefined ? undefined : readPath(exchange.responseBody, paging.envelope.nextCursor);
+    walk.cursor = nextCursorOf(next);
+    return true;
+}
+/* Whether this page is the list's last: empty, short of a full page served before, or its envelope says so. */
+function endsHere(walk, envelope, page) {
+    if (page.rows === 0 || (walk.fullPage > 0 && page.rows < walk.fullPage))
+        return true;
+    const read = (path) => (path === undefined ? undefined : readPath(page.body, path));
+    if (read(envelope.hasMore) === false)
+        return true;
+    const total = read(envelope.total);
+    if (typeof total === "number" && walk.served >= total)
+        return true;
+    if (envelope.nextCursor === undefined)
+        return false;
+    const next = read(envelope.nextCursor);
+    return next === null || next === undefined || next === "";
+}
+//# sourceMappingURL=still-listed.js.map

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

@@ -0,0 +1,76 @@
+import type { RemovalVerdict, RemovedRecord } from "../../config/types/hooks.ts";
+import type { ProvenId } from "../proven-id.ts";
+/** A record the API tester made: its entity, the id the backend gave back, and the path parameters in scope. */
+export interface Created {
+    entity: string;
+    id: ProvenId;
+    scope: Record<string, string>;
+    /**
+     * Ledgered from a POST that is not the entity's create, whose answer named a new `<entity>_id`
+     * that a read then showed: inferred, not declared.
+     */
+    inferred?: true;
+}
+/** The principal a record belongs to, as far as removing it goes: removed as it, `as: { principal: id }`. */
+export interface Owner {
+    id: string;
+}
+export interface Disposable {
+    entity: string;
+    id: string;
+    /** Path parameters in scope when the record was created. */
+    scope: Record<string, string>;
+    /** Who created it. Only the creator's view of the record decides whether it is gone. */
+    owner: Owner;
+    /** Ledgered from an answer that named a new id, not from a declared create. */
+    inferred?: true;
+}
+/** A create that answered 2xx without an id the API tester could read: what it made may remain. */
+export interface UnidentifiedCreate {
+    entity: string;
+    operationId: string;
+    method: string;
+    url: string;
+    status: number;
+    /** The exchange's sequence number in the run's transcript. */
+    seq: number;
+}
+export interface TeardownReport {
+    removed: number;
+    /** Records still in place, each with the principal that created it. */
+    failed: Array<{
+        entity: string;
+        id: string;
+        principal: string;
+        reason: string;
+    }>;
+    unsupported: string[];
+    /** Every record the unwind was given, in creation order, its creator, and whether it is gone now. */
+    records: Array<{
+        entity: string;
+        id: string;
+        principal: string;
+        removed: boolean;
+        inferred?: true;
+    }>;
+    /** Creates whose record the API tester could not identify, so could not remove. Each fails the run. */
+    unidentified: UnidentifiedCreate[];
+    /** What `hooks.verifyRemoved` threw, once per call that did; those records keep teardown's verdict. */
+    verifyHookErrors?: string[];
+}
+export interface UnwindOptions {
+    onItem?: (done: number, total: number, item: Disposable) => void;
+    verify?: boolean;
+    verifyRemoved?: (record: RemovedRecord) => RemovalVerdict | Promise<RemovalVerdict>;
+}
+/** One record's line in the report, updated as the unwind learns whether it is gone. */
+export type RecordState = TeardownReport["records"][number];
+/** What the unwind asks of the ledger it unwinds. */
+export interface LedgerView {
+    /** What moved the record away, when an accepted write did. */
+    movedAway: (item: Disposable) => string | undefined;
+    /** Whether the record's creator ever read it back. */
+    seenByCreator: (item: Disposable) => boolean;
+    sighted: (entity: string, id: string, principal: string) => void;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,20 @@
+/**
+ * The unwind: deepest records first, one level at a time, every record within a level at once.
+ * A record's depth is how many path parameters its delete route takes: a child's route carries
+ * its parent's parameters and its own, so a level never holds a record and its parent. Newest
+ * first within a level keeps the order the creation sequence implies.
+ */
+import type { SpecModel } from "../../spec/graph/types.ts";
+import type { Client } from "../../client/client.ts";
+import type { Disposable, LedgerView, Owner, TeardownReport, UnwindOptions } from "./types.ts";
+export interface UnwindInput {
+    model: SpecModel;
+    client: Client;
+    fallbacks: (owner: Owner) => Owner[];
+    options: UnwindOptions;
+    /** The records to remove, newest first. */
+    queue: readonly Disposable[];
+    ledger: LedgerView;
+}
+export declare function unwindQueue(input: UnwindInput): Promise<TeardownReport>;
+//# sourceMappingURL=unwind.d.ts.map

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

@@ -0,0 +1,83 @@
+/**
+ * The unwind: deepest records first, one level at a time, every record within a level at once.
+ * A record's depth is how many path parameters its delete route takes: a child's route carries
+ * its parent's parameters and its own, so a level never holds a record and its parent. Newest
+ * first within a level keeps the order the creation sequence implies.
+ */
+import { UnsatisfiedSecurity } from "../../client/credential-source.js";
+import { FencedError } from "../fence.js";
+import { isNetworkError } from "../../errors/network.js";
+import { markNeverSeen } from "./never-seen.js";
+import { removeOne } from "./remove.js";
+import { deletedEarlierIn, deleteOperationFor, readPathOf } from "./routes.js";
+import { askVerifyHook } from "./verify-hook.js";
+import { verifyGone } from "./verify-gone.js";
+export async function unwindQueue(input) {
+    const { client, ledger, model, options, queue } = input;
+    const { verify = true } = options;
+    const report = { failed: [], records: [], removed: 0, unidentified: [], unsupported: [] };
+    const records = new Map(queue.map((item) => [
+        item,
+        {
+            entity: item.entity,
+            id: item.id,
+            principal: item.owner.id,
+            removed: false,
+            ...(item.inferred === true ? { inferred: true } : {}),
+        },
+    ]));
+    const state = {
+        client,
+        deletedEarlier: deletedEarlierIn(client.transcript),
+        done: 0,
+        fallbacks: input.fallbacks,
+        ledger,
+        model,
+        onItem: options.onItem,
+        paths: new Map(),
+        records,
+        report,
+        total: queue.length,
+        unsupported: new Set(),
+    };
+    const depthOf = (item) => deleteOperationFor(item.entity, model)?.pathParams.length ?? 0;
+    const levels = [...new Set(queue.map(depthOf))].sort((a, b) => b - a);
+    for (const level of levels) {
+        const removing = queue.filter((item) => depthOf(item) === level);
+        /* A record its creator never read back is read once, as its creator. */
+        await Promise.all(removing.filter((item) => !ledger.seenByCreator(item)).map((item) => readBack(state, item)));
+        await Promise.all(removing.map((item) => removeOne(state, item)));
+        /* Before the parents go: a removed parent takes with it the list its children are read in. */
+        if (verify)
+            await verifyGone({ client, model, queue: removing, records, report });
+    }
+    const neverSeen = markNeverSeen(state, queue);
+    if (options.verifyRemoved !== undefined) {
+        await askVerifyHook(options.verifyRemoved, { neverSeen, queue, records, report });
+    }
+    report.unsupported = [...state.unsupported];
+    report.records = [...records.values()].toReversed();
+    return report;
+}
+/*
+ * One read of the record as its creator; a 2xx is the sighting it lacked. A read that cannot go,
+ * fenced, offline, or as a creator with no credential to send, leaves it unsighted.
+ */
+async function readBack(state, item) {
+    const read = readPathOf(state.model, item);
+    if (read === null)
+        return;
+    try {
+        const exchange = await state.client.get(read.path, {
+            as: { principal: item.owner.id },
+            operationId: read.op.operationId,
+        });
+        if (exchange.status >= 200 && exchange.status < 300)
+            state.ledger.sighted(item.entity, item.id, item.owner.id);
+    }
+    catch (error) {
+        if (!(error instanceof FencedError) && !(error instanceof UnsatisfiedSecurity) && !isNetworkError(error))
+            throw error;
+    }
+}
+//# sourceMappingURL=unwind.js.map

package/dist/api/runtime/teardown/verify-gone.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The list a removed record lived in, read again with its creator's credential: a record still
+ * listed is a leftover, whatever its delete answered. A record whose entity has no list is read
+ * back by its item read instead: a 2xx is a leftover, a 404 or 410 shows it gone. A read that
+ * cannot be sent — fenced, or the network gone — verifies nothing and claims nothing.
+ */
+import type { SpecModel } from "../../spec/graph/types.ts";
+import type { Client } from "../../client/client.ts";
+import type { Disposable, RecordState, TeardownReport } from "./types.ts";
+export declare const STILL_LISTED = "delete answered 2xx but the record is still listed";
+export declare const STILL_READS = "delete answered 2xx but the record still reads back";
+/** One level of the unwind, and the report its re-lists amend. */
+export interface Relist {
+    model: SpecModel;
+    client: Client;
+    queue: readonly Disposable[];
+    records: ReadonlyMap<Disposable, RecordState>;
+    report: TeardownReport;
+}
+export declare function verifyGone(relist: Relist): Promise<void>;
+//# sourceMappingURL=verify-gone.d.ts.map

package/dist/api/runtime/teardown/verify-gone.js

@@ -0,0 +1,87 @@
+/**
+ * The list a removed record lived in, read again with its creator's credential: a record still
+ * listed is a leftover, whatever its delete answered. A record whose entity has no list is read
+ * back by its item read instead: a 2xx is a leftover, a 404 or 410 shows it gone. A read that
+ * cannot be sent — fenced, or the network gone — verifies nothing and claims nothing.
+ */
+import { UnsatisfiedSecurity } from "../../client/credential-source.js";
+import { isNetworkError } from "../../errors/network.js";
+import { FencedError } from "../fence.js";
+import { fillPath } from "../fill-path.js";
+import { leftover } from "./remove.js";
+import { readPathOf } from "./routes.js";
+import { stillListed } from "./still-listed.js";
+export const STILL_LISTED = "delete answered 2xx but the record is still listed";
+export const STILL_READS = "delete answered 2xx but the record still reads back";
+export async function verifyGone(relist) {
+    for (const group of groupsOf(relist).values()) {
+        const listed = await stillListed(relist.model, relist.client, group);
+        if (listed === null)
+            continue;
+        for (const item of group.items)
+            if (listed.has(item.id))
+                stillThere(relist, item, STILL_LISTED);
+    }
+    const unlisted = relist.queue.filter((item) => removed(relist, item) && relist.model.entities.get(item.entity)?.list === undefined);
+    const reads = await Promise.all(unlisted.map((item) => readsBack(relist, item)));
+    unlisted.forEach((item, at) => {
+        if (reads[at] === true)
+            stillThere(relist, item, STILL_READS);
+    });
+}
+/* Every record the unwind was given has its line. */
+const removed = (relist, item) => relist.records.get(item).removed;
+/** A record counted removed that is still there: a leftover after all. */
+function stillThere(relist, item, reason) {
+    ;
+    relist.records.get(item).removed = false;
+    relist.report.removed -= 1;
+    relist.report.failed.push(leftover(item, reason));
+}
+/**
+ * Whether the record still reads back as its creator. Only a 2xx says it does; a record with no
+ * read to fill, a read that cannot be sent, or any other answer claims nothing.
+ */
+async function readsBack(relist, item) {
+    const read = readPathOf(relist.model, item);
+    if (read === null)
+        return false;
+    try {
+        const exchange = await relist.client.get(read.path, {
+            as: { principal: item.owner.id },
+            operationId: read.op.operationId,
+        });
+        return exchange.status >= 200 && exchange.status < 300;
+    }
+    catch (error) {
+        if (!(error instanceof FencedError) && !(error instanceof UnsatisfiedSecurity) && !isNetworkError(error))
+            throw error;
+        return false;
+    }
+}
+/** The removed records by the list each lived in, as its creator reads it. */
+function groupsOf(relist) {
+    const { model } = relist;
+    const groups = new Map();
+    for (const item of relist.queue) {
+        if (!removed(relist, item))
+            continue;
+        const entity = model.entities.get(item.entity);
+        const listOp = entity?.list === undefined ? undefined : model.byOperationId.get(entity.list);
+        if (entity === undefined || listOp === undefined || entity.identity === null)
+            continue;
+        let path;
+        try {
+            path = fillPath(listOp.path, item.scope);
+        }
+        catch {
+            continue;
+        }
+        const key = `${item.entity}\u0000${path}\u0000${item.owner.id}`;
+        const group = groups.get(key) ?? { identity: entity.identity, items: [], listOp, owner: item.owner, path };
+        group.items.push(item);
+        groups.set(key, group);
+    }
+    return groups;
+}
+//# sourceMappingURL=verify-gone.js.map

package/dist/api/runtime/teardown/verify-hook.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `hooks.verifyRemoved`: the product's own word on whether a record is gone, asked about every
+ * record counted removed and every one never seen.
+ */
+import type { Disposable, RecordState, TeardownReport, UnwindOptions } from "./types.ts";
+export declare const VERIFY_HOOK_PRESENT = "hooks.verifyRemoved says it is still present";
+/** The unwind's records, the ones never seen, and the report the verdicts amend. */
+export interface Verdicts {
+    queue: readonly Disposable[];
+    records: ReadonlyMap<Disposable, RecordState>;
+    neverSeen: ReadonlySet<Disposable>;
+    report: TeardownReport;
+}
+/**
+ * Applies `hooks.verifyRemoved` to every record counted removed and every one never seen, a few at
+ * a time: `present` makes a leftover, `absent` clears a never-seen record, `unknown` — or a throw —
+ * leaves teardown's own verdict.
+ */
+export declare function askVerifyHook(hook: NonNullable<UnwindOptions["verifyRemoved"]>, verdicts: Verdicts): Promise<void>;
+//# sourceMappingURL=verify-hook.d.ts.map