@prestack/thread 0.0.1

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

@@ -0,0 +1 @@
+export {};

package/dist/operations/generators/permits.js

@@ -0,0 +1,196 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { argv, stderr, stdout } from 'node:process';
+import { pathToFileURL } from 'node:url';
+import { exit } from "../../core/invoked.js";
+import { PUBLIC_ROLE as PUBLIC } from "../../core/actor.js";
+import { ROOT, descend } from "../../core/descend.js";
+import { forbids, runChecker } from "../../core/finding.js";
+import { findTree, inTree } from "../../core/tree.js";
+import { PERMITS_AT, grantedTwice, opensToEverybody, unanswerable } from "../access.js";
+import { DECLARED_SEAMS_AT } from "../capabilities.js";
+import { operations as woven, runtime, types } from "./seed.js";
+function stop(why) {
+    stderr.write(`permits: ${why}\n`);
+    exit(1);
+}
+const CHECKING = argv.includes('--check');
+const pass = await descend();
+const stopped = [...pass.broken, ...pass.findings].filter(forbids)[0];
+if (stopped !== undefined) {
+    stop('the descent is broken, so who may ask for what is only partly known, and a gate written from half of it ' +
+        `would permit callers nobody granted — ${stopped.detail} (${stopped.file ?? ''})`);
+}
+async function taken(file, name, what) {
+    const at = inTree(findTree(), file);
+    if (!existsSync(at))
+        stop(`${at} is where this app states ${what}, and it is not there`);
+    let held;
+    try {
+        held = (await import(__rewriteRelativeImportExtension(pathToFileURL(at).href)));
+    }
+    catch (thrown) {
+        stop(`${at} could not be read: ${thrown instanceof Error ? thrown.message : String(thrown)}. A tree whose access ` +
+            'cannot be read reports exactly like a tree that granted nothing, and a gate written from that would refuse ' +
+            'every caller rather than say so');
+    }
+    const list = held[name];
+    if (!Array.isArray(list))
+        stop(`${at} exports no \`${name}\` list, so nothing there states ${what}`);
+    return list;
+}
+const grants = await taken('access.ts', 'GRANTS', 'who may ask for what');
+const operations = [...woven(pass, types(pass))].map(([id]) => ({
+    id,
+    describes: pass.stated.get(id)?.describes ?? '',
+}));
+for (const found of [unanswerable(grants)]) {
+    if (found.length > 0)
+        stop(found.join('; '));
+}
+const twice = grantedTwice(grants);
+if (twice.length > 0) {
+    stop(`${twice.map((one) => `\`${one}\``).join(', ')} ${twice.length === 1 ? 'is granted' : 'are granted'} more than once, ` +
+        'so two arms answer to one id and either may permit. One id, one policy — rename one of them, or delete the ' +
+        'arm that is not meant to stand');
+}
+const open = opensToEverybody(grants);
+if (open.length > 0) {
+    stop(`${open.map((one) => `\`${one.id}\``).join(', ')} names no roles or entitlements and states no condition that ` +
+        'reads the caller, so who may run this is left unsaid rather than decided. If it is meant to be open, say so: ' +
+        `\`to: { roles: ['${PUBLIC}'] }\` is the role an unauthenticated caller already wears, and naming it puts ` +
+        'that decision in the sheet. Otherwise name the roles that may, or state a `when` saying whose row it is');
+}
+const said = (held) => JSON.stringify(held);
+function reads(one, grant) {
+    if ('value' in one)
+        return said(one.value);
+    if ('now' in one)
+        return 'Date.now()';
+    if ('ago' in one) {
+        const size = Number(one.ago.slice(0, -1));
+        const unit = one.ago.slice(-1);
+        const seconds = size * (unit === 's' ? 1 : unit === 'm' ? 60 : unit === 'h' ? 3_600 : 86_400);
+        return `(Date.now() - ${String(seconds * 1000)})`;
+    }
+    if ('actor' in one)
+        return `actor.${one.actor}`;
+    if ('field' in one) {
+        if (grant.on === undefined) {
+            stop(`\`${grant.id}\` reads the field "${one.field}" and names no entity in \`on\`, so there is nothing saying what ` +
+                'the row in front of the gate is. Name the entity the resource is, or state the rule without reading a field');
+        }
+        if (one.field.includes('.')) {
+            stop(`\`${grant.id}\` reads "${one.field}", which reaches through a link. The gate is handed one row and has ` +
+                'nothing to follow a link with — name a value of "' +
+                grant.on +
+                '" itself, or state the rule as an invariant where the rows are');
+        }
+        return `at(resource, ${said(one.field)})`;
+    }
+    stop(`\`${grant.id}\` states an operand this gate cannot read`);
+}
+function predicate(condition, grant) {
+    if ('all' in condition) {
+        return condition.all.length === 0 ? 'true' : `(${condition.all.map((one) => predicate(one, grant)).join(' && ')})`;
+    }
+    if ('any' in condition) {
+        return condition.any.length === 0 ? 'false' : `(${condition.any.map((one) => predicate(one, grant)).join(' || ')})`;
+    }
+    if ('not' in condition)
+        return `(!${predicate(condition.not, grant)})`;
+    return `held(${said(condition.op)}, ${reads(condition.is, grant)}, ${reads(condition.than, grant)})`;
+}
+function wears(grant) {
+    const held = [];
+    const roles = grant.to?.roles;
+    if (roles !== undefined && !roles.includes(PUBLIC))
+        held.push(`some(actor.roles, ${said(roles)})`);
+    if (grant.to?.entitlements !== undefined)
+        held.push(`some(actor.entitlements, ${said(grant.to.entitlements)})`);
+    return held;
+}
+const READS = ['const at = (row: Row | null, name: string): unknown => (row === null ? undefined : row[name])'];
+const WEARS = [
+    'const some = (worn: readonly string[], named: readonly string[]): boolean => named.some((one) => worn.includes(one))',
+];
+const COMPARES = [
+    'const held = (op: string, left: unknown, right: unknown): boolean => {',
+    '  if (op === \'in\') return Array.isArray(right) && right.includes(left)',
+    '  if (op === \'has\') return Array.isArray(left) && left.includes(right)',
+    '  if (op === \'eq\') return left === right',
+    '  if (op === \'neq\') return left !== right',
+    '  if (typeof left !== typeof right) return false',
+    '  if (typeof left !== \'number\' && typeof left !== \'string\') return false',
+    '  const other = right as number | string',
+    '  if (op === \'lt\') return left < other',
+    '  if (op === \'lte\') return left <= other',
+    '  if (op === \'gt\') return left > other',
+    '  return left >= other',
+    '}',
+];
+function permitting() {
+    const arms = grants.flatMap((one) => {
+        const parts = [...wears(one), ...(one.when === undefined ? [] : [predicate(one.when, one)])];
+        return [
+            `  if (${said(one.may)}.includes(action)) {`,
+            `    if (${parts.length === 0 ? 'true' : parts.join(' && ')}) return { allow: true, because: ${said(one.describes)} }`,
+            `    denied.push(${said(one.describes)})`,
+            '  }',
+        ];
+    });
+    const body = grants.length === 0
+        ? [
+            '  return {',
+            '    allow: false,',
+            "    because: 'this app declares no grants, so nothing permits any operation. Declare one with `thread grant`',",
+            '  }',
+        ]
+        : [
+            '  const denied: string[] = []',
+            ...arms,
+            '  return { allow: false, because: denied[0] ?? `nothing granted permits ${action}` }',
+        ];
+    return [
+        `import type { Actor } from '${runtime(PERMITS_AT, '../../core/actor.ts')}'`,
+        `import type { Row } from '${runtime(PERMITS_AT, '../seams.ts')}'`,
+        '',
+        ...(grants.some((one) => one.when !== undefined) ? [...READS, ''] : []),
+        ...(grants.some((one) => one.to !== undefined) ? [...WEARS, ''] : []),
+        ...(grants.some((one) => one.when !== undefined) ? [...COMPARES, ''] : []),
+        'export function permits(actor: Actor, action: string, resource: Row | null): { allow: boolean; because?: string } {',
+        ...(grants.length === 0 ? ['  void actor', '  void resource'] : []),
+        ...body,
+        '}',
+        '',
+    ].join('\n');
+}
+const RUNS = 'thread permits';
+const permitted = resolve(ROOT, PERMITS_AT);
+const content = permitting();
+const count = `${String(grants.length)} grant(s) over ${String(operations.length)} operation(s)`;
+if (CHECKING) {
+    const findings = [];
+    const current = existsSync(permitted) ? readFileSync(permitted, 'utf8') : '';
+    if (current !== content) {
+        findings.push({
+            file: PERMITS_AT,
+            detail: 'is not what this app grants',
+            instead: `run \`${RUNS}\` and commit what it writes. Never edit this file — a branch here exists because a grant was declared, and an edit widens or narrows access nobody agreed to`,
+        });
+    }
+    runChecker('permits', findings, count);
+    exit(findings.length === 0 ? 0 : 1);
+}
+mkdirSync(dirname(permitted), { recursive: true });
+writeFileSync(permitted, content);
+stdout.write(`permits: wrote ${PERMITS_AT} — ${count}. ${DECLARED_SEAMS_AT} hands it to dispatch as the gate every operation passes; ` +
+    '`thread grant` adds a grant, and a refusal no grant can say is an invariant on the entity, or a rule from `thread create rule`.\n');

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

@@ -0,0 +1,20 @@
+import { type Pass, type Row } from '../../core/descend.ts';
+import { quoted } from '../../core/rows.ts';
+export { quoted };
+export declare const beside: (from: string, to: string) => string;
+export declare const runtime: (at: string, file: string) => string;
+export declare function types(pass: Pass): ReadonlySet<string>;
+export declare function builtFrom(row: Row, known: ReadonlySet<string>): string | undefined;
+interface Woven {
+    readonly nodes: readonly Row[];
+    readonly takes: readonly Row[];
+    readonly body?: string;
+    readonly requires: readonly string[];
+    readonly stray: readonly string[];
+}
+export declare function operations(pass: Pass, known: ReadonlySet<string>): ReadonlyMap<string, Woven>;
+export declare const problem: (id: string, one: Woven) => string | undefined;
+export declare function blockIn(text: string): string | undefined;
+export declare function scaffold(from: string, name: string): string;
+export declare function nodeText(at: string, name: string, takes: string, from: string, requires: readonly string[], body?: string): string;
+export declare function seed(bodies?: ReadonlyMap<string, string>, say?: boolean): number;

package/dist/operations/generators/seed.js

@@ -0,0 +1,285 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+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";
+const COMPILES = 'thread compile';
+const OPERATIONS_ID = 'operations';
+const NODES_ID = 'nodes';
+const NAMED = /\btype:\s*'((?:[^'\\]|\\.)*)'/;
+import { quoted } from "../../core/rows.js";
+export { quoted };
+const slash = (one) => one.split('\\').join('/');
+export const beside = (from, to) => {
+    const said = slash(relative(dirname(from), to));
+    return said.startsWith('.') ? said : `./${said}`;
+};
+export const runtime = (at, file) => beside(resolve(ROOT, at), fileURLToPath(new URL(file, import.meta.url)));
+const FRESH = {
+    nd_read: (throws) => `async () => {\n  ${throws}\n}`,
+    nd_action: (throws) => `async () => {\n  ${throws}\n}`,
+    nd_stop: (throws) => `async () => {\n  ${throws}\n}`,
+    nd_each: (throws) => `() => [], async () => {\n  ${throws}\n}`,
+    nd_repeat: (throws) => `1, async (pass, carried) => {\n  ${throws}\n}`,
+    nd_parallel: (throws) => `[\n  async () => {\n    ${throws}\n  },\n]`,
+    nd_branch: (throws) => `async () => 'one', {\n  one: async () => {\n    ${throws}\n  },\n}`,
+};
+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);
+export function types(pass) {
+    const found = new Set(SHIPPED);
+    const named = new Set();
+    for (const threadings of pass.threaded.values()) {
+        for (const one of threadings)
+            if (one.row.id !== undefined)
+                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))
+            found.add(one);
+    }
+    return found;
+}
+export function builtFrom(row, known) {
+    const found = (row.requires ?? []).filter((one) => known.has(one));
+    return found.length === 1 ? found[0] : undefined;
+}
+const reaches = (pass, one) => pass.stated.has(one) && !under(pass, one, NODES_ID);
+export function operations(pass, known) {
+    const found = new Map();
+    const held = (id) => {
+        const one = found.get(id);
+        if (one !== undefined)
+            return one;
+        const stated = pass.stated.get(id);
+        const asked = stated?.requires ?? [];
+        const made = {
+            nodes: [],
+            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)),
+        };
+        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))
+                continue;
+            if (one.list === 'derives' && one.row.by === COMPILES)
+                held(one.by).body = at;
+            else if (one.list === 'seeds') {
+                const mine = held(one.by);
+                if (mine.wants.has(one.row.id ?? ''))
+                    mine.takes.push(one.row);
+                else
+                    mine.nodes.push(one.row);
+            }
+        }
+    }
+    return found;
+}
+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. ` +
+            `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 — ` +
+            'declare one with `thread create target`');
+    }
+    return undefined;
+};
+const takesFile = (at) => [
+    "import { z } from 'zod'",
+    '',
+    `import type { Row } from ${quoted(runtime(at, '../seams.ts'))}`,
+    '',
+    'export const input = z.unknown()',
+    '',
+    'export const estimate = 1',
+    '',
+    'export const resource = (): Row | null => null',
+    '',
+    'export type In = z.infer<typeof input>',
+    '',
+].join('\n');
+const OPENS = 'export const node = ';
+export function blockIn(text) {
+    const at = text.indexOf(OPENS);
+    if (at === -1)
+        return undefined;
+    const open = text.indexOf('(', at);
+    const shut = text.lastIndexOf(')');
+    if (open === -1 || shut <= open)
+        return undefined;
+    return text.slice(open + 1, shut);
+}
+export function scaffold(from, name) {
+    const throws = `throw new Error(${quoted(`the node ${name} was scaffolded and never written`)})`;
+    return (FRESH[from] ?? ((one) => `async () => {\n  ${one}\n}`))(throws);
+}
+export function nodeText(at, name, takes, from, requires, body) {
+    const held = SHIPPED.has(from)
+        ? `import { ${from} } from ${quoted(runtime(at, '../nodes.ts'))}`
+        : `import { node as ${from} } from ${quoted(beside(at, `nodes/${from}.ts`))}`;
+    const only = requires.length === 0 ? 'never' : requires.map((one) => quoted(one)).join(' | ');
+    return [
+        held,
+        '',
+        `import type { In } from ${quoted(beside(at, takes))}`,
+        '',
+        `${OPENS}${from}<In, ${only}>(${body ?? scaffold(from, name)})`,
+        '',
+    ].join('\n');
+}
+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'))}`,
+    '',
+    'export const node = <I, R extends Supplied = Supplied>(block: (hands: Handed<R>, held: Held<I>) => Promise<unknown>) => ({',
+    `  type: ${quoted(id)} as const,`,
+    '})',
+    '',
+].join('\n');
+function planned(bodies) {
+    const pass = descend();
+    const known = types(pass);
+    const mine = operations(pass, known);
+    const found = [];
+    for (const [id, one] of mine) {
+        void id;
+        for (const row of one.takes)
+            if (row.at !== undefined)
+                found.push({ at: row.at, derived: false, text: takesFile(row.at) });
+        for (const row of one.nodes) {
+            const from = builtFrom(row, known);
+            const takes = one.takes[0]?.at;
+            if (row.at === undefined || from === undefined || takes === undefined)
+                continue;
+            const path = resolve(ROOT, row.at);
+            const held = existsSync(path) ? readFileSync(path, 'utf8') : undefined;
+            const block = bodies.get(row.at) ?? (held === undefined ? undefined : blockIn(held));
+            if (held !== undefined && block === undefined) {
+                found.push({
+                    at: row.at,
+                    derived: true,
+                    because: `\`${String(row.id)}\` states no \`${OPENS}\` this can read, so the block it holds cannot be told from the ` +
+                        'wrapper its rows own. Delete the file and run `thread seed` to scaffold it again, then write the block back into it',
+                });
+                continue;
+            }
+            found.push({ at: row.at, derived: true, wraps: String(row.id), text: nodeFile(row.at, row, takes, from, one.requires, block) });
+        }
+    }
+    for (const [at, threadings] of pass.threaded) {
+        for (const one of threadings) {
+            if (one.list !== 'seeds' || !isType(pass, one.by) || SHIPPED.has(one.by))
+                continue;
+            found.push({ at, derived: false, text: ownType(at, one.by), type: one.by });
+        }
+    }
+    return found;
+}
+function checked(plan) {
+    const findings = plan.flatMap((one) => {
+        const path = resolve(ROOT, one.at);
+        if (one.because !== undefined) {
+            return [
+                {
+                    file: one.at,
+                    detail: one.because,
+                    instead: 'declare it properly — this file is written from those rows and cannot be written without them',
+                },
+            ];
+        }
+        if (!existsSync(path)) {
+            return [
+                {
+                    file: one.at,
+                    detail: 'a row declares this file and nothing is there',
+                    instead: 'run `thread seed` and write what it leaves — a row that seeded nothing is half a declaration',
+                },
+            ];
+        }
+        if (one.type !== undefined) {
+            const said = NAMED.exec(readFileSync(path, 'utf8'))?.[1];
+            if (said === one.type)
+                return [];
+            return [
+                {
+                    file: one.at,
+                    detail: said === undefined
+                        ? `\`${one.type}\` seeds this type and the file states no name of its own`
+                        : `\`${one.type}\` seeds this type and the file calls itself \`${said}\``,
+                    instead: "state the row's own id as the type's name. A node declares which type it is built from, and the compiler holds the two together by that name",
+                },
+            ];
+        }
+        if (!one.derived)
+            return [];
+        if (readFileSync(path, 'utf8') === one.text)
+            return [];
+        if (one.wraps !== undefined) {
+            return [
+                {
+                    file: one.at,
+                    detail: `the line that opens \`${one.wraps}\` is written from its rows, and this is no longer the bytes they write`,
+                    instead: 'run `thread seed`. Which type builds this node and what its operation lets it touch are the rows to say, not this line — the block inside the call is yours and is put back exactly as you left it',
+                },
+            ];
+        }
+        return [
+            {
+                file: one.at,
+                detail: 'this operation derives its body, and this is no longer the bytes that derive it',
+                instead: 'run `thread seed`, or put back what it writes. A derived body has no author: to change what an operation does, change the rows that declare its nodes, and to change what a node does, write it in the file that node seeds',
+            },
+        ];
+    });
+    runChecker('seed', findings, `${String(plan.length)} file(s) declared`);
+    exit(findings.length === 0 ? 0 : 1);
+}
+export function seed(bodies = new Map(), say = true) {
+    const plan = planned(bodies);
+    let written = 0;
+    for (const one of plan) {
+        const path = resolve(ROOT, one.at);
+        const held = existsSync(path) ? readFileSync(path, 'utf8') : undefined;
+        if (held !== undefined && !one.derived && !bodies.has(one.at))
+            continue;
+        if (one.text === undefined) {
+            if (say)
+                stdout.write(`seed: ${one.at} was not written — ${one.because ?? 'the rows behind it are incomplete'}\n`);
+            continue;
+        }
+        if (held === one.text)
+            continue;
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, one.text, 'utf8');
+        written += 1;
+        if (say)
+            stdout.write(`seed: wrote ${one.at}\n`);
+    }
+    if (say)
+        stdout.write(`seed: ${String(written)} of ${String(plan.length)} file(s) written, ${String(plan.length - written)} already as declared.\n`);
+    return written;
+}
+if (invoked(import.meta.url)) {
+    if (argv.includes('--check'))
+        checked(planned(new Map()));
+    else
+        seed();
+}

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

@@ -0,0 +1,53 @@
+import { type Actor } from '../../core/actor.ts';
+import { type ScriptedAnswer } from '../http.ts';
+import { TRIALS_AT, type Operation } from '../operations.ts';
+import type { Result } from '../result.ts';
+import type { Row, Seams } from '../seams.ts';
+export { TRIALS_AT };
+export interface Scenario {
+    readonly id: string;
+    readonly describes: string;
+    readonly input: unknown;
+    readonly actor?: Actor;
+    readonly rows?: readonly {
+        readonly entity: string;
+        readonly row: Row;
+    }[];
+    readonly answers?: Readonly<Record<string, ScriptedAnswer>>;
+    readonly views?: Readonly<Record<string, readonly unknown[]>>;
+}
+export interface Trial {
+    readonly operation: string;
+    readonly scenario: string;
+    readonly refused: boolean;
+    readonly measured: boolean;
+    readonly result: unknown;
+    readonly kept: unknown;
+    readonly observed: unknown;
+    readonly called: unknown;
+}
+export interface Outcome {
+    readonly id: string;
+    readonly operation: string;
+    readonly passed: boolean;
+    readonly refused: boolean;
+    readonly measured: boolean;
+    readonly failures: readonly string[];
+}
+export interface Run {
+    readonly outcomes: readonly Outcome[];
+    readonly passed: number;
+    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 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[];
+export declare function record(): Promise<{
+    readonly trials: readonly Trial[];
+    readonly refusals: readonly string[];
+}>;