@prestack/thread 0.1.3 → 0.1.5

package/dist/operations/generators/seed.js

@@ -1,16 +1,17 @@
-import { existsSync, readFileSync, writeFileSync } from "../../core/files.js";
+import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.js';
 import { dirname, relative, resolve } from 'node:path';
 import { argv, stdout } from 'node:process';
 import { fileURLToPath } from 'node:url';
-import { ROOT, descend, under } from "../../core/descend.js";
-import { runChecker } from "../../core/finding.js";
-import { exit, invoked } from "../../core/invoked.js";
-import { SUPPLIES, supplies } from "../seams.js";
+import ts from 'typescript';
+import { ROOT, descend, under } from '../../core/descend.js';
+import { runChecker } from '../../core/finding.js';
+import { exit, invoked } from '../../core/invoked.js';
+import { PREFIXES } from '../../core/thread.js';
 const COMPILES = 'thread compile';
 const OPERATIONS_ID = 'operations';
 const NODES_ID = 'nodes';
 const NAMED = /\btype:\s*'((?:[^'\\]|\\.)*)'/;
-import { quoted } from "../../core/rows.js";
+import { quoted } from '../../core/rows.js';
 export { quoted };
 const slash = (one) => one.split('\\').join('/');
 export const beside = (from, to) => {
@@ -30,6 +31,7 @@ const FRESH = {
 const SHIPPED = new Set(Object.keys(FRESH));
 const isType = (pass, id) => under(pass, id, NODES_ID);
 const isOurs = (pass, id) => under(pass, id, OPERATIONS_ID);
+const isOperation = (pass, id) => Object.values(PREFIXES).some((one) => id.startsWith(one)) && isOurs(pass, id);
 export function types(pass) {
     const found = new Set(SHIPPED);
     const named = new Set();
@@ -39,7 +41,7 @@ export function types(pass) {
                 named.add(one.row.id);
     }
     for (const one of pass.coined.keys()) {
-        if (one !== NODES_ID && !supplies(one) && !named.has(one) && under(pass, one, NODES_ID))
+        if (one !== NODES_ID && !named.has(one) && under(pass, one, NODES_ID))
             found.add(one);
     }
     return found;
@@ -49,6 +51,7 @@ export function builtFrom(row, known) {
     return found.length === 1 ? found[0] : undefined;
 }
 const reaches = (pass, one) => pass.stated.has(one) && !under(pass, one, NODES_ID);
+const waiting = (held) => held !== undefined && ts.isNumericLiteral(held) ? Number(held.text.replace(/_/g, '')) : undefined;
 export function operations(pass, known) {
     const found = new Map();
     const held = (id) => {
@@ -62,15 +65,16 @@ export function operations(pass, known) {
             takes: [],
             body: undefined,
             wants: new Set(stated?.takes ?? []),
-            requires: asked.filter((one) => supplies(one) || reaches(pass, one)),
-            stray: asked.filter((one) => !supplies(one) && !reaches(pass, one)),
+            requires: asked.filter((one) => reaches(pass, one)),
+            stray: asked.filter((one) => !reaches(pass, one)),
+            timeout: waiting(stated?.fields.get('timeout')),
         };
         found.set(id, made);
         return made;
     };
     for (const [at, threadings] of pass.threaded) {
         for (const one of threadings) {
-            if (one.by === OPERATIONS_ID || !isOurs(pass, one.by) || isType(pass, one.by))
+            if (!isOperation(pass, one.by))
                 continue;
             if (one.list === 'derives' && one.row.by === COMPILES)
                 held(one.by).body = at;
@@ -89,14 +93,14 @@ export const problem = (id, one) => {
     if (one.nodes.length === 0)
         return `\`${id}\` is an operation that seeds no nodes, and an operation is its nodes`;
     if (one.takes.length === 0) {
-        return (`\`${id}\` names nothing it takes, and an operation takes one thing — its input, its estimate and the row it touches. ` +
+        return (`\`${id}\` names nothing it takes, and an operation takes one thing — its input and the row it touches. ` +
             `Write \`takes: ['${id}_takes']\` on its row beside the file that row seeds`);
     }
     if (one.takes.length > 1)
         return `\`${id}\` takes ${String(one.takes.length)} things, and it takes one`;
     if (one.stray.length > 0) {
         return (`\`${id}\` requires ${one.stray.join(', ')}, and dispatch can supply neither a capability nor a target by that ` +
-            `name. What an operation may require is ${SUPPLIES.join(', ')}, or a target this app declares — ` +
+            `name. What an operation may require is a target this app declares — ` +
             'declare one with `thread create target`');
     }
     return undefined;
@@ -104,12 +108,10 @@ export const problem = (id, one) => {
 const takesFile = (at) => [
     "import { z } from 'zod'",
     '',
-    `import type { Row } from ${quoted(runtime(at, '../seams.ts'))}`,
+    'import type { Row } from ' + quoted(runtime(at, '../../integrations/target.ts')),
     '',
     'export const input = z.unknown()',
     '',
-    'export const estimate = 1',
-    '',
     'export const resource = (): Row | null => null',
     '',
     'export type In = z.infer<typeof input>',
@@ -147,9 +149,9 @@ export function nodeText(at, name, takes, from, requires, body) {
 const nodeFile = (at, row, takes, from, requires, body) => nodeText(at, row.id ?? '', takes, from, requires, body);
 const ownType = (at, id) => [
     `import type { Held } from ${quoted(runtime(at, '../nodes.ts'))}`,
-    `import type { Handed, Supplied } from ${quoted(runtime(at, '../seams.ts'))}`,
+    'import type { Opened } from ' + quoted(runtime(at, '../operations.ts')),
     '',
-    'export const node = <I, R extends Supplied = Supplied>(block: (hands: Handed<R>, held: Held<I>) => Promise<unknown>) => ({',
+    'export const node = <I, R extends string = never>(block: (opened: Opened<R>, held: Held<I>) => Promise<unknown>) => ({',
     `  type: ${quoted(id)} as const,`,
     '})',
     '',

package/dist/operations/generators/seed.ts

@@ -1,13 +1,14 @@
-import { existsSync, readFileSync, writeFileSync } from '../../core/files.ts'
+import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
 import { dirname, relative, resolve } from 'node:path'
 import { argv, stdout } from 'node:process'
 import { fileURLToPath } from 'node:url'
 
+import ts from 'typescript'
+
 import { ROOT, descend, under, type Pass, type Row } from '../../core/descend.ts'
 import { runChecker, type Finding } from '../../core/finding.ts'
 import { exit, invoked } from '../../core/invoked.ts'
-
-import { SUPPLIES, supplies, type Supplied } from '../seams.ts'
+import { PREFIXES } from '../../core/thread.ts'
 
 const COMPILES = 'thread compile'
 
@@ -47,6 +48,9 @@ const isType = (pass: Pass, id: string): boolean => under(pass, id, NODES_ID)
 
 const isOurs = (pass: Pass, id: string): boolean => under(pass, id, OPERATIONS_ID)
 
+const isOperation = (pass: Pass, id: string): boolean =>
+  Object.values(PREFIXES).some((one) => id.startsWith(one)) && isOurs(pass, id)
+
 export function types(pass: Pass): ReadonlySet<string> {
   const found = new Set<string>(SHIPPED)
   const named = new Set<string>()
@@ -55,7 +59,7 @@ export function types(pass: Pass): ReadonlySet<string> {
   }
 
   for (const one of pass.coined.keys()) {
-    if (one !== NODES_ID && !supplies(one) && !named.has(one) && under(pass, one, NODES_ID)) found.add(one)
+    if (one !== NODES_ID && !named.has(one) && under(pass, one, NODES_ID)) found.add(one)
   }
   return found
 }
@@ -72,10 +76,15 @@ interface Woven {
 
   readonly requires: readonly string[]
   readonly stray: readonly string[]
+
+  readonly timeout?: number
 }
 
 const reaches = (pass: Pass, one: string): boolean => pass.stated.has(one) && !under(pass, one, NODES_ID)
 
+const waiting = (held: ts.Expression | undefined): number | undefined =>
+  held !== undefined && ts.isNumericLiteral(held) ? Number(held.text.replace(/_/g, '')) : undefined
+
 export function operations(pass: Pass, known: ReadonlySet<string>): ReadonlyMap<string, Woven> {
   const found = new Map<string, Woven & { nodes: Row[]; takes: Row[]; body?: string; wants: ReadonlySet<string> }>()
   const held = (id: string): { nodes: Row[]; takes: Row[]; body?: string; wants: ReadonlySet<string> } => {
@@ -88,8 +97,9 @@ export function operations(pass: Pass, known: ReadonlySet<string>): ReadonlyMap<
       takes: [] as Row[],
       body: undefined as string | undefined,
       wants: new Set(stated?.takes ?? []),
-      requires: asked.filter((one) => supplies(one) || reaches(pass, one)),
-      stray: asked.filter((one) => !supplies(one) && !reaches(pass, one)),
+      requires: asked.filter((one) => reaches(pass, one)),
+      stray: asked.filter((one) => !reaches(pass, one)),
+      timeout: waiting(stated?.fields.get('timeout')),
     }
     found.set(id, made)
     return made
@@ -97,7 +107,7 @@ export function operations(pass: Pass, known: ReadonlySet<string>): ReadonlyMap<
 
   for (const [at, threadings] of pass.threaded) {
     for (const one of threadings) {
-      if (one.by === OPERATIONS_ID || !isOurs(pass, one.by) || isType(pass, one.by)) continue
+      if (!isOperation(pass, one.by)) continue
 
       if (one.list === 'derives' && one.row.by === COMPILES) held(one.by).body = at
       else if (one.list === 'seeds') {
@@ -114,7 +124,7 @@ export const problem = (id: string, one: Woven): string | undefined => {
   if (one.nodes.length === 0) return `\`${id}\` is an operation that seeds no nodes, and an operation is its nodes`
   if (one.takes.length === 0) {
     return (
-      `\`${id}\` names nothing it takes, and an operation takes one thing — its input, its estimate and the row it touches. ` +
+      `\`${id}\` names nothing it takes, and an operation takes one thing — its input and the row it touches. ` +
       `Write \`takes: ['${id}_takes']\` on its row beside the file that row seeds`
     )
   }
@@ -122,7 +132,7 @@ export const problem = (id: string, one: Woven): string | undefined => {
   if (one.stray.length > 0) {
     return (
       `\`${id}\` requires ${one.stray.join(', ')}, and dispatch can supply neither a capability nor a target by that ` +
-      `name. What an operation may require is ${SUPPLIES.join(', ')}, or a target this app declares — ` +
+      `name. What an operation may require is a target this app declares — ` +
       'declare one with `thread create target`'
     )
   }
@@ -133,12 +143,10 @@ const takesFile = (at: string): string =>
   [
     "import { z } from 'zod'",
     '',
-    `import type { Row } from ${quoted(runtime(at, '../seams.ts'))}`,
+    'import type { Row } from ' + quoted(runtime(at, '../../integrations/target.ts')),
     '',
     'export const input = z.unknown()',
     '',
-    'export const estimate = 1',
-    '',
     'export const resource = (): Row | null => null',
     '',
     'export type In = z.infer<typeof input>',
@@ -191,9 +199,9 @@ const nodeFile = (at: string, row: Row, takes: string, from: string, requires: r
 const ownType = (at: string, id: string): string =>
   [
     `import type { Held } from ${quoted(runtime(at, '../nodes.ts'))}`,
-    `import type { Handed, Supplied } from ${quoted(runtime(at, '../seams.ts'))}`,
+    'import type { Opened } from ' + quoted(runtime(at, '../operations.ts')),
     '',
-    'export const node = <I, R extends Supplied = Supplied>(block: (hands: Handed<R>, held: Held<I>) => Promise<unknown>) => ({',
+    'export const node = <I, R extends string = never>(block: (opened: Opened<R>, held: Held<I>) => Promise<unknown>) => ({',
     `  type: ${quoted(id)} as const,`,
     '})',
     '',

package/dist/operations/generators/trial.d.ts

@@ -1,8 +1,9 @@
 import { type Actor } from '../../core/actor.ts';
-import { type ScriptedAnswer } from '../http.ts';
+import { type Call, type Row, type Target } from '../../integrations/target.ts';
+import { type Scripted } from '../../integrations/https.ts';
 import { TRIALS_AT, type Operation } from '../operations.ts';
 import type { Result } from '../result.ts';
-import type { Row, Seams } from '../seams.ts';
+import type { Vault } from '../../integrations/secret.ts';
 export { TRIALS_AT };
 export interface Scenario {
     readonly id: string;
@@ -13,8 +14,9 @@ export interface Scenario {
         readonly entity: string;
         readonly row: Row;
     }[];
-    readonly answers?: Readonly<Record<string, ScriptedAnswer>>;
+    readonly answers?: Readonly<Record<string, Scripted>>;
     readonly views?: Readonly<Record<string, readonly unknown[]>>;
+    readonly files?: Readonly<Record<string, string>>;
 }
 export interface Trial {
     readonly operation: string;
@@ -23,7 +25,6 @@ export interface Trial {
     readonly measured: boolean;
     readonly result: unknown;
     readonly kept: unknown;
-    readonly observed: unknown;
     readonly called: unknown;
 }
 export interface Outcome {
@@ -40,10 +41,7 @@ export interface Run {
     readonly failed: number;
     readonly measured: number;
 }
-export declare function runScenario(one: Operation<unknown>, scenario: Scenario, dispatch: (operation: Operation<unknown>, input: unknown, actor: Actor, seams: Seams) => Promise<Result<unknown>>, stood?: Readonly<Record<string, string>>, gate?: NonNullable<Seams['permits']>, known?: {
-    readonly entities: ReadonlyMap<string, ReadonlySet<string>>;
-    readonly keys: ReadonlyMap<string, string>;
-}): Promise<Trial>;
+export declare function runScenario(one: Operation<unknown>, scenario: Scenario, dispatch: (operation: Operation<unknown>, input: unknown, actor: Actor, opened: Readonly<Record<string, unknown>>, opening: Vault) => Promise<Result<unknown>>, stood?: Readonly<Record<string, string>>, targets?: readonly Target[], calls?: readonly Call[]): Promise<Trial | string>;
 export declare function scenariosFor(one: Operation<unknown>, takes: string, granted?: readonly string[]): Promise<readonly Scenario[] | string>;
 export declare function compared(was: readonly Trial[], now: readonly Trial[]): Run;
 export declare function unproven(run: Run): readonly string[];

package/dist/operations/generators/trial.js

@@ -6,21 +6,21 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { existsSync, readFileSync, writeFileSync } from "../../core/files.js";
+import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.js';
 import { resolve } from 'node:path';
 import { argv, stdout } from 'node:process';
 import { pathToFileURL } from 'node:url';
-import { ANONYMOUS } from "../../core/actor.js";
-import { ROOT, TREE, descend } from "../../core/descend.js";
-import { exit, invoked } from "../../core/invoked.js";
-import { recordingHttp } from "../http.js";
-import { inMemorySeams } from "../memory.js";
-import { TRIALS_AT } from "../operations.js";
-import { PERMITS_AT } from "../access.js";
-import { operations, types } from "./seed.js";
+import { ANONYMOUS } from '../../core/actor.js';
+import { ROOT, descend } from '../../core/descend.js';
+import { exit, invoked } from '../../core/invoked.js';
+import { reachOf, standsHere } from '../../integrations/target.js';
+import { recordingHttp } from '../../integrations/https.js';
+import { standing } from '../../integrations/pglite.js';
+import { TRIALS_AT } from '../operations.js';
+import { PERMITS_AT } from '../access.js';
+import { operations, types } from './seed.js';
 export { TRIALS_AT };
 const DISPATCH_AT = 'operations/_dispatch.ts';
-const ENTITIES_AT = `${TREE}entities.ts`;
 const ACCESS_AT = '_threads/access.ts';
 const WHEN = 1_767_225_600_000;
 const compare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
@@ -51,68 +51,191 @@ const asking = (scenario) => ({
     ...(scenario.actor ?? ANONYMOUS),
     run: 'trial',
     replay: `trial_${scenario.id}`,
+    moment: new Date(WHEN).toISOString(),
 });
-function seamsFor(one, scenario, stood, gate, known) {
-    const made = inMemorySeams({
-        secrets: stood,
-        ...(scenario.views === undefined ? {} : { views: scenario.views }),
-        ...(known === undefined ? {} : { entities: known.entities, keys: known.keys }),
-    });
-    const found = made.seams;
-    if (gate !== undefined)
-        found['permits'] = gate;
-    found['clock'] = { now: () => WHEN };
-    let drawn = 0;
-    found['random'] = {
-        next: () => {
-            drawn += 1;
-            return drawn / 100;
+function programmed(word, names) {
+    const made = {};
+    for (const order of names) {
+        made[order] = () => {
+            throw new Error(word + ' was asked to run ' + order + ', and this scenario says nothing about what that did. A trial stands a ' +
+                'disk up out of the files its scenario states, and there is nowhere yet to state what a program or a package answered, so ' +
+                'a scenario cannot give either an order. This says that rather than inventing a result for one.');
+        };
+    }
+    return made;
+}
+function packaged(word, names, script, into) {
+    const spent = new Map();
+    const made = {};
+    for (const name of names) {
+        made[name] = async (given) => {
+            const key = word + ' ' + name;
+            into.push({ target: word, method: 'CALL', path: name, headers: {}, body: JSON.stringify(stable(given ?? null)) });
+            const held = script[key];
+            if (held === undefined) {
+                throw new Error('this scenario scripts no answer for "' + key + '", so nothing here knows what ' + word + ' would hand back. Add ' +
+                    'that key to the scenario\'s answers, with what the call returns written as JSON in its body.');
+            }
+            const each = Array.isArray(held) ? held : undefined;
+            const at = spent.get(key) ?? 0;
+            spent.set(key, at + 1);
+            const answer = each === undefined ? held : each[at];
+            if (answer === undefined) {
+                throw new Error('this scenario scripts ' + String(each?.length ?? 0) + ' answer(s) for "' + key + '" and it has now been called ' +
+                    String(at + 1) + ' time(s). A node that calls the same thing again needs one answer per call, in the order they come back.');
+            }
+            if (answer.status !== 200)
+                throw new Error(answer.body ?? word + ' ' + name + ' failed with ' + String(answer.status));
+            return answer.body === undefined ? undefined : JSON.parse(answer.body);
+        };
+    }
+    return made;
+}
+function disked(files) {
+    const held = new Map(Object.entries(files));
+    const under = (at) => [...held.keys()].some((one) => one.startsWith(at + '/'));
+    const gone = (at) => new Error(at + ' is not in this scenario, and a trial answers a file order against the files its scenario states');
+    return {
+        kind: (at) => (held.has(at) ? 'file' : under(at) ? 'folder' : 'none'),
+        read: (at) => {
+            const said = held.get(at);
+            if (said === undefined)
+                throw gone(at);
+            return said;
+        },
+        write: (at, said) => {
+            held.set(at, said);
+        },
+        list: (at) => {
+            const inside = new Map();
+            for (const one of held.keys()) {
+                if (!one.startsWith(at + '/'))
+                    continue;
+                const rest = one.slice(at.length + 1);
+                const cut = rest.indexOf('/');
+                const name = cut === -1 ? rest : rest.slice(0, cut);
+                inside.set(name, { name, kind: cut === -1 ? 'file' : 'folder' });
+            }
+            return [...inside.values()];
+        },
+        stat: (at) => {
+            const said = held.get(at);
+            if (said === undefined)
+                throw gone(at);
+            return { size: said.length, modified: 0 };
         },
-        uuid: () => {
-            drawn += 1;
-            return `00000000-0000-4000-8000-${String(drawn).padStart(12, '0')}`;
+        remove: (at) => {
+            held.delete(at);
         },
+        real: (at) => at,
     };
+}
+function vaulting(stood) {
+    return {
+        async resolve(refs) {
+            const found = {};
+            for (const ref of refs) {
+                const value = stood[ref];
+                if (value === undefined) {
+                    throw new Error(ref + ' is not a secret this app declares, so a trial has nothing to stand in for it. Declare it with ' +
+                        '`thread create secret`, or stop requiring the target that asks for it.');
+                }
+                found[ref] = value;
+            }
+            return found;
+        },
+    };
+}
+async function standingStore(row) {
+    const said = row.derives?.find((each) => each.id === row.id + '_store')?.at;
+    if (said === undefined) {
+        return row.id + ' keeps rows and its row derives no store, so a trial has nothing to stand up. Run `thread schema`';
+    }
+    const at = resolve(ROOT, said);
+    if (!existsSync(at))
+        return said + ' is not there, so ' + row.id + ' cannot be stood up. Run `thread schema`';
+    const made = (await import(__rewriteRelativeImportExtension(pathToFileURL(at).href)));
+    const held = made.kept;
+    if (held === undefined) {
+        return said + ' says nothing about what ' + row.id + ' keeps or with what schema. Run `thread schema`';
+    }
+    return standing(held);
+}
+async function openedFor(one, scenario, stood, targets = [], calls = []) {
     const recorder = recordingHttp(scenario.answers ?? {});
-    found['http'] = recorder;
-    return { seams: made.seams, sink: made.sink, kept: () => made.store, calls: () => recorder.calls };
+    const packages = [];
+    const opening = vaulting(stood);
+    const opened = {};
+    const stores = [];
+    const answering = (row) => calls.filter((each) => each.of === row.id && row.takes.includes(each.id)).map((each) => each.id.replace(/^cl_/, ''));
+    for (const word of one.requires) {
+        const row = targets.find((each) => each.id === word);
+        if (row === undefined || !standsHere(row, targets))
+            continue;
+        const reach = reachOf(row.id);
+        if (reach === 'disk')
+            opened[word] = disked(scenario.files ?? {});
+        else if (reach === 'cli')
+            opened[word] = programmed(word, answering(row));
+        else if (reach === 'https')
+            opened[word] = recorder;
+        else if (reach === 'sdk')
+            opened[word] = packaged(word, answering(row), scenario.answers ?? {}, packages);
+        else {
+            const held = await standingStore(row);
+            if (typeof held === 'string')
+                return held;
+            opened[word] = held.store;
+            stores.push(held);
+        }
+    }
+    return { opened, opening, stores, calls: () => [...recorder['calls'], ...packages] };
 }
-function entered(sink) {
-    return sink.logs.some((one) => {
-        const data = one.data;
-        return data !== undefined && 'observability' in data;
-    });
+const BEFORE = new Set(['denied', 'invalid']);
+function entered(result) {
+    if (typeof result !== 'object' || result === null)
+        return false;
+    const held = result;
+    if (held.ok === true)
+        return true;
+    return held.ok === false && !BEFORE.has(String(held.code));
 }
 function denied(result) {
     if (typeof result !== 'object' || result === null)
         return false;
     const held = result;
-    return held.ok === false && held.code === 'denied';
+    return held.ok === false && BEFORE.has(String(held.code));
 }
-export async function runScenario(one, scenario, dispatch, stood = {}, gate, known) {
-    const made = seamsFor(one, scenario, stood, gate, known);
+export async function runScenario(one, scenario, dispatch, stood = {}, targets = [], calls = []) {
+    const made = await openedFor(one, scenario, stood, targets, calls);
+    if (typeof made === 'string')
+        return made;
     const actor = asking(scenario);
-    for (const seeded of scenario.rows ?? []) {
-        const held = made.seams.store;
-        if (held === undefined)
-            throw new Error(String(seeded.entity) + " cannot be seeded: these seams keep no rows");
-        await held.insert(actor, seeded.entity, seeded.row);
+    for (const each of scenario.rows ?? []) {
+        const held = made.stores.find((store) => store.keeps.includes(each.entity));
+        if (held === undefined) {
+            return ('`' + one.id + '` is tried with a row of "' + each.entity + '" and no target it requires keeps that entity, ' +
+                'so there is nowhere to put it. Require the target that keeps it, or take that row off the scenario');
+        }
+        await held.seed(actor, [each]);
     }
     let result;
     try {
-        result = await dispatch(one, scenario.input, actor, made.seams);
+        result = await dispatch(one, scenario['input'], actor, made.opened, made.opening);
     }
     catch (thrown) {
         result = { threw: thrown instanceof Error ? thrown.message : String(thrown) };
     }
+    const kept = {};
+    for (const held of made.stores)
+        Object.assign(kept, await held.taken(actor));
     return {
         operation: one.id,
         scenario: scenario.id,
         refused: denied(result),
-        measured: entered(made.sink),
+        measured: entered(result),
         result,
-        kept: made.kept(),
-        observed: made.sink,
+        kept,
         called: made.calls(),
     };
 }
@@ -157,14 +280,14 @@ export function compared(was, now) {
                 `measured and no refusal was proven either. What it answered was ${JSON.stringify(one.result)}`);
         }
         if (one.refused && one.measured) {
-            failures.push('this app\'s own gate denied the caller and the run REACHED THE OPERATION anyway — dispatch let a ' +
-                'denied request through to the compiled function, which is the gate not holding rather than a trial drifting');
+            failures.push('this run was refused before the operation could start and REACHED THE OPERATION anyway — dispatch let a ' +
+                'refused request through to the compiled function, which is the gate not holding rather than a trial drifting');
         }
         if (older === undefined) {
             failures.push('no trial holds this scenario. Run `thread trials` and commit the result');
         }
         else {
-            for (const part of ['result', 'kept', 'observed']) {
+            for (const part of ['result', 'kept', 'called']) {
                 const then = printed(older[part]);
                 const said = printed(one[part]);
                 if (then === said)
@@ -219,7 +342,7 @@ export function unproven(run) {
         const how = [
             denied === 0
                 ? ''
-                : `${String(denied)} were denied by this app's own gate, which proves the gate turns somebody away and nothing whatever about the operation`,
+                : `${String(denied)} were refused before the operation could start — by the gate, or because what they were given is not what it takes — which proves the refusal and nothing whatever about the operation`,
             neither === 0 ? '' : `${String(neither)} neither reached it nor were denied`,
         ].filter((one) => one !== '');
         said.push(`\`${operation}\` is UNPROVEN — ${String(outcomes.length)} scenario(s) ran and not one of them reached it: ${how.join(', and ')}. ` +
@@ -227,7 +350,7 @@ export function unproven(run) {
     }
     return said;
 }
-async function standing() {
+async function standIns() {
     const at = resolve(ROOT, '_threads/secrets.ts');
     if (!existsSync(at))
         return {};
@@ -243,10 +366,24 @@ async function standing() {
     }
     const found = {};
     for (const one of held) {
-        found[one.id] = one.sends === undefined ? `https://${one.id.replace(/_/g, '-')}.invalid` : `${one.id}-stood-in-for`;
+        found[one.id] = one.sends === undefined && one.signs === undefined ? `https://${one.id.replace(/_/g, '-')}.invalid` : `${one.id}-stood-in-for`;
     }
     return found;
 }
+async function reaching() {
+    const at = resolve(ROOT, '_threads/targets.ts');
+    if (!existsSync(at))
+        return { targets: [], calls: [] };
+    try {
+        const taken = (await import(__rewriteRelativeImportExtension(pathToFileURL(at).href)));
+        return { targets: taken.TARGETS ?? [], calls: taken.CALLS ?? [] };
+    }
+    catch (thrown) {
+        return (`_threads/targets.ts is there and could not be read: ${thrown instanceof Error ? thrown.message : String(thrown)}. ` +
+            'Which disk a trial hands an operation is read from that sheet, so every trial would run with no disk at all and ' +
+            'the failures would name the operation instead of the sheet');
+    }
+}
 export async function record() {
     const pass = descend();
     const known = types(pass);
@@ -255,9 +392,13 @@ export async function record() {
     const declared = [...operations(pass, known)].filter(([, one]) => one.body !== undefined);
     if (declared.length === 0)
         return { trials: [], refusals: [] };
-    const stood = await standing();
+    const stood = await standIns();
     if (typeof stood === 'string')
         return { trials: [], refusals: [stood] };
+    const reached = await reaching();
+    if (typeof reached === 'string')
+        return { trials: [], refusals: [reached] };
+    const { targets, calls } = reached;
     const at = resolve(ROOT, DISPATCH_AT);
     if (!existsSync(at)) {
         return {
@@ -272,18 +413,6 @@ export async function record() {
     if (dispatch === undefined) {
         return { trials: [], refusals: [`${DISPATCH_AT} exports no \`dispatch\`, so nothing here can run an operation`] };
     }
-    const kept = resolve(ROOT, ENTITIES_AT);
-    const entities = new Map();
-    const keys = new Map();
-    if (existsSync(kept)) {
-        const sheet = (await import(__rewriteRelativeImportExtension(pathToFileURL(kept).href)));
-        for (const one of sheet.ENTITIES ?? []) {
-            entities.set(one.id, new Set([...(one.holds ?? []).map((each) => each.id), ...(one.links ?? []).map((each) => `${each.id}_id`)]));
-            const named = (one.must ?? []).flatMap((each) => (each.unique?.length === 1 ? [each.unique[0]] : []));
-            if (named.length === 1)
-                keys.set(one.id, named[0]);
-        }
-    }
     const permitted = resolve(ROOT, ACCESS_AT);
     const may = new Map();
     if (existsSync(permitted)) {
@@ -304,9 +433,6 @@ export async function record() {
             refusals: [`${PERMITS_AT} exports no \`permits\`, so a trial cannot be answered by the gate this app derives`],
         };
     }
-    const gate = permits === undefined
-        ? undefined
-        : { check: (actor, action, resource) => Promise.resolve(permits(actor, action, resource)) };
     for (const [id, one] of [...declared].sort((a, b) => compare(a[0], b[0]))) {
         if (one.body === undefined)
             continue;
@@ -332,7 +458,11 @@ export async function record() {
             continue;
         }
         for (const scenario of scenarios) {
-            trials.push(await runScenario(operation, scenario, dispatch, stood, gate, { entities, keys }));
+            const ran = await runScenario(operation, scenario, dispatch, stood, targets, calls);
+            if (typeof ran === 'string')
+                refusals.push(ran);
+            else
+                trials.push(ran);
         }
     }
     return { trials, refusals };