@prestack/thread 0.1.3 → 0.1.5

package/dist/operations/generators/compile.js

@@ -1,15 +1,14 @@
-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 ts from 'typescript';
-import { ROOT, descend } from "../../core/descend.js";
-import { runChecker } from "../../core/finding.js";
-import { exit, invoked } from "../../core/invoked.js";
-import { inCode, valuesIn } from "../../core/rows.js";
-import { addressOf, credentialsOf, reachOf } from "../../integrations/target.js";
-import { DISPATCH_AT, dispatched } from "../dispatch.js";
-import { SUPPLIES } from "../seams.js";
-import { beside, blockIn, builtFrom, operations, problem, quoted, runtime, types } from "./seed.js";
+import { ROOT, descend } from '../../core/descend.js';
+import { runChecker } from '../../core/finding.js';
+import { exit, invoked } from '../../core/invoked.js';
+import { inCode, valuesIn } from '../../core/rows.js';
+import { credentialsOf, holdsOf, reachOf } from '../../integrations/target.js';
+import { DISPATCH_AT, dispatched } from '../dispatch.js';
+import { beside, blockIn, builtFrom, operations, problem, quoted, runtime, types } from './seed.js';
 async function reaching() {
     const held = async (file, list) => {
         const path = resolve(ROOT, `_threads/${file}`);
@@ -34,18 +33,27 @@ function reached(targets, calls, secrets) {
         const mine = calls.filter((each) => each.of === one.id && one.takes.includes(each.id));
         out[one.id] = {
             reach: reachOf(one.id) ?? 'nothing known',
-            address: addressOf(one, secrets)?.id ?? null,
-            sends: credentialsOf(one, secrets).map((each) => ({
+            address: one.address,
+            headers: one.headers ?? {},
+            signs: credentialsOf(one, secrets)
+                .filter((each) => each.signs !== undefined)
+                .map((each) => ({
+                secret: each.id,
+                header: each.signs?.header ?? '',
+                prefix: each.signs?.prefix ?? '',
+            })),
+            sends: credentialsOf(one, secrets).filter((each) => each.sends !== undefined).map((each) => ({
                 secret: each.id,
                 header: each.sends?.header ?? '',
                 prefix: each.sends?.prefix ?? '',
             })),
-            calls: Object.fromEntries(mine.map((each) => [each.id.replace(/^cl_/, ''), { method: each.method, path: each.path }])),
+            calls: Object.fromEntries(mine.map((each) => [each.id.replace(/^cl_/, ''), { method: each.method ?? null, path: each.path }])),
         };
     }
     return out;
 }
 const OWN = '$';
+const OPENED = 'opened';
 const ENTERED = `${OWN}at`;
 const PLAIN = /^(?:[A-Za-z_][A-Za-z0-9_]*|'(?:[^'\\]|\\.)*')$/;
 export function parts(text) {
@@ -91,10 +99,10 @@ function keyed(text) {
 }
 const OPENS = 'const $ = ';
 const ROLES = {
-    block: ['hands', 'held'],
+    block: ['opened', 'held'],
     over: ['held'],
-    item: ['item', 'hands', 'held'],
-    again: ['pass', 'carried', 'hands', 'held'],
+    item: ['item', 'opened', 'held'],
+    again: ['pass', 'carried', 'opened', 'held'],
 };
 function arrowIn(text, roles) {
     const file = ts.createSourceFile('block.ts', `${OPENS}${text}`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
@@ -208,6 +216,10 @@ function spliced(text, names, mine, roles) {
     const body = again.arrow.body;
     if (again.arrow.parameters.length > 1)
         return { form: 'call', text: whole, whole };
+    const opens = again.arrow.parameters[0];
+    if (opens !== undefined && ts.isIdentifier(opens.name) && opens.name.text !== OPENED) {
+        return { form: 'call', text: whole, whole };
+    }
     if (!ts.isBlock(body))
         return { form: 'expression', text: body.getText(), whole };
     const found = [];
@@ -220,15 +232,15 @@ function spliced(text, names, mine, roles) {
     return { form: 'call', text: whole, whole };
 }
 const ANSWERS = `${OWN}ANSWER`;
-function answered(name, one, hands, kind) {
+function answered(name, one, opened, kind) {
     if (one.form === 'expression')
         return [`${kind} ${name}: unknown = ${one.text}`];
     if (one.form === 'statements') {
         return [`let ${name}: unknown`, '{', ...one.text.split('\n').map((line) => `  ${line.replace(ANSWERS, name)}`), '}'];
     }
-    return [`${kind} ${name}: unknown = await ${asFn(one.whole, hands)}(hands)`];
+    return [`${kind} ${name}: unknown = await ${asFn(one.whole, opened)}(opened)`];
 }
-const asFn = (text, hands, more = '') => `((${text}) as (${more}hands: ${hands}) => Promise<unknown>)`;
+const asFn = (text, opened, more = '') => `((${text}) as (${more}opened: ${opened}) => Promise<unknown>)`;
 function forked(name, said, shape) {
     if (said.length !== 2)
         return `takes a chooser and the ways it chooses between, and was handed ${String(said.length)} thing(s)`;
@@ -245,7 +257,7 @@ function forked(name, said, shape) {
         `let ${name}: unknown`,
         chose.form === 'expression'
             ? `const ${picked}: string = await (${chose.text})`
-            : `const ${picked}: string = await ((${said[0] ?? ''}) as (hands: ${shape.reads}) => Promise<string>)(hands)`,
+            : `const ${picked}: string = await ((${said[0] ?? ''}) as (opened: ${shape.reads}) => Promise<string>)(opened)`,
         `switch (${picked}) {`,
     ];
     for (const way of named) {
@@ -258,7 +270,7 @@ function forked(name, said, shape) {
         else if (each.form === 'statements')
             runs.push(...each.text.split('\n').map((line) => `    ${line.replace(ANSWERS, name)}`));
         else
-            runs.push(`    ${name} = await ${asFn(each.whole, shape.all)}(hands)`);
+            runs.push(`    ${name} = await ${asFn(each.whole, shape.all)}(opened)`);
         runs.push('    break');
         runs.push('  }');
     }
@@ -285,9 +297,9 @@ const SHAPES = {
         return {
             runs: [
                 `const ${all}: unknown[] = []`,
-                `const ${each} = (${block.whole}) as (item: unknown, hands: ${shape.all}) => Promise<unknown>`,
+                `const ${each} = (${block.whole}) as (item: unknown, opened: ${shape.all}) => Promise<unknown>`,
                 `for (const ${item} of ${over.form === 'expression' ? `(${over.text})` : `((${over.whole}) as () => readonly unknown[])()`} as readonly unknown[]) {`,
-                `  ${all}.push(await ${each}(${item}, hands))`,
+                `  ${all}.push(await ${each}(${item}, opened))`,
                 '}',
                 `const ${name}: unknown = ${all}`,
             ],
@@ -307,7 +319,7 @@ const SHAPES = {
             const each = spliced(one, shape.names, shape.mine, ROLES.block);
             if (typeof each === 'string')
                 return `runs a block at position ${String(order + 1)} that ${each}`;
-            calls.push(each.form === 'expression' ? `(async () => ${each.text})()` : `${asFn(each.whole, shape.all)}(hands)`);
+            calls.push(each.form === 'expression' ? `(async () => ${each.text})()` : `${asFn(each.whole, shape.all)}(opened)`);
         }
         return { runs: [`const ${name}: unknown = await Promise.all([${calls.join(', ')}])`] };
     },
@@ -327,11 +339,11 @@ const SHAPES = {
             runs: [
                 `let ${name}: unknown`,
                 `const ${ceiling}: number = ${said[0] ?? ''}`,
-                `const ${again} = (${block.whole}) as (pass: number, carried: unknown, hands: ${shape.all}) => Promise<{ readonly done: boolean; readonly value: unknown }>`,
+                `const ${again} = (${block.whole}) as (pass: number, carried: unknown, opened: ${shape.all}) => Promise<{ readonly done: boolean; readonly value: unknown }>`,
                 `let ${carried}: unknown`,
                 `let ${done} = false`,
                 `for (let ${pass} = 0; ${pass} < ${ceiling}; ${pass} += 1) {`,
-                `  const ${answer} = await ${again}(${pass}, ${carried}, hands)`,
+                `  const ${answer} = await ${again}(${pass}, ${carried}, opened)`,
                 `  if (${answer}.done) { ${name} = ${answer}.value; ${done} = true; break }`,
                 `  ${carried} = ${answer}.value`,
                 '}',
@@ -342,21 +354,23 @@ const SHAPES = {
     nd_branch: forked,
 };
 const STOPS = "Symbol.for('thread.operation.stopped')";
-function plainly(name, said, shape, hands, ends) {
+function plainly(name, said, shape, opened, ends) {
     if (said.length !== 1)
         return `takes one block, and was handed ${String(said.length)} thing(s)`;
     const one = spliced(said[0] ?? '', shape.names, shape.mine, ROLES.block);
     if (typeof one === 'string')
         return one;
     if (!ends)
-        return { runs: answered(name, one, hands, 'const') };
+        return { runs: answered(name, one, opened, 'const') };
     return {
         runs: [
-            ...answered(name, one, hands, 'const'),
+            ...answered(name, one, opened, 'const'),
             `throw Object.assign(new Error(${quoted(`${name} ended the operation`)}), { [${STOPS}]: true, value: ${name} })`,
         ],
     };
 }
+const saidIn = (held) => held !== undefined && ts.isStringLiteral(held) ? held.text : undefined;
+const sourceIn = (held) => held?.getText();
 function compiled(at, id, one, known) {
     const because = problem(id, one);
     if (because !== undefined)
@@ -364,6 +378,18 @@ function compiled(at, id, one, known) {
     const takes = one.takes[0]?.at;
     if (takes === undefined)
         return { because: `\`${id}\` seeds what it takes and states no file for it` };
+    const { timeout } = one;
+    const fields = descend().stated.get(id)?.fields;
+    const entitled = saidIn(fields?.get('entitled'));
+    const rate = sourceIn(fields?.get('rate'));
+    const quota = sourceIn(fields?.get('quota'));
+    if (timeout === undefined) {
+        return {
+            because: `\`${id}\` states no \`timeout\`, and an operation says how long it waits. Add \`timeout: 10_000\` to its row in ` +
+                '_threads/operations.ts, or change it with `thread edit ' + id + ' --timeout <milliseconds>`. How long a call may ' +
+                'run is part of the operation, not something the place it reaches decides',
+        };
+    }
     const only = one.requires.length === 0 ? 'never' : one.requires.map((each) => quoted(each)).join(' | ');
     const mine = new Set(['input', ...one.nodes.map((row) => String(row.id))]);
     const runs = [];
@@ -392,7 +418,7 @@ function compiled(at, id, one, known) {
         if (held === undefined) {
             return { because: `the node \`${name}\` states no block this can read in ${row.at} — run \`thread seed\` and write it again` };
         }
-        const shape = { all: `Handed<${only}>`, reads: `Reads<Handed<${only}>>`, names, mine };
+        const shape = { all: `Opened<${only}>`, reads: `Reads<Opened<${only}>>`, names, mine };
         const made = (SHAPES[from] ?? ownType)(name, parts(held), shape);
         if (typeof made === 'string')
             return { because: `the node \`${name}\` ${made}` };
@@ -407,18 +433,21 @@ function compiled(at, id, one, known) {
             "import type { z } from 'zod'",
             '',
             `import type { Operation } from ${quoted(runtime(at, '../operations.ts'))}`,
-            `import type { Handed, Reads } from ${quoted(runtime(at, '../seams.ts'))}`,
+            'import type { Opened, Reads } from ' + quoted(runtime(at, '../operations.ts')),
             '',
-            `import { estimate, input, resource } from ${quoted(beside(at, takes))}`,
+            `import { input, resource } from ${quoted(beside(at, takes))}`,
             '',
             `export const operation: Operation<z.infer<typeof input>, ${only}> = {`,
             `  id: ${quoted(id)},`,
             '  input,',
-            '  estimate,',
+            `  timeout: ${String(timeout)},`,
             '  resource,',
             `  requires: [${one.requires.map((each) => quoted(each)).join(', ')}],`,
+            ...(entitled === undefined ? [] : [`  entitled: ${quoted(entitled)},`]),
+            ...(rate === undefined ? [] : [`  rate: ${rate},`]),
+            ...(quota === undefined ? [] : [`  quota: ${quota},`]),
             '',
-            '  run: async (hands, held) => {',
+            '  run: async (opened, held) => {',
             '    const input = held.input',
             `    let ${ENTERED} = ''`,
             '    try {',
@@ -440,8 +469,8 @@ async function planned() {
     const known = types(pass);
     const reach = await reaching();
     const found = [];
-    const answers = Object.keys(reach).filter((one) => Object.keys(reach[one]?.calls ?? {}).length > 0);
-    const may = [...SUPPLIES, ...answers];
+    const answers = Object.keys(reach).filter((one) => Object.keys(reach[one]?.calls ?? {}).length > 0 || holdsOf(one)?.takes !== 'calls');
+    const may = [...answers];
     for (const [id, one] of operations(pass, known)) {
         if (one.body === undefined)
             continue;
@@ -452,11 +481,9 @@ async function planned() {
                 because: silent
                     .map((each) => {
                     const how = reach[each]?.reach ?? 'nothing known';
-                    const instead = how === 'module' || how === 'cli'
-                        ? 'run it with `thread run ' + each.replace(/^[a-z]+_/, '') + '`'
-                        : 'reach the rows it keeps with `sm_store`';
+                    const instead = 'declare what it answers with `thread create target call ' + each + ' <name>`';
                     return ('`' + id + '` requires `' + each + '`, which is reached over ' + how + ' and answers no call, so there ' +
-                        'is nothing for a node to be handed. ' + instead + ', give it a call with `thread create target call`, ' +
+                        'is nothing for a node to be handed. ' + instead + ', ' +
                         'or take the word off that operation\'s row');
                 })
                     .join('; '),

package/dist/operations/generators/compile.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from '../../core/files.ts'
+import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
 import { dirname, resolve } from 'node:path'
 import { argv, stdout } from 'node:process'
 
@@ -9,11 +9,10 @@ import { runChecker, type Finding } from '../../core/finding.ts'
 import { exit, invoked } from '../../core/invoked.ts'
 import { inCode, valuesIn } from '../../core/rows.ts'
 
-import { addressOf, credentialsOf, reachOf, type Call, type Target } from '../../integrations/target.ts'
+import { credentialsOf, holdsOf, reachOf, type Call, type Target } from '../../integrations/target.ts'
 import type { Secret } from '../../integrations/secret.ts'
 
 import { DISPATCH_AT, dispatched } from '../dispatch.ts'
-import { SUPPLIES } from '../seams.ts'
 import { beside, blockIn, builtFrom, operations, problem, quoted, runtime, types } from './seed.ts'
 
 async function reaching(): Promise<Readonly<Record<string, ReturnType<typeof reached>[string]>>> {
@@ -42,10 +41,11 @@ function reached(
     string,
     {
       readonly reach: string
-      readonly address: string | null
-      readonly sends: readonly { readonly secret: string; readonly header: string; readonly prefix: string }[]
-      readonly calls: Readonly<Record<string, { readonly method: string; readonly path: string }>>
-
+      readonly address?: string
+      readonly headers: Readonly<Record<string, string>>
+  readonly sends: readonly { readonly secret: string; readonly header: string; readonly prefix: string }[]
+  readonly signs: readonly { readonly secret: string; readonly header: string; readonly prefix: string }[]
+        readonly calls: Readonly<Record<string, { readonly method: string | null; readonly path: string }>>
     }
   >
 > {
@@ -54,15 +54,23 @@ function reached(
     const mine = calls.filter((each) => each.of === one.id && one.takes.includes(each.id))
     out[one.id] = {
       reach: reachOf(one.id) ?? 'nothing known',
-      address: addressOf(one, secrets)?.id ?? null,
-      sends: credentialsOf(one, secrets).map((each) => ({
+      address: one.address,
+      headers: one.headers ?? {},
+      signs: credentialsOf(one, secrets)
+        .filter((each) => each.signs !== undefined)
+        .map((each) => ({
+          secret: each.id,
+          header: each.signs?.header ?? '',
+          prefix: each.signs?.prefix ?? '',
+        })),
+      sends: credentialsOf(one, secrets).filter((each) => each.sends !== undefined).map((each) => ({
         secret: each.id,
         header: each.sends?.header ?? '',
         prefix: each.sends?.prefix ?? '',
       })),
 
       calls: Object.fromEntries(
-        mine.map((each) => [each.id.replace(/^cl_/, ''), { method: each.method, path: each.path }]),
+        mine.map((each) => [each.id.replace(/^cl_/, ''), { method: each.method ?? null, path: each.path }]),
       ),
     }
   }
@@ -71,6 +79,8 @@ function reached(
 
 const OWN = '$'
 
+const OPENED = 'opened'
+
 const ENTERED = `${OWN}at`
 
 const PLAIN = /^(?:[A-Za-z_][A-Za-z0-9_]*|'(?:[^'\\]|\\.)*')$/
@@ -115,10 +125,10 @@ function keyed(text: string): { readonly key: string; readonly held: string } |
 const OPENS = 'const $ = '
 
 const ROLES = {
-  block: ['hands', 'held'],
+  block: ['opened', 'held'],
   over: ['held'],
-  item: ['item', 'hands', 'held'],
-  again: ['pass', 'carried', 'hands', 'held'],
+  item: ['item', 'opened', 'held'],
+  again: ['pass', 'carried', 'opened', 'held'],
 } as const satisfies Readonly<Record<string, readonly string[]>>
 
 interface Read {
@@ -261,6 +271,11 @@ function spliced(
 
   if (again.arrow.parameters.length > 1) return { form: 'call', text: whole, whole }
 
+  const opens = again.arrow.parameters[0]
+  if (opens !== undefined && ts.isIdentifier(opens.name) && opens.name.text !== OPENED) {
+    return { form: 'call', text: whole, whole }
+  }
+
   if (!ts.isBlock(body)) return { form: 'expression', text: body.getText(), whole }
 
   const found: ts.ReturnStatement[] = []
@@ -287,16 +302,16 @@ interface Shape {
   readonly mine: ReadonlySet<string>
 }
 
-function answered(name: string, one: Spliced, hands: string, kind: 'const' | 'let'): readonly string[] {
+function answered(name: string, one: Spliced, opened: string, kind: 'const' | 'let'): readonly string[] {
   if (one.form === 'expression') return [`${kind} ${name}: unknown = ${one.text}`]
   if (one.form === 'statements') {
     return [`let ${name}: unknown`, '{', ...one.text.split('\n').map((line) => `  ${line.replace(ANSWERS, name)}`), '}']
   }
-  return [`${kind} ${name}: unknown = await ${asFn(one.whole, hands)}(hands)`]
+  return [`${kind} ${name}: unknown = await ${asFn(one.whole, opened)}(opened)`]
 }
 
-const asFn = (text: string, hands: string, more: string = ''): string =>
-  `((${text}) as (${more}hands: ${hands}) => Promise<unknown>)`
+const asFn = (text: string, opened: string, more: string = ''): string =>
+  `((${text}) as (${more}opened: ${opened}) => Promise<unknown>)`
 
 function forked(name: string, said: readonly string[], shape: Shape): Made | string {
   if (said.length !== 2) return `takes a chooser and the ways it chooses between, and was handed ${String(said.length)} thing(s)`
@@ -314,7 +329,7 @@ function forked(name: string, said: readonly string[], shape: Shape): Made | str
     `let ${name}: unknown`,
     chose.form === 'expression'
       ? `const ${picked}: string = await (${chose.text})`
-      : `const ${picked}: string = await ((${said[0] ?? ''}) as (hands: ${shape.reads}) => Promise<string>)(hands)`,
+      : `const ${picked}: string = await ((${said[0] ?? ''}) as (opened: ${shape.reads}) => Promise<string>)(opened)`,
     `switch (${picked}) {`,
   ]
 
@@ -324,7 +339,7 @@ function forked(name: string, said: readonly string[], shape: Shape): Made | str
     runs.push(`  case ${(way?.key ?? '').startsWith("'") ? (way?.key ?? '') : quoted(way?.key ?? '')}: {`)
     if (each.form === 'expression') runs.push(`    ${name} = ${each.text}`)
     else if (each.form === 'statements') runs.push(...each.text.split('\n').map((line) => `    ${line.replace(ANSWERS, name)}`))
-    else runs.push(`    ${name} = await ${asFn(each.whole, shape.all)}(hands)`)
+    else runs.push(`    ${name} = await ${asFn(each.whole, shape.all)}(opened)`)
     runs.push('    break')
     runs.push('  }')
   }
@@ -351,9 +366,9 @@ const SHAPES: Readonly<Record<string, (name: string, said: readonly string[], sh
     return {
       runs: [
         `const ${all}: unknown[] = []`,
-        `const ${each} = (${block.whole}) as (item: unknown, hands: ${shape.all}) => Promise<unknown>`,
+        `const ${each} = (${block.whole}) as (item: unknown, opened: ${shape.all}) => Promise<unknown>`,
         `for (const ${item} of ${over.form === 'expression' ? `(${over.text})` : `((${over.whole}) as () => readonly unknown[])()`} as readonly unknown[]) {`,
-        `  ${all}.push(await ${each}(${item}, hands))`,
+        `  ${all}.push(await ${each}(${item}, opened))`,
         '}',
         `const ${name}: unknown = ${all}`,
       ],
@@ -371,7 +386,7 @@ const SHAPES: Readonly<Record<string, (name: string, said: readonly string[], sh
     for (const [order, one] of every.entries()) {
       const each = spliced(one, shape.names, shape.mine, ROLES.block)
       if (typeof each === 'string') return `runs a block at position ${String(order + 1)} that ${each}`
-      calls.push(each.form === 'expression' ? `(async () => ${each.text})()` : `${asFn(each.whole, shape.all)}(hands)`)
+      calls.push(each.form === 'expression' ? `(async () => ${each.text})()` : `${asFn(each.whole, shape.all)}(opened)`)
     }
     return { runs: [`const ${name}: unknown = await Promise.all([${calls.join(', ')}])`] }
   },
@@ -390,11 +405,11 @@ const SHAPES: Readonly<Record<string, (name: string, said: readonly string[], sh
       runs: [
         `let ${name}: unknown`,
         `const ${ceiling}: number = ${said[0] ?? ''}`,
-        `const ${again} = (${block.whole}) as (pass: number, carried: unknown, hands: ${shape.all}) => Promise<{ readonly done: boolean; readonly value: unknown }>`,
+        `const ${again} = (${block.whole}) as (pass: number, carried: unknown, opened: ${shape.all}) => Promise<{ readonly done: boolean; readonly value: unknown }>`,
         `let ${carried}: unknown`,
         `let ${done} = false`,
         `for (let ${pass} = 0; ${pass} < ${ceiling}; ${pass} += 1) {`,
-        `  const ${answer} = await ${again}(${pass}, ${carried}, hands)`,
+        `  const ${answer} = await ${again}(${pass}, ${carried}, opened)`,
         `  if (${answer}.done) { ${name} = ${answer}.value; ${done} = true; break }`,
         `  ${carried} = ${answer}.value`,
         '}',
@@ -408,20 +423,24 @@ const SHAPES: Readonly<Record<string, (name: string, said: readonly string[], sh
 
 const STOPS = "Symbol.for('thread.operation.stopped')"
 
-function plainly(name: string, said: readonly string[], shape: Shape, hands: string, ends: boolean): Made | string {
+function plainly(name: string, said: readonly string[], shape: Shape, opened: string, ends: boolean): Made | string {
   if (said.length !== 1) return `takes one block, and was handed ${String(said.length)} thing(s)`
   const one = spliced(said[0] ?? '', shape.names, shape.mine, ROLES.block)
   if (typeof one === 'string') return one
 
-  if (!ends) return { runs: answered(name, one, hands, 'const') }
+  if (!ends) return { runs: answered(name, one, opened, 'const') }
 
   return {
     runs: [
-      ...answered(name, one, hands, 'const'),
+      ...answered(name, one, opened, 'const'),
       `throw Object.assign(new Error(${quoted(`${name} ended the operation`)}), { [${STOPS}]: true, value: ${name} })`,
     ],
   }
 }
+const saidIn = (held: ts.Expression | undefined): string | undefined =>
+  held !== undefined && ts.isStringLiteral(held) ? held.text : undefined
+
+const sourceIn = (held: ts.Expression | undefined): string | undefined => held?.getText()
 
 function compiled(
   at: string,
@@ -435,6 +454,21 @@ function compiled(
   const takes = one.takes[0]?.at
   if (takes === undefined) return { because: `\`${id}\` seeds what it takes and states no file for it` }
 
+  const { timeout } = one
+
+  const fields = descend().stated.get(id)?.fields
+  const entitled = saidIn(fields?.get('entitled'))
+  const rate = sourceIn(fields?.get('rate'))
+  const quota = sourceIn(fields?.get('quota'))
+  if (timeout === undefined) {
+    return {
+      because:
+        `\`${id}\` states no \`timeout\`, and an operation says how long it waits. Add \`timeout: 10_000\` to its row in ` +
+        '_threads/operations.ts, or change it with `thread edit ' + id + ' --timeout <milliseconds>`. How long a call may ' +
+        'run is part of the operation, not something the place it reaches decides',
+    }
+  }
+
   const only = one.requires.length === 0 ? 'never' : one.requires.map((each) => quoted(each)).join(' | ')
   const mine = new Set<string>(['input', ...one.nodes.map((row) => String(row.id))])
 
@@ -466,7 +500,7 @@ function compiled(
       return { because: `the node \`${name}\` states no block this can read in ${row.at} — run \`thread seed\` and write it again` }
     }
 
-    const shape: Shape = { all: `Handed<${only}>`, reads: `Reads<Handed<${only}>>`, names, mine }
+    const shape: Shape = { all: `Opened<${only}>`, reads: `Reads<Opened<${only}>>`, names, mine }
     const made = (SHAPES[from] ?? ownType)(name, parts(held), shape)
     if (typeof made === 'string') return { because: `the node \`${name}\` ${made}` }
 
@@ -481,18 +515,21 @@ function compiled(
       "import type { z } from 'zod'",
       '',
       `import type { Operation } from ${quoted(runtime(at, '../operations.ts'))}`,
-      `import type { Handed, Reads } from ${quoted(runtime(at, '../seams.ts'))}`,
+      'import type { Opened, Reads } from ' + quoted(runtime(at, '../operations.ts')),
       '',
-      `import { estimate, input, resource } from ${quoted(beside(at, takes))}`,
+      `import { input, resource } from ${quoted(beside(at, takes))}`,
       '',
       `export const operation: Operation<z.infer<typeof input>, ${only}> = {`,
       `  id: ${quoted(id)},`,
       '  input,',
-      '  estimate,',
+      `  timeout: ${String(timeout)},`,
       '  resource,',
       `  requires: [${one.requires.map((each) => quoted(each)).join(', ')}],`,
+      ...(entitled === undefined ? [] : [`  entitled: ${quoted(entitled)},`]),
+      ...(rate === undefined ? [] : [`  rate: ${rate},`]),
+      ...(quota === undefined ? [] : [`  quota: ${quota},`]),
       '',
-      '  run: async (hands, held) => {',
+      '  run: async (opened, held) => {',
       '    const input = held.input',
       `    let ${ENTERED} = ''`,
       '    try {',
@@ -524,8 +561,10 @@ async function planned(): Promise<readonly Wanted[]> {
   const reach = await reaching()
   const found: Wanted[] = []
 
-  const answers = Object.keys(reach).filter((one) => Object.keys(reach[one]?.calls ?? {}).length > 0)
-  const may = [...SUPPLIES, ...answers]
+  const answers = Object.keys(reach).filter(
+    (one) => Object.keys(reach[one]?.calls ?? {}).length > 0 || holdsOf(one)?.takes !== 'calls',
+  )
+  const may = [...answers]
   for (const [id, one] of operations(pass, known)) {
     if (one.body === undefined) continue
     const silent = one.requires.filter((each) => reach[each] !== undefined && !answers.includes(each))
@@ -535,13 +574,13 @@ async function planned(): Promise<readonly Wanted[]> {
         because: silent
           .map((each) => {
             const how = reach[each]?.reach ?? 'nothing known'
-            const instead =
-              how === 'module' || how === 'cli'
-                ? 'run it with `thread run ' + each.replace(/^[a-z]+_/, '') + '`'
-                : 'reach the rows it keeps with `sm_store`'
+              const instead = 'declare what it answers with `thread create target call ' + each + ' <name>`'
+
+
+
             return (
               '`' + id + '` requires `' + each + '`, which is reached over ' + how + ' and answers no call, so there ' +
-              'is nothing for a node to be handed. ' + instead + ', give it a call with `thread create target call`, ' +
+                'is nothing for a node to be handed. ' + instead + ', ' +
               'or take the word off that operation\'s row'
             )
           })

package/dist/operations/generators/permits.js

@@ -1,15 +1,14 @@
-import { existsSync, readFileSync, writeFileSync } from "../../core/files.js";
-import { valuesIn } from "../../core/rows.js";
+import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.js';
+import { valuesIn } from '../../core/rows.js';
 import { resolve } from 'node:path';
 import { argv, stderr, stdout } from 'node:process';
-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";
+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 { operations as woven, runtime, types } from './seed.js';
 function stop(why) {
     stderr.write(`permits: ${why}\n`);
     exit(1);
@@ -153,7 +152,7 @@ function permitting() {
         ];
     return [
         `import type { Actor } from '${runtime(PERMITS_AT, '../../core/actor.ts')}'`,
-        `import type { Row } from '${runtime(PERMITS_AT, '../seams.ts')}'`,
+        "import type { Row } from '" + runtime(PERMITS_AT, '../../integrations/target.ts') + "'",
         '',
         ...(grants.some((one) => one.when !== undefined) ? [...READS, ''] : []),
         ...(grants.some((one) => one.to !== undefined) ? [...WEARS, ''] : []),
@@ -183,5 +182,5 @@ if (CHECKING) {
     exit(findings.length === 0 ? 0 : 1);
 }
 writeFileSync(permitted, content);
-stdout.write(`permits: wrote ${PERMITS_AT} — ${count}. ${DECLARED_SEAMS_AT} hands it to dispatch as the gate every operation passes; ` +
+stdout.write(`permits: wrote ${PERMITS_AT} — ${count}. Dispatch imports this check itself, so every operation passes it; ` +
     '`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/permits.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from '../../core/files.ts'
+import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
 import { valuesIn } from '../../core/rows.ts'
 import { dirname, resolve } from 'node:path'
 import { argv, stderr, stdout } from 'node:process'
@@ -12,7 +12,6 @@ import type { Condition, Operand } from '../../core/condition.ts'
 import { findTree, inTree } from '../../core/tree.ts'
 
 import { PERMITS_AT, grantedTwice, opensToEverybody, unanswerable, type Grant } from '../access.ts'
-import { DECLARED_SEAMS_AT } from '../capabilities.ts'
 import { operations as woven, runtime, types } from './seed.ts'
 
 function stop(why: string): never {
@@ -180,7 +179,7 @@ function permitting(): string {
 
   return [
     `import type { Actor } from '${runtime(PERMITS_AT, '../../core/actor.ts')}'`,
-    `import type { Row } from '${runtime(PERMITS_AT, '../seams.ts')}'`,
+    "import type { Row } from '" + runtime(PERMITS_AT, '../../integrations/target.ts') + "'",
     '',
     ...(grants.some((one) => one.when !== undefined) ? [...READS, ''] : []),
     ...(grants.some((one) => one.to !== undefined) ? [...WEARS, ''] : []),
@@ -218,6 +217,6 @@ if (CHECKING) {
 
 writeFileSync(permitted, content)
 stdout.write(
-  `permits: wrote ${PERMITS_AT} — ${count}. ${DECLARED_SEAMS_AT} hands it to dispatch as the gate every operation passes; ` +
+  `permits: wrote ${PERMITS_AT} — ${count}. Dispatch imports this check itself, so every operation passes it; ` +
     '`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

@@ -11,6 +11,7 @@ interface Woven {
     readonly body?: string;
     readonly requires: readonly string[];
     readonly stray: readonly string[];
+    readonly timeout?: number;
 }
 export declare function operations(pass: Pass, known: ReadonlySet<string>): ReadonlyMap<string, Woven>;
 export declare const problem: (id: string, one: Woven) => string | undefined;