@prestack/thread 0.1.3 → 0.1.5

package/dist/integrations/disk.ts

@@ -0,0 +1,465 @@
+import * as disk from 'node:fs'
+import { basename, dirname, isAbsolute, relative, resolve } from 'node:path'
+import { env, pid } from 'node:process'
+
+import { ORDERS, type Answer, type Attached, type Answering, type Kind, type Listed, type Measured, type Order, type Ran } from '../integrations/target.ts'
+
+export type { Answering, Kind, Listed, Measured, Ran } from '../integrations/target.ts'
+
+export const CHANNEL = 'THREAD_CHANNEL'
+
+export const FOLDER = 'THREAD_FOLDER'
+
+const WAITING = 180_000
+
+const WORKING = 600_000
+
+const ASKING = '-asking'
+
+const ORDER = '-order'
+
+const ANSWER = '-answer'
+
+function overFiles(dir: string): Attached {
+  const idle = new Int32Array(new SharedArrayBuffer(4))
+  let spun = 0
+
+  const ask = (body: Order): Answer => {
+    spun += 1
+    const name = dir + '/' + String(pid) + '-' + String(spun)
+    const long = body.order === 'fetch' ? true : body.order === 'run'
+    const waits = long ? WORKING : WAITING
+    disk.writeFileSync(name + ASKING, JSON.stringify(body))
+    disk.renameSync(name + ASKING, name + ORDER)
+    const until = Date.now() + waits
+    for (;;) {
+      let held = ''
+      try {
+        held = disk.readFileSync(name + ANSWER, 'utf8')
+      } catch {
+        held = ''
+      }
+      if (held !== '') {
+        disk.rmSync(name + ANSWER, { force: true })
+        const said = JSON.parse(held) as Answer
+        if (said.answered === 'refused') throw new Error(String(said.because))
+        return said
+      }
+      if (Date.now() > until) {
+        throw new Error(
+          'nothing answered ' + body.order + ' ' + body.at + ' for ' + String(Math.round(waits / 60_000)) +
+            ' minutes, so this stopped waiting rather than spinning forever. Whoever was answering is gone. ' +
+            'Nothing here is half-written: one order is one file, and it was either answered or it was not.',
+        )
+      }
+      Atomics.wait(idle, 0, 0, 2)
+    }
+  }
+
+  const took = (body: Order): Answer => {
+    const said = ask(body)
+    const want = ORDERS[body.order]
+    if (said.answered !== want) {
+      throw new Error(
+        body.order + ' ' + body.at + ' was answered as ' + said.answered + ', and that order is answered as ' + want +
+          '. Whatever answered is not the copy of prestack this server sends orders to.',
+      )
+    }
+    return said
+  }
+
+  const kinds = new Map<string, Kind>()
+  const listed = new Map<string, readonly Listed[]>()
+  const reals = new Map<string, string>()
+
+  const listing = (at: string): readonly Listed[] => {
+    const held = listed.get(at)
+    if (held !== undefined) return held
+    const found = took({ order: 'list', at }).found as readonly Listed[]
+    listed.set(at, found)
+    return found
+  }
+
+  const kindOf = (at: string): Kind => {
+    const held = kinds.get(at)
+    if (held !== undefined) return held
+    const up = dirname(at)
+    if (up !== at && across(up)) {
+      const one = kindOf(up) === 'folder' ? listing(up).find((each) => each.name === basename(at)) : undefined
+      if (one === undefined) {
+        kinds.set(at, 'none')
+        return 'none'
+      }
+      if (one.kind !== 'other') {
+        kinds.set(at, one.kind)
+        return one.kind
+      }
+    }
+    const found = took({ order: 'kind', at }).found as Kind
+    kinds.set(at, found)
+    return found
+  }
+
+  const wrote = (at: string): void => {
+    kinds.set(at, 'file')
+    for (let child = at, up = dirname(at); up !== child && across(up); child = up, up = dirname(up)) {
+      const inside = listed.get(up)
+      if (inside !== undefined && !inside.some((each) => each.name === basename(child))) {
+        listed.set(up, [...inside, { name: basename(child), kind: child === at ? 'file' : 'folder' }])
+      }
+      kinds.set(up, 'folder')
+    }
+  }
+
+  const removed = (at: string): void => {
+    for (const key of [...kinds.keys()]) if (key.startsWith(at + '/')) kinds.delete(key)
+    for (const key of [...listed.keys()]) if (key === at || key.startsWith(at + '/')) listed.delete(key)
+    reals.clear()
+    kinds.set(at, 'none')
+    const inside = listed.get(dirname(at))
+    if (inside !== undefined) listed.set(dirname(at), inside.filter((each) => each.name !== basename(at)))
+  }
+
+  const unknown = (): void => {
+    kinds.clear()
+    listed.clear()
+    reals.clear()
+  }
+
+  return {
+    kind: kindOf,
+    read: (at) => String(took({ order: 'read', at }).said),
+    write: (at, said, mode) => {
+      took(mode === undefined ? { order: 'write', at, said } : { order: 'write', at, said, mode })
+      wrote(at)
+    },
+    list: listing,
+    stat: (at) => took({ order: 'stat', at }).found as Measured,
+    remove: (at) => {
+      took({ order: 'remove', at })
+      removed(at)
+    },
+    real: (at) => {
+      const held = reals.get(at)
+      if (held !== undefined) return held
+      const found = String(took({ order: 'real', at }).at)
+      reals.set(at, found)
+      return found
+    },
+    fetch: (at) => {
+      try {
+        return String(took({ order: 'fetch', at }).said)
+      } finally {
+        unknown()
+      }
+    },
+    run: (at, words) => {
+      try {
+        return took({ order: 'run', at, words }).found as Ran
+      } finally {
+        unknown()
+      }
+    },
+  }
+}
+
+const seam: { held?: Attached } = {}
+
+const WHERE = env[CHANNEL]
+
+if (WHERE !== undefined && WHERE !== '') seam.held = overFiles(WHERE)
+
+export function answeredBy(one?: Attached): void {
+  seam.held = one
+}
+
+const placed = (at: string): string => {
+  const root = env[FOLDER] ?? ''
+  return root === '' ? at : resolve(root, at)
+}
+
+const within = (root: string, at: string): boolean => {
+  const step = relative(resolve(root), resolve(root, at))
+  return step === '' || (!step.startsWith('..') && !isAbsolute(step))
+}
+
+export function across(at: string): boolean {
+  const root = env[FOLDER] ?? ''
+  return seam.held !== undefined && root !== '' && within(root, at)
+}
+
+export function beyond(at: string): boolean {
+  const root = env[FOLDER] ?? ''
+  return seam.held !== undefined && root !== '' && !within(root, at)
+}
+
+function asked(at: unknown): Attached | undefined {
+  const one = seam.held
+  if (one === undefined) return undefined
+  const root = env[FOLDER] ?? ''
+  if (root === '') return typeof at === 'string' ? one : undefined
+  if (typeof at !== 'string') {
+    throw new Error('a path given as anything but text cannot be held to ' + root + ', the folder this answers for, so it was not used.')
+  }
+  if (within(root, at)) return one
+  throw new Error(
+    at + ' is outside ' + root + ', the folder this answers for. A command answering for a folder on another machine ' +
+      'reaches that folder and nothing else, so nothing was read, written or removed.',
+  )
+}
+
+export function attached(): boolean {
+  return seam.held !== undefined
+}
+
+export function here(): Attached {
+  return seam.held ?? HERE
+}
+
+export function kind(at: string): Kind {
+  const one = asked(at)
+  return one === undefined ? HERE.kind(at) : one.kind(placed(at))
+}
+
+export function existsSync(at: disk.PathLike): boolean {
+  return typeof at === 'string' ? kind(at) !== 'none' : asked(at) === undefined && disk.existsSync(at)
+}
+
+export function readFileSync(at: disk.PathOrFileDescriptor, how?: BufferEncoding): string {
+  const one = asked(at)
+  return one === undefined ? disk.readFileSync(at, how ?? 'utf8') : one.read(placed(at as string))
+}
+
+export function writeFileSync(
+  at: disk.PathOrFileDescriptor,
+  said: string,
+  how?: BufferEncoding | { readonly encoding?: BufferEncoding; readonly mode?: number },
+): void {
+  const held = how === undefined || typeof how === 'string' ? { encoding: how, mode: undefined } : how
+  const one = asked(at)
+  if (one !== undefined) {
+    one.write(placed(at as string), said, held.mode)
+    return
+  }
+  if (typeof at === 'string') disk.mkdirSync(dirname(at), { recursive: true })
+  disk.writeFileSync(at, said, { encoding: held.encoding ?? 'utf8', ...(held.mode === undefined ? {} : { mode: held.mode }) })
+}
+
+export function createFileSync(at: string, said: string): boolean {
+  if (asked(at) !== undefined) {
+    throw new Error(at + ' is on a machine that answers orders, and only a file on this machine can be created for one command alone.')
+  }
+  disk.mkdirSync(dirname(at), { recursive: true })
+  try {
+    disk.writeFileSync(at, said, { encoding: 'utf8', flag: 'wx' })
+    return true
+  } catch (thrown) {
+    if ((thrown as NodeJS.ErrnoException).code === 'EEXIST') return false
+    throw thrown
+  }
+}
+
+export interface Named {
+  readonly name: string
+  readonly isFile: () => boolean
+  readonly isDirectory: () => boolean
+}
+
+export function readdirSync(at: disk.PathLike): string[]
+export function readdirSync(at: disk.PathLike, how: { readonly withFileTypes: true }): readonly Named[]
+export function readdirSync(at: disk.PathLike, how?: { readonly withFileTypes: true }): string[] | readonly Named[] {
+  const one = asked(at)
+  if (one === undefined) return how === undefined ? disk.readdirSync(at) : disk.readdirSync(at, how)
+  const held = one.list(placed(at as string))
+  return how === undefined
+    ? held.map((each) => each.name)
+    : held.map((each) => ({ name: each.name, isFile: () => each.kind === 'file', isDirectory: () => each.kind === 'folder' }))
+}
+
+export interface Held extends Named, Measured {
+  readonly mtimeMs: number
+}
+
+export function statSync(at: disk.PathLike): Held
+export function statSync(at: disk.PathLike, how: { readonly throwIfNoEntry: false }): Held | undefined
+export function statSync(at: disk.PathLike, how?: { readonly throwIfNoEntry: false }): Held | undefined {
+  const one = asked(at)
+  if (one === undefined) return (how === undefined ? disk.statSync(at) : disk.statSync(at, how)) as Held | undefined
+  const path = placed(at as string)
+  const held = one.kind(path)
+  if (held === 'none') {
+    if (how !== undefined) return undefined
+    throw new Error(`${path} is not there, so nothing can be said about it.`)
+  }
+  const measured = one.stat(path)
+  return {
+    name: path,
+    size: measured.size,
+    modified: measured.modified,
+    mtimeMs: measured.modified,
+    isFile: () => held === 'file',
+    isDirectory: () => held === 'folder',
+  }
+}
+
+export function rmSync(at: disk.PathLike, how?: disk.RmOptions): void {
+  const one = asked(at)
+  if (one === undefined) disk.rmSync(at, how)
+  else one.remove(placed(at as string))
+}
+
+export function rmdirSync(at: disk.PathLike): void {
+  const one = asked(at)
+  if (one === undefined) disk.rmdirSync(at)
+  else one.remove(placed(at as string))
+}
+
+export function renameSync(from: disk.PathLike, to: disk.PathLike): void {
+  const one = asked(from)
+  if (one === undefined) {
+    if (typeof to === 'string') disk.mkdirSync(dirname(to), { recursive: true })
+    disk.renameSync(from, to)
+    return
+  }
+  asked(to)
+  one.write(placed(to as string), one.read(placed(from as string)))
+  one.remove(placed(from as string))
+}
+
+export function appendFileSync(at: disk.PathOrFileDescriptor, said: string): void {
+  const one = asked(at)
+  if (one === undefined) {
+    disk.appendFileSync(at, said)
+    return
+  }
+  const path = placed(at as string)
+  one.write(path, `${one.kind(path) === 'none' ? '' : one.read(path)}${said}`)
+}
+
+export function realpathSync(at: disk.PathLike): string {
+  const one = asked(at)
+  return one === undefined ? disk.realpathSync(at as string) : one.real(placed(at as string))
+}
+
+const FILES_ONLY = ' is on this disk, and a disk holds files. '
+
+export const HERE: Attached = {
+  kind: (at) => {
+    let held: disk.Stats | undefined
+    try {
+      held = disk.statSync(at, { throwIfNoEntry: false })
+    } catch (thrown) {
+      if ((thrown as NodeJS.ErrnoException).code === 'ERR_ACCESS_DENIED') return 'none'
+      throw thrown
+    }
+    if (held === undefined) return 'none'
+    return held.isFile() ? 'file' : held.isDirectory() ? 'folder' : 'other'
+  },
+  read: (at) => disk.readFileSync(at, 'utf8'),
+  write: (at, said, mode) => {
+    disk.mkdirSync(dirname(at), { recursive: true })
+    disk.writeFileSync(at, said, { encoding: 'utf8', ...(mode === undefined ? {} : { mode }) })
+  },
+  list: (at) =>
+    disk.readdirSync(at, { withFileTypes: true }).map((one) => ({
+      name: one.name,
+      kind: one.isFile() ? 'file' : one.isDirectory() ? 'folder' : 'other',
+    })),
+  stat: (at) => {
+    const held = disk.statSync(at)
+    return { size: held.size, modified: held.mtimeMs }
+  },
+  remove: (at) => {
+    if (disk.lstatSync(at, { throwIfNoEntry: false })?.isDirectory() === true) disk.rmdirSync(at)
+    else disk.rmSync(at)
+  },
+  real: (at) => disk.realpathSync(at),
+  fetch: (at) => {
+    throw new Error(at + FILES_ONLY + 'Installing what a tree depends on happens where somebody typed the command, so it cannot be ordered of this disk.')
+  },
+  run: (at) => {
+    throw new Error(at + FILES_ONLY + 'A program is started where somebody typed the command, so running one cannot be ordered of this disk.')
+  },
+}
+
+const GONE = 'is not in the scenario this trial stands, and while it runs the scenario is the whole tree.'
+
+const MADE_UP = 'a trial answers orders against a tree it made up, so there is nowhere here to '
+
+export function standing(root: string, given: ReadonlyMap<string, string>): Attached {
+  const flat = (at: string): string => {
+    let path = at
+    while (path.length > 1 && path.endsWith('/')) path = path.slice(0, -1)
+    return path
+  }
+  const under = (at: string): boolean => at.startsWith(root) || `${at}/` === root
+  const own = (at: string): boolean => under(at) && !at.slice(root.length).split('/').includes('node_modules')
+  const beside = (at: string): readonly Listed[] => {
+    try {
+      return HERE.list(at)
+    } catch {
+      return []
+    }
+  }
+
+  const held = new Map<string, string>(given)
+  const folders = new Set<string>()
+  const parents = (at: string): void => {
+    for (let up = dirname(at); under(`${up}/`); up = dirname(up)) folders.add(up)
+  }
+  for (const at of held.keys()) parents(at)
+
+  const answers: Answering = {
+    kind: (at) => (held.has(at) ? 'file' : folders.has(at) ? 'folder' : own(at) ? 'none' : HERE.kind(at)),
+    read: (at) => {
+      const said = held.get(at)
+      if (said !== undefined) return said
+      if (own(at)) throw new Error(`${at} ${GONE}`)
+      return HERE.read(at)
+    },
+    write: (at, said) => {
+      held.set(at, said)
+      parents(at)
+    },
+    list: (at) => {
+      const inside = new Map<string, Listed>()
+      const found = own(at) ? [] : folders.has(at) ? beside(at) : HERE.list(at)
+      for (const one of found) inside.set(one.name, { name: one.name, kind: one.kind === 'folder' ? 'folder' : 'file' })
+      for (const path of folders) if (dirname(path) === at) inside.set(basename(path), { name: basename(path), kind: 'folder' })
+      for (const path of held.keys()) if (dirname(path) === at) inside.set(basename(path), { name: basename(path), kind: 'file' })
+      return [...inside.values()]
+    },
+    stat: (at) => {
+      const said = held.get(at)
+      if (said !== undefined) return { size: said.length, modified: 0 }
+      if (folders.has(at)) return { size: 0, modified: 0 }
+      if (own(at)) throw new Error(`${at} ${GONE}`)
+      return HERE.stat(at)
+    },
+    remove: (at) => {
+      held.delete(at)
+      folders.delete(at)
+    },
+    real: (at) => (own(at) || held.has(at) || folders.has(at) ? at : HERE.real(at)),
+  }
+
+  return {
+    kind: (at) => answers.kind(flat(at)),
+    read: (at) => answers.read(flat(at)),
+    write: (at, said) => {
+      answers.write(flat(at), said)
+    },
+    list: (at) => answers.list(flat(at)),
+    stat: (at) => answers.stat(flat(at)),
+    remove: (at) => {
+      answers.remove(flat(at))
+    },
+    real: (at) => answers.real(flat(at)),
+    fetch: () => {
+      throw new Error(MADE_UP + 'install anything into.')
+    },
+    run: () => {
+      throw new Error(MADE_UP + 'run anything in.')
+    },
+  }
+}

package/dist/integrations/generators/read.js

@@ -1,8 +1,8 @@
-import { stdout } from 'node:process';
-import { exit } from "../../core/invoked.js";
-import { TYPED, wordsIn } from "../../core/answers.js";
-import { descend } from "../../core/descend.js";
-const words = wordsIn([]);
+import { argv, stdout } from 'node:process';
+import { exit } from '../../core/invoked.js';
+import { descend } from '../../core/descend.js';
+import { THING as TYPED } from '../../core/scope.js';
+const words = argv.slice(2).filter((one) => !one.startsWith('-'));
 const looking = words.join(' ').trim().toLowerCase();
 const pass = descend();
 const said = (one) => (one.describes ?? '').replace(/\s+/g, ' ');
@@ -14,7 +14,7 @@ const carries = (one, list, file) => {
 };
 const shown = (one, list, pad, alone = false) => {
     const marks = [
-        ...(one.by === undefined ? [] : [`written by \`${one.by}\``]),
+        ...(one.by === undefined ? [] : [`${list === 'stated' ? 'answers' : 'written by'} \`${one.by}\``]),
         ...(one.runs === undefined ? [] : [`checked by \`${one.runs}\``]),
         ...((one.requires ?? []).length === 0 ? [] : [`requires ${(one.requires ?? []).join(', ')}`]),
         ...((one.takes ?? []).length === 0 ? [] : [`takes ${(one.takes ?? []).join(', ')}`]),

package/dist/integrations/generators/read.ts

@@ -1,10 +1,10 @@
-import { stdout } from 'node:process'
+import { argv, stdout } from 'node:process'
 
 import { exit } from '../../core/invoked.ts'
-import { TYPED, wordsIn } from '../../core/answers.ts'
 import { descend, type Row } from '../../core/descend.ts'
+import { THING as TYPED } from '../../core/scope.ts'
 
-const words = wordsIn([])
+const words = argv.slice(2).filter((one) => !one.startsWith('-'))
 
 const looking = words.join(' ').trim().toLowerCase()
 
@@ -20,7 +20,7 @@ const carries = (one: Row, list: string, file: string): boolean => {
 
 const shown = (one: Row, list: string, pad: string, alone = false): readonly string[] => {
   const marks = [
-    ...(one.by === undefined ? [] : [`written by \`${one.by}\``]),
+    ...(one.by === undefined ? [] : [`${list === 'stated' ? 'answers' : 'written by'} \`${one.by}\``]),
     ...(one.runs === undefined ? [] : [`checked by \`${one.runs}\``]),
     ...((one.requires ?? []).length === 0 ? [] : [`requires ${(one.requires ?? []).join(', ')}`]),
     ...((one.takes ?? []).length === 0 ? [] : [`takes ${(one.takes ?? []).join(', ')}`]),

package/dist/integrations/generators/vault.js

@@ -1,21 +1,19 @@
-import { existsSync, readFileSync, writeFileSync } from "../../core/files.js";
-import { valuesIn } from "../../core/rows.js";
+import { existsSync, readFileSync, writeFileSync } from '../disk.js';
+import { valuesIn } from '../../core/rows.js';
 import { dirname, join, relative } from 'node:path';
 import { argv, stderr, stdout } from 'node:process';
-import { fileURLToPath } from 'node:url';
 import ts from 'typescript';
-import { exit } from "../../core/invoked.js";
-import { named as packageOf } from "../../core/scope.js";
-import { findTree, inTree, strayFiles } from "../../core/tree.js";
-import { unclassified, valued } from "../secret.js";
-import { refusals, servesBrowser } from "../target.js";
-import { ALGORITHM, KEY_BYTES, KEY_NAME, SEALED_AT, SEALED_NAME, VAULT_DIR } from "../vault.js";
+import { exit } from '../../core/invoked.js';
+import { named as packageOf } from '../../core/scope.js';
+import { findTree, inTree, strayFiles } from '../../core/tree.js';
+import { unclassified, valued } from '../secret.js';
+import { refusals, servesBrowser } from '../target.js';
+import { ALGORITHM, KEY_BYTES, KEY_NAME, SEALED_AT, SEALED_NAME, VAULT_DIR } from '../vault.js';
 const TREE = findTree();
 const AT = 'src/vault.ts';
 const here = (one) => relative(TREE.at, one).split('\\').join('/');
 const from = inTree(TREE, 'secrets.ts');
 const path = join(TREE.at, AT);
-const toward = relative(dirname(path), fileURLToPath(new URL('../vault.ts', import.meta.url))).split('\\').join('/');
 const declares = relative(dirname(path), from).split('\\').join('/');
 const sheet = declares.startsWith('.') ? declares : `./${declares}`;
 function refuse(because) {
@@ -148,12 +146,13 @@ async function reaching() {
 }
 async function stated() {
     const targets = await taken('targets.ts', 'TARGETS');
+    const integrations = await taken('targets.ts', 'INTEGRATIONS');
     const calls = await taken('targets.ts', 'CALLS');
     const entities = (await taken('entities.ts', 'ENTITIES')).map((one) => one.id);
     return [
         ...unclassified(secrets),
         ...valued(secrets),
-        ...refusals(targets, secrets, calls, entities),
+        ...refusals(targets, secrets, calls, entities, integrations),
         ...(await reaching()),
     ];
 }

package/dist/integrations/generators/vault.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from '../../core/files.ts'
+import { existsSync, readFileSync, writeFileSync } from '../disk.ts'
 import { valuesIn } from '../../core/rows.ts'
 import { dirname, join, relative } from 'node:path'
 import { argv, stderr, stdout } from 'node:process'
@@ -11,7 +11,7 @@ import { named as packageOf } from '../../core/scope.ts'
 import { findTree, inTree, strayFiles } from '../../core/tree.ts'
 
 import { unclassified, valued, type Secret } from '../secret.ts'
-import { refusals, servesBrowser, type Call, type Target } from '../target.ts'
+import { refusals, servesBrowser, type Call, type Integration, type Target } from '../target.ts'
 import { ALGORITHM, KEY_BYTES, KEY_NAME, SEALED_AT, SEALED_NAME, VAULT_DIR } from '../vault.ts'
 
 const TREE = findTree()
@@ -24,8 +24,6 @@ const from = inTree(TREE, 'secrets.ts')
 
 const path = join(TREE.at, AT)
 
-const toward = relative(dirname(path), fileURLToPath(new URL('../vault.ts', import.meta.url))).split('\\').join('/')
-
 const declares = relative(dirname(path), from).split('\\').join('/')
 
 const sheet = declares.startsWith('.') ? declares : `./${declares}`
@@ -160,12 +158,13 @@ async function reaching(): Promise<readonly string[]> {
 
 async function stated(): Promise<readonly string[]> {
   const targets = await taken<Target>('targets.ts', 'TARGETS')
+  const integrations = await taken<Integration>('targets.ts', 'INTEGRATIONS')
   const calls = await taken<Call>('targets.ts', 'CALLS')
   const entities = (await taken<{ readonly id: string }>('entities.ts', 'ENTITIES')).map((one) => one.id)
   return [
     ...unclassified(secrets),
     ...valued(secrets),
-    ...refusals(targets, secrets, calls, entities),
+    ...refusals(targets, secrets, calls, entities, integrations),
     ...(await reaching()),
   ]
 }

package/dist/{operations/http.d.ts → integrations/https.d.ts}

@@ -1,4 +1,4 @@
-import type { Http } from './seams.ts';
+import type { Http, HttpRequest, HttpResponse } from './target.ts';
 export declare const HTTP_CALL_ACTION = "http.call";
 export declare class HttpNotConfiguredError extends Error {
     constructor();
@@ -7,12 +7,15 @@ export declare class OutwardTransportError extends Error {
     readonly target: string;
     constructor(target: string, cause: unknown);
 }
+export declare const refusedPath: (path: string) => string | undefined;
 export declare function outwardUrl(target: string, address: string, path: string): URL;
-export interface HttpSeamOptions {
-    readonly transport?: typeof fetch;
-    readonly timeoutMs?: number;
+export interface HttpOptions {
+    readonly timeout?: number;
 }
-export declare function httpSeam(options?: HttpSeamOptions): Http;
+export declare const STREAMED = "application/x-ndjson";
+export declare const TOLD = "told";
+export declare function called(request: HttpRequest, options?: HttpOptions): Promise<HttpResponse>;
+export declare function sendingHttp(options?: HttpOptions): Http;
 export interface RecordedCall {
     readonly target: string;
     readonly method: string;
@@ -25,6 +28,7 @@ export interface ScriptedAnswer {
     readonly headers?: Readonly<Record<string, string>>;
     readonly body?: string;
 }
-export declare function recordingHttp(script?: Readonly<Record<string, ScriptedAnswer>>): Http & {
+export type Scripted = ScriptedAnswer | readonly ScriptedAnswer[];
+export declare function recordingHttp(script?: Readonly<Record<string, Scripted>>): Http & {
     readonly calls: readonly RecordedCall[];
 };