@prestack/thread 0.1.3 → 0.1.5

package/dist/operations/generators/trial.ts

@@ -1,25 +1,26 @@
-import { existsSync, readFileSync, writeFileSync } from '../../core/files.ts'
+import { existsSync, readFileSync, writeFileSync, type Answering, type Listed } from '../../integrations/disk.ts'
 import { dirname, resolve } from 'node:path'
 import { argv, stdout } from 'node:process'
 import { pathToFileURL } from 'node:url'
 
 import { ANONYMOUS, type Actor } from '../../core/actor.ts'
-import { ROOT, TREE, descend } from '../../core/descend.ts'
+import { ROOT, descend } from '../../core/descend.ts'
 import { exit, invoked } from '../../core/invoked.ts'
+import { reachOf, standsHere, type Call, type Row, type Target } from '../../integrations/target.ts'
 
-import { recordingHttp, type ScriptedAnswer } from '../http.ts'
-import { inMemorySeams, type Sink } from '../memory.ts'
+import { recordingHttp, type RecordedCall, type Scripted, type ScriptedAnswer } from '../../integrations/https.ts'
+import { standing, type Kept, type Stood } from '../../integrations/pglite.ts'
 import { TRIALS_AT, type Operation } from '../operations.ts'
 import { PERMITS_AT } from '../access.ts'
 import type { Result } from '../result.ts'
-import type { Row, Seams } from '../seams.ts'
+import type { Vault } from '../../integrations/secret.ts'
 import { operations, types } from './seed.ts'
 
 export { TRIALS_AT }
 
 const DISPATCH_AT = 'operations/_dispatch.ts'
 
-const ENTITIES_AT = `${TREE}entities.ts`
+
 
 const ACCESS_AT = '_threads/access.ts'
 
@@ -36,9 +37,11 @@ export interface Scenario {
 
   readonly rows?: readonly { 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 {
@@ -53,7 +56,6 @@ export interface Trial {
 
   readonly kept: unknown
 
-  readonly observed: unknown
 
   readonly called: unknown
 }
@@ -99,55 +101,185 @@ const asking = (scenario: Scenario): Actor => ({
   ...(scenario.actor ?? ANONYMOUS),
   run: 'trial',
   replay: `trial_${scenario.id}`,
+  moment: new Date(WHEN).toISOString(),
 })
 
-function seamsFor(
-  one: Operation<unknown>,
-  scenario: Scenario,
-  stood: Readonly<Record<string, string>>,
-  gate?: NonNullable<Seams['permits']>,
-  known?: { readonly entities: ReadonlyMap<string, ReadonlySet<string>>; readonly keys: ReadonlyMap<string, string> },
-): { readonly seams: Seams; readonly sink: Sink; readonly kept: () => unknown; readonly calls: () => unknown } {
-  const made = inMemorySeams({
-    secrets: stood,
-    ...(scenario.views === undefined ? {} : { views: scenario.views }),
-    ...(known === undefined ? {} : { entities: known.entities, keys: known.keys }),
-  })
-
-  const found = made.seams as unknown as Record<string, unknown>
-
-  if (gate !== undefined) found['permits'] = gate
-  found['clock'] = { now: () => WHEN }
-
-  let drawn = 0
-  found['random'] = {
-    next: () => {
-      drawn += 1
-      return drawn / 100
+function programmed(word: string, names: readonly string[]): Record<string, unknown> {
+  const made: Record<string, unknown> = {}
+  for (const order of names) {
+    made[order] = (): never => {
+      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: string,
+  names: readonly string[],
+  script: Readonly<Record<string, Scripted>>,
+  into: RecordedCall[],
+): Record<string, unknown> {
+  const spent = new Map<string, number>()
+  const made: Record<string, unknown> = {}
+  for (const name of names) {
+    made[name] = async (given?: unknown): Promise<unknown> => {
+      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 as readonly ScriptedAnswer[]) : undefined
+      const at = spent.get(key) ?? 0
+      spent.set(key, at + 1)
+      const answer = each === undefined ? (held as ScriptedAnswer) : 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) as unknown)
+    }
+  }
+  return made
+}
+
+function disked(files: Readonly<Record<string, string>>): Answering {
+  const held = new Map<string, string>(Object.entries(files))
+  const under = (at: string): boolean => [...held.keys()].some((one) => one.startsWith(at + '/'))
+  const gone = (at: string): Error =>
+    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<string, Listed>()
+      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 }
+    },
+    remove: (at) => {
+      held.delete(at)
     },
-    uuid: () => {
-      drawn += 1
-      return `00000000-0000-4000-8000-${String(drawn).padStart(12, '0')}`
+    real: (at) => at,
+  }
+}
+
+function vaulting(stood: Readonly<Record<string, string>>): Vault {
+  return {
+    async resolve(refs) {
+      const found: Record<string, string> = {}
+      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: Target): Promise<Stood | string> {
+  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(pathToFileURL(at).href)) as { readonly kept?: Kept }
+  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: Operation<unknown>,
+  scenario: Scenario,
+  stood: Readonly<Record<string, string>>,
+  targets: readonly Target[] = [],
+  calls: readonly Call[] = [],
+): Promise<{
+  readonly opened: Readonly<Record<string, unknown>>
+  readonly opening: Vault
+  readonly stores: readonly Stood[]
+  readonly calls: () => unknown
+} | string> {
   const recorder = recordingHttp(scenario.answers ?? {})
-  found['http'] = recorder
+  const packages: RecordedCall[] = []
+  const opening = vaulting(stood)
+  const opened: Record<string, unknown> = {}
+  const stores: Stood[] = []
+
+  const answering = (row: Target): readonly string[] =>
+    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 { seams: made.seams, sink: made.sink, kept: () => made.store, calls: () => recorder.calls }
+
+  return { opened, opening, stores, calls: () => [...recorder['calls'], ...packages] }
 }
 
-function entered(sink: Sink): boolean {
-  return sink.logs.some((one) => {
-    const data = one.data as Record<string, unknown> | undefined
-    return data !== undefined && 'observability' in data
-  })
+const BEFORE = new Set(['denied', 'invalid'])
+
+function entered(result: unknown): boolean {
+  if (typeof result !== 'object' || result === null) return false
+  const held = result as { readonly ok?: unknown; readonly code?: unknown }
+  if (held.ok === true) return true
+  return held.ok === false && !BEFORE.has(String(held.code))
 }
 
 function denied(result: unknown): boolean {
   if (typeof result !== 'object' || result === null) return false
   const held = result as { readonly ok?: unknown; readonly code?: unknown }
-  return held.ok === false && held.code === 'denied'
+  return held.ok === false && BEFORE.has(String(held.code))
 }
 
 export async function runScenario(
@@ -157,38 +289,48 @@ export async function runScenario(
     operation: Operation<unknown>,
     input: unknown,
     actor: Actor,
-    seams: Seams,
+    opened: Readonly<Record<string, unknown>>,
+    opening: Vault,
   ) => 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> {
+  targets: readonly Target[] = [],
+  calls: readonly Call[] = [],
+): Promise<Trial | string> {
 
-  const made = seamsFor(one, scenario, stood, gate, known)
+  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: unknown
   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: Record<string, unknown> = {}
+  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(),
   }
 }
@@ -252,15 +394,15 @@ export function compared(was: readonly Trial[], now: readonly Trial[]): Run {
 
     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',
+        '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'] as const) {
+      for (const part of ['result', 'kept', 'called'] as const) {
         const then = printed(older[part])
         const said = printed(one[part])
         if (then === said) continue
@@ -318,7 +460,7 @@ export function unproven(run: Run): readonly string[] {
     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 !== '')
 
@@ -331,13 +473,13 @@ export function unproven(run: Run): readonly string[] {
   return said
 }
 
-async function standing(): Promise<Readonly<Record<string, string>> | string> {
+async function standIns(): Promise<Readonly<Record<string, string>> | string> {
   const at = resolve(ROOT, '_threads/secrets.ts')
   if (!existsSync(at)) return {}
-  let held: readonly { readonly id: string; readonly sends?: unknown }[]
+  let held: readonly { readonly id: string; readonly sends?: unknown; readonly signs?: unknown }[]
   try {
     const taken = (await import(pathToFileURL(at).href)) as {
-      readonly SECRETS?: readonly { readonly id: string; readonly sends?: unknown }[]
+      readonly SECRETS?: readonly { readonly id: string; readonly sends?: unknown; readonly signs?: unknown }[]
     }
     held = taken.SECRETS ?? []
   } catch (thrown) {
@@ -349,11 +491,26 @@ async function standing(): Promise<Readonly<Record<string, string>> | string> {
   }
   const found: Record<string, string> = {}
   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(): Promise<{ readonly targets: readonly Target[]; readonly calls: readonly Call[] } | string> {
+  const at = resolve(ROOT, '_threads/targets.ts')
+  if (!existsSync(at)) return { targets: [], calls: [] }
+  try {
+    const taken = (await import(pathToFileURL(at).href)) as { readonly TARGETS?: readonly Target[]; readonly CALLS?: readonly Call[] }
+    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(): Promise<{ readonly trials: readonly Trial[]; readonly refusals: readonly string[] }> {
   const pass = descend()
   const known = types(pass)
@@ -363,9 +520,13 @@ export async function record(): Promise<{ readonly trials: readonly Trial[]; rea
   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 {
@@ -380,7 +541,8 @@ export async function record(): Promise<{ readonly trials: readonly Trial[]; rea
       operation: Operation<unknown>,
       input: unknown,
       actor: Actor,
-      seams: Seams,
+      opened: Readonly<Record<string, unknown>>,
+      opening: Vault,
     ) => Promise<Result<unknown>>
   }
   const dispatch = made.dispatch
@@ -388,28 +550,6 @@ export async function record(): Promise<{ readonly trials: readonly Trial[]; rea
     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<string, ReadonlySet<string>>()
-  const keys = new Map<string, string>()
-  if (existsSync(kept)) {
-    const sheet = (await import(pathToFileURL(kept).href)) as {
-      readonly ENTITIES?: readonly {
-        readonly id: string
-        readonly holds?: readonly { readonly id: string }[]
-        readonly links?: readonly { readonly id: string }[]
-        readonly must?: readonly { readonly unique?: readonly string[] }[]
-      }[]
-    }
-    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] as string] : []))
-      if (named.length === 1) keys.set(one.id, named[0] as string)
-    }
-  }
-
   const permitted = resolve(ROOT, ACCESS_AT)
   const may = new Map<string, string[]>()
   if (existsSync(permitted)) {
@@ -438,11 +578,6 @@ export async function record(): Promise<{ readonly trials: readonly Trial[]; rea
       refusals: [`${PERMITS_AT} exports no \`permits\`, so a trial cannot be answered by the gate this app derives`],
     }
   }
-  const gate: NonNullable<Seams['permits']> | undefined =
-    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
     const from = resolve(ROOT, one.body)
@@ -471,7 +606,9 @@ export async function record(): Promise<{ readonly trials: readonly Trial[]; rea
     }
 
     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)
     }
   }
 

package/dist/operations/nodes.d.ts

@@ -1,6 +1,5 @@
 import type { Threaded } from '../core/thread.ts';
-import type { Operation } from './operations.ts';
-import type { Handed, Reads, Supplied } from './seams.ts';
+import type { Opened, Operation, Reads } from './operations.ts';
 export interface Node extends Threaded {
     readonly version: number;
 }
@@ -9,27 +8,27 @@ export declare const STOPPED: unique symbol;
 export declare function stopped(thrown: unknown): {
     readonly value: unknown;
 } | undefined;
-export declare const nd_read: <I, R extends string = Supplied>(block: (hands: Reads<Handed<R>>, held: Held<I>) => Promise<unknown>) => {
-    type: "nd_read";
+export declare const nd_read: <I, R extends string = never>(block: (opened: Reads<Opened<R>>, held: Held<I>) => Promise<unknown>) => {
+    type: 'nd_read';
 };
-export declare const nd_action: <I, R extends string = Supplied>(block: (hands: Handed<R>, held: Held<I>) => Promise<unknown>) => {
-    type: "nd_action";
+export declare const nd_action: <I, R extends string = never>(block: (opened: Opened<R>, held: Held<I>) => Promise<unknown>) => {
+    type: 'nd_action';
 };
-export declare const nd_branch: <I, R extends string = Supplied>(choose: (hands: Reads<Handed<R>>, held: Held<I>) => Promise<string>, ways: Readonly<Record<string, (hands: Handed<R>, held: Held<I>) => Promise<unknown>>>) => {
-    type: "nd_branch";
+export declare const nd_branch: <I, R extends string = never>(choose: (opened: Reads<Opened<R>>, held: Held<I>) => Promise<string>, ways: Readonly<Record<string, (opened: Opened<R>, held: Held<I>) => Promise<unknown>>>) => {
+    type: 'nd_branch';
 };
-export declare const nd_each: <I, R extends string = Supplied>(over: (held: Held<I>) => readonly unknown[], block: (item: unknown, hands: Handed<R>, held: Held<I>) => Promise<unknown>) => {
-    type: "nd_each";
+export declare const nd_each: <I, R extends string = never>(over: (held: Held<I>) => readonly unknown[], block: (item: unknown, opened: Opened<R>, held: Held<I>) => Promise<unknown>) => {
+    type: 'nd_each';
 };
-export declare const nd_parallel: <I, R extends string = Supplied>(blocks: readonly ((hands: Handed<R>, held: Held<I>) => Promise<unknown>)[]) => {
-    type: "nd_parallel";
+export declare const nd_parallel: <I, R extends string = never>(blocks: readonly ((opened: Opened<R>, held: Held<I>) => Promise<unknown>)[]) => {
+    type: 'nd_parallel';
 };
-export declare const nd_repeat: <I, R extends string = Supplied>(ceiling: number, block: (pass: number, carried: unknown, hands: Handed<R>, held: Held<I>) => Promise<{
+export declare const nd_repeat: <I, R extends string = never>(ceiling: number, block: (pass: number, carried: unknown, opened: Opened<R>, held: Held<I>) => Promise<{
     readonly done: boolean;
     readonly value: unknown;
 }>) => {
-    type: "nd_repeat";
+    type: 'nd_repeat';
 };
-export declare const nd_stop: <I, R extends string = Supplied>(block: (hands: Reads<Handed<R>>, held: Held<I>) => Promise<unknown>) => {
-    type: "nd_stop";
+export declare const nd_stop: <I, R extends string = never>(block: (opened: Reads<Opened<R>>, held: Held<I>) => Promise<unknown>) => {
+    type: 'nd_stop';
 };

package/dist/operations/nodes.ts

@@ -1,7 +1,6 @@
 import type { Threaded } from '../core/thread.ts'
 
-import type { Operation } from './operations.ts'
-import type { Handed, Reads, Supplied } from './seams.ts'
+import type { Opened, Operation, Reads } from './operations.ts'
 
 export interface Node extends Threaded {
   readonly version: number
@@ -17,38 +16,38 @@ export function stopped(thrown: unknown): { readonly value: unknown } | undefine
   return { value: (thrown as { readonly value?: unknown }).value }
 }
 
-export const nd_read = <I, R extends string = Supplied>(
-  block: (hands: Reads<Handed<R>>, held: Held<I>) => Promise<unknown>,
+export const nd_read = <I, R extends string = never>(
+  block: (opened: Reads<Opened<R>>, held: Held<I>) => Promise<unknown>,
 ) => ({ type: 'nd_read' as const })
 
-export const nd_action = <I, R extends string = Supplied>(
-  block: (hands: Handed<R>, held: Held<I>) => Promise<unknown>,
+export const nd_action = <I, R extends string = never>(
+  block: (opened: Opened<R>, held: Held<I>) => Promise<unknown>,
 ) => ({ type: 'nd_action' as const })
 
-export const nd_branch = <I, R extends string = Supplied>(
-  choose: (hands: Reads<Handed<R>>, held: Held<I>) => Promise<string>,
-  ways: Readonly<Record<string, (hands: Handed<R>, held: Held<I>) => Promise<unknown>>>,
+export const nd_branch = <I, R extends string = never>(
+  choose: (opened: Reads<Opened<R>>, held: Held<I>) => Promise<string>,
+  ways: Readonly<Record<string, (opened: Opened<R>, held: Held<I>) => Promise<unknown>>>,
 ) => ({ type: 'nd_branch' as const })
 
-export const nd_each = <I, R extends string = Supplied>(
+export const nd_each = <I, R extends string = never>(
   over: (held: Held<I>) => readonly unknown[],
-  block: (item: unknown, hands: Handed<R>, held: Held<I>) => Promise<unknown>,
+  block: (item: unknown, opened: Opened<R>, held: Held<I>) => Promise<unknown>,
 ) => ({ type: 'nd_each' as const })
 
-export const nd_parallel = <I, R extends string = Supplied>(
-  blocks: readonly ((hands: Handed<R>, held: Held<I>) => Promise<unknown>)[],
+export const nd_parallel = <I, R extends string = never>(
+  blocks: readonly ((opened: Opened<R>, held: Held<I>) => Promise<unknown>)[],
 ) => ({ type: 'nd_parallel' as const })
 
-export const nd_repeat = <I, R extends string = Supplied>(
+export const nd_repeat = <I, R extends string = never>(
   ceiling: number,
   block: (
     pass: number,
     carried: unknown,
-    hands: Handed<R>,
+    opened: Opened<R>,
     held: Held<I>,
   ) => Promise<{ readonly done: boolean; readonly value: unknown }>,
 ) => ({ type: 'nd_repeat' as const })
 
-export const nd_stop = <I, R extends string = Supplied>(
-  block: (hands: Reads<Handed<R>>, held: Held<I>) => Promise<unknown>,
+export const nd_stop = <I, R extends string = never>(
+  block: (opened: Reads<Opened<R>>, held: Held<I>) => Promise<unknown>,
 ) => ({ type: 'nd_stop' as const })

package/dist/operations/operations.d.ts

@@ -1,18 +1,54 @@
 import type { z } from 'zod';
+import type { Actor } from '../core/actor.ts';
 import type { Member } from '../core/thread.ts';
-import type { Handed, Row, Supplied } from './seams.ts';
+import { REACH, type Answering, type Calling, type HttpResponse, type Row, type Running, type Store } from '../integrations/target.ts';
+import type { Surface } from './capabilities.ts';
 export declare const OPERATIONS_FILE = "operations.ts";
 export declare const TRIALS_AT = "operations/_trials.json";
 export declare const NODES_FILE = "nodes.ts";
 export declare const MEMBERS_LIST = "MEMBERS";
-export interface Operation<I = unknown, R extends string = Supplied> {
+export interface Reaching {
+}
+type CallsOf<K extends string> = K extends keyof Reaching ? (Reaching[K] extends string ? Reaching[K] : string) : string;
+export type Opened<R extends string = never> = {
+    readonly actor: Actor;
+    readonly tell: (said: unknown) => void;
+} & {
+    readonly [K in R]: K extends `${typeof REACH.disk}${string}` ? Answering : K extends `${typeof REACH.cli}${string}` ? Running<CallsOf<K>> : K extends `${typeof REACH.postgres}${string}` | `${typeof REACH.pglite}${string}` | `${typeof REACH.browser}${string}` ? Store : K extends `${typeof REACH.sdk}${string}` ? Calling<CallsOf<K>> : Readonly<Record<CallsOf<K>, (given?: {
+        readonly fills?: Readonly<Record<string, string | number>>;
+        readonly json?: unknown;
+        readonly body?: Uint8Array;
+        readonly contentType?: string;
+        readonly told?: (said: unknown) => void;
+    }) => Promise<HttpResponse>>>;
+};
+export type Reads<H> = {
+    readonly [K in keyof H]: H[K] extends Store ? Pick<Store, 'get' | 'list'> : H[K];
+};
+export declare const WINDOWS: readonly ['second', 'minute', 'hour', 'day', 'week', 'month'];
+export type Window = (typeof WINDOWS)[number];
+export interface Allowance {
+    readonly runs: number;
+    readonly per: Window;
+}
+export interface Counting {
+    readonly seen: (key: string, per: Window) => Promise<number>;
+}
+export interface Operation<I = unknown, R extends string = never> {
     readonly id: string;
     readonly input: z.ZodType<I>;
     readonly requires: readonly string[];
-    readonly run: (hands: Handed<R>, held: {
+    readonly webhooks?: readonly string[];
+    readonly off?: readonly Surface[];
+    readonly signed?: boolean;
+    readonly entitled?: string;
+    readonly rate?: Allowance;
+    readonly quota?: Allowance;
+    readonly run: (opened: Opened<R>, held: {
         readonly input: I;
     } & Readonly<Record<string, unknown>>) => Promise<unknown>;
-    readonly estimate: number;
+    readonly timeout: number;
     readonly resource: (input: I) => Row | null;
 }
 export declare const OPERATIONS: readonly Member[];
+export {};