@prestack/thread 0.1.20 → 0.1.22

package/dist/operations/access.ts

@@ -1,131 +0,0 @@
-import type { Actor } from '../core/actor.ts'
-import { mentionsActor, walkOperands, type Condition } from '../core/condition.ts'
-import type { Member } from '../core/thread.ts'
-
-export const PERMITS_AT = 'src/_generated/permits.ts'
-
-export function declaredWords(
-  entities: readonly {
-    readonly holds: readonly { readonly id: string; readonly options?: readonly string[] }[]
-    readonly actor?: { readonly roles: string; readonly entitlements?: string }
-  }[],
-  which: 'roles' | 'entitlements',
-  everybody: string,
-): readonly string[] {
-  const found = entities.flatMap((one) => {
-    const at = one.actor?.[which]
-    return at === undefined ? [] : (one.holds.find((each) => each.id === at)?.options ?? [])
-  })
-  return [...new Set(which === 'roles' ? [everybody, ...found] : found)]
-}
-
-export function undeclared(answered: string, offers: readonly string[], which: 'roles' | 'entitlements'): string | undefined {
-  const stray = answered
-    .split(',')
-    .map((one) => one.trim())
-    .filter((one) => one !== '' && !offers.includes(one))
-  if (stray.length === 0) return undefined
-
-  return (
-    `this app declares no ${which === 'roles' ? 'role' : 'entitlement'} called ${stray.map((one) => `\`${one}\``).join(', ')} — ` +
-    (offers.length === 0
-      ? `it declares none at all. A ${which === 'roles' ? 'role' : 'entitlement'} is one of the words the value an ` +
-        'entity names as saying what a caller may do is held to. Declare them with `thread create entity edit` — ' +
-        'name that value, give it the `choice` format, and state its options'
-      : `it declares ${offers.map((one) => `\`${one}\``).join(', ')}`)
-  )
-}
-
-export interface Declaring {
-  readonly id: string
-  readonly holds: readonly { readonly id: string; readonly options?: readonly string[] }[]
-  readonly rows?: readonly Record<string, unknown>[]
-  readonly must?: readonly { readonly unique?: readonly string[] }[]
-  readonly actor?: { readonly roles: string; readonly entitlements?: string }
-}
-
-export interface Caller {
-  readonly id: string
-  readonly entity: string
-  readonly roles: readonly string[]
-  readonly entitlements: readonly string[]
-}
-
-export const keyIn = (one: Declaring): string | undefined =>
-  (one.must ?? []).flatMap((each) => (each.unique?.length === 1 ? [each.unique[0] as string] : []))[0]
-
-const wordsFrom = (held: unknown): readonly string[] => {
-  if (typeof held === 'string') return [held]
-  if (Array.isArray(held)) return held.filter((each): each is string => typeof each === 'string')
-  return []
-}
-
-export const declaredCallers = (entities: readonly Declaring[]): readonly Caller[] =>
-  entities.flatMap((one) => {
-    const said = one.actor
-    const key = keyIn(one)
-    if (said === undefined || key === undefined) return []
-    return (one.rows ?? []).flatMap((row): readonly Caller[] => {
-      const named = row[key]
-      if (typeof named !== 'string') return []
-      return [
-        {
-          id: named,
-          entity: one.id,
-          roles: wordsFrom(row[said.roles]),
-          entitlements: said.entitlements === undefined ? [] : wordsFrom(row[said.entitlements]),
-        },
-      ]
-    })
-  })
-
-export interface Grant extends Member {
-
-  readonly may: readonly string[]
-
-  readonly on?: string
-
-  readonly to?: {
-    readonly roles?: Actor['roles']
-    readonly entitlements?: Actor['entitlements']
-  }
-
-  readonly when?: Condition
-}
-
-export function opensToEverybody(grants: readonly Grant[]): readonly Grant[] {
-  return grants.filter((one) => one.to === undefined && (one.when === undefined || !mentionsActor(one.when)))
-}
-
-export function grantedTwice(grants: readonly Grant[]): readonly string[] {
-  const seen = new Set<string>()
-  const twice = new Set<string>()
-  for (const one of grants) {
-    if (seen.has(one.id)) twice.add(one.id)
-    seen.add(one.id)
-  }
-  return [...twice].sort()
-}
-
-function operandsOf(one: Grant): readonly string[] {
-  if (one.when === undefined) return []
-  const found: string[] = []
-  walkOperands(one.when, (each) => {
-    if ('agg' in each) found.push('agg')
-    if ('was' in each) found.push('was')
-    if ('outer' in each) found.push('outer')
-  })
-  return found
-}
-
-export function unanswerable(grants: readonly Grant[]): readonly string[] {
-  return grants.flatMap((one) => {
-    const held = [...new Set(operandsOf(one))]
-    if (held.length === 0) return []
-    const why = held.includes('agg')
-      ? 'it counts other rows, and a gate is asked about the one in front of it. Put the aggregate in an invariant on the entity, where it runs against the rows themselves'
-      : 'it reads a value as it was before the write, and at the moment this is asked the write has not happened. Only an invariant, which runs on the write itself, can see a before'
-    return [`\`${one.id}\` states a condition this gate cannot answer — ${why}`]
-  })
-}
-

package/dist/operations/attach.ts

@@ -1,408 +0,0 @@
-import type { Attaching } from '../core/attach.ts'
-import { SHAPED } from '../core/init.ts'
-import { NAMED, named } from '../core/scope.ts'
-
-import { LISTS } from '../core/descend.ts'
-import { quoted } from '../core/rows.ts'
-import type { Threaded } from '../core/thread.ts'
-
-import { PERMITS_AT } from './access.ts'
-import { ACTOR_AT, CAPABILITIES_AT, CLIENT_AT, DEFAULTS_AT, DISPATCHING_AT, MCP_AT, OPENAPI_AT, REACHING_AT } from './capabilities.ts'
-import { DISPATCH_AT } from './dispatch.ts'
-import { TRIALS_AT } from './operations.ts'
-import { MEMBERS_LIST, NODES_FILE, OPERATIONS_FILE } from './operations.ts'
-
-const HOME = `node_modules/${named('operations')}/dist`
-
-const VERSION = 1
-
-const ROOT = 'operations'
-
-const NODES_AT = '_threads/nodes.ts'
-
-const OPERATIONS_AT = '_threads/operations.ts'
-
-const DESCRIBES =
-  'Everything this app can be asked to do. Each operation is a named job built from steps, and every one of them runs the same way. Add one with `thread create operation`.'
-
-export const TAKES =
-  'What one operation needs before it will run: the shape of its input, what it is expected to cost, and who is allowed to ask for it. Written once when the operation is created, then yours to change.'
-
-export const WOVEN =
-  'The operation written out as one function. `thread compile` builds it from the steps declared for it, so nothing here is edited by hand — anything added here is gone the next time it is compiled.'
-
-const NODES =
-  'Every kind of step an operation can be built from — a read, a branch, a loop. A step holds no code of its own: the work goes in a file written beside the operation that uses it.'
-
-const DISPATCH =
-  'Every operation runs through here and nowhere else. `thread compile` writes it for this app: before a run starts it checks who is asking, what the run may cost and whether the input is valid, then runs the operation and records what happened.'
-
-const PROGRAM =
-  'Every row this package adds to an app, listed in one place so what it put there can be read rather than guessed at. `thread attach` writes back anything missing or edited.'
-
-const TRIALS =
-  'What each operation actually did when it was run, recorded rather than written by hand. `thread trials` runs them against their example inputs and keeps the results; `thread trials --check` runs them again and refuses anything that has changed since.'
-
-const CAPABILITIES =
-  'Which of this app\'s operations can be reached from outside, and how — as an MCP tool, a terminal command, or a web route. Everything here is worked out, and nothing here is yours to set: which surfaces are on comes from _threads/defaults.ts and from `off` on each operation row, and `thread create capability` changes either.'
-
-const OPENAPI =
-  'This app\'s web API written as an OpenAPI document: the route, the verb and the input shape of every operation that answers on the web. Generated rather than written, so it cannot describe a route that is not there.'
-
-const TOOLS =
-  'The tools an MCP client is offered: every operation switched on for that surface, with its own sentence and the shape of its input. Switching `mcp` off for an operation is how an agent is told it may not call it.'
-
-const CLIENT =
-  'Every operation a page in this app may call. An operation that is switched off is absent from this file rather than listed and disabled, as is any operation needing a credential a browser must not hold.'
-
-const CALLER =
-  'Who is asking, worked out from the request itself. It reads the header or cookie that the entity naming people says carries their token, looks that person up, and answers with their id, their roles and what they hold — or with nobody, when the request carries none. What the request brought with it, the run, the address, the device, is carried through either way. Nobody edits it, because an edit here decides who somebody is, and that comes from the declarations.'
-
-const REACHING =
-  'Every place this app declared it reaches, opened and ready, each carrying only the calls its own row names. It is written from the targets, the calls and the secrets already in the tree, so an operation reaches a place by naming it and never writes a url, a connection string or the name of an environment variable. Nobody edits it, because an edit here hands an operation something no declaration granted.'
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-const valued = (one: unknown): string => {
-  if (typeof one === 'string') return quoted(one)
-  if (Array.isArray(one)) return `[${one.map((each) => valued(each)).join(', ')}]`
-  if (typeof one === 'object' && one !== null) {
-    return `{ ${Object.entries(one).map(([key, held]) => `${key}: ${valued(held)}`).join(', ')} }`
-  }
-  return String(one)
-}
-
-export const said = (one: Threaded, pad: string): string => {
-  const { declares, derives, seeds, ...plain } = one
-  const lines = [`${pad}{`]
-  for (const [key, held] of Object.entries(plain)) lines.push(`${pad}  ${key}: ${valued(held)},`)
-  for (const list of LISTS) {
-    const held = one[list]
-    if (held === undefined) continue
-    lines.push(`${pad}  ${list}: [`)
-    for (const child of held) lines.push(said(child, `${pad}    `))
-    lines.push(`${pad}  ],`)
-  }
-  return [...lines, `${pad}},`].join('\n')
-}
-
-const ACCESS =
-  'Who may ask this app to do what. A row says which operations it permits, on what, to whom, and under what condition. Nothing is permitted by default: an operation no row grants here cannot be run at all.'
-
-const PERMITS =
-  'The check compiled from the grants in _threads/access.ts: one branch per grant, so who may ask for what comes from one statement. Nobody edits it, because an edit here widens or narrows access nobody granted. An app that grants nothing permits nothing.'
-
-const ACCESS_SOURCE = `import type { Grant } from '${NAMED}/operations/access'
-
-export const GRANTS: readonly Grant[] = []
-`
-
-const DEFAULTS =
-  'Which surfaces every operation in this app answers on, stated once for all of them. An operation turns one off with `off` on its own row and can never turn on one this row leaves off. With no `live` stated, every operation answers on cli alone, so nothing is reachable from outside the machine until this row says so. `thread create capability edit defaults` changes it.'
-
-const DEFAULTS_SOURCE = `import type { Defaults } from '${NAMED}/operations/capabilities'
-
-export const DEFAULTS: Defaults = {
-  id: 'defaults',
-  at: ${quoted(DEFAULTS_AT)},
-  describes: ${quoted(DEFAULTS)},
-  version: ${String(VERSION)},
-}
-`
-
-const shipped = (): Threaded => ({
-  id: 'shipped',
-  at: `${HOME}/attach.js`,
-  describes: PROGRAM,
-  version: VERSION,
-  declares: [
-    {
-      id: 'operations',
-      at: OPERATIONS_AT,
-      describes: DESCRIBES,
-      version: VERSION,
-    },
-    {
-      id: 'nodes',
-      at: NODES_AT,
-      describes: NODES,
-      version: VERSION,
-    },
-    {
-      id: 'access',
-      at: '_threads/access.ts',
-      describes: ACCESS,
-      version: VERSION,
-    },
-    {
-      id: 'defaults',
-      at: DEFAULTS_AT,
-      describes: DEFAULTS,
-      version: VERSION,
-    },
-    {
-      id: 'permits',
-      at: PERMITS_AT,
-      describes: PERMITS,
-      version: VERSION,
-      by: 'thread permits',
-      runs: 'thread permits --check',
-    },
-    {
-      id: 'dispatch',
-      at: DISPATCH_AT,
-      describes: DISPATCH,
-      version: VERSION,
-      by: 'thread compile',
-      runs: 'thread compile --check',
-    },
-    {
-      id: 'trials',
-      at: TRIALS_AT,
-      describes: TRIALS,
-      version: VERSION,
-      by: 'thread trials',
-      runs: 'thread trials --check',
-    },
-    {
-      id: 'capabilities',
-      at: CAPABILITIES_AT,
-      describes: CAPABILITIES,
-      version: VERSION,
-      by: 'thread capabilities',
-      runs: 'thread capabilities --check',
-    },
-    {
-      id: 'openapi',
-      at: OPENAPI_AT,
-      describes: OPENAPI,
-      version: VERSION,
-      by: 'thread capabilities',
-      runs: 'thread capabilities --check',
-    },
-    {
-      id: 'tools',
-      at: MCP_AT,
-      describes: TOOLS,
-      version: VERSION,
-      by: 'thread capabilities',
-      runs: 'thread capabilities --check',
-    },
-    {
-      id: 'client',
-      at: CLIENT_AT,
-      describes: CLIENT,
-      version: VERSION,
-      by: 'thread capabilities',
-      runs: 'thread capabilities --check',
-    },
-    {
-      id: 'dispatching',
-      at: DISPATCHING_AT,
-
-      describes:
-        'The operations this app declares, named wherever something reaches one. The framework ships an empty list and each app widens it, so a name written at a call site is accepted only when this app declared an operation by it.',
-      version: VERSION,
-      by: 'thread capabilities',
-      runs: 'thread capabilities --check',
-    },
-    {
-      id: 'caller',
-      at: ACTOR_AT,
-      describes: CALLER,
-      version: VERSION,
-      by: 'thread capabilities',
-      runs: 'thread capabilities --check',
-    },
-    {
-      id: 'reaching',
-      at: REACHING_AT,
-      describes: REACHING,
-      version: VERSION,
-      by: 'thread capabilities',
-      runs: 'thread capabilities --check',
-    },
-    {
-      id: 'nd_read',
-      at: NODES_AT,
-      describes: 'A node that only reads. It is handed the store and the search and nothing else, so it cannot write — the fetch an operation does before it decides anything.',
-      version: VERSION,
-    },
-    {
-      id: 'nd_action',
-      at: NODES_AT,
-      describes: 'A node that changes something — a write, a call out, a spend. It is handed everything, and it is where an operation keeps its effects rather than spreading them across the flow.',
-      version: VERSION,
-    },
-    {
-      id: 'nd_branch',
-      at: NODES_AT,
-      describes: 'A node that chooses. Its first block returns a name, and the way with that name is what runs, so a fork in the flow is visible in the declaration instead of buried in an if.',
-      version: VERSION,
-    },
-    {
-      id: 'nd_each',
-      at: NODES_AT,
-      describes: 'A node that runs once per item, in order, one at a time. Its block is handed a single item and never the collection, so it cannot reorder them or batch them behind your back.',
-      version: VERSION,
-    },
-    {
-      id: 'nd_parallel',
-      at: NODES_AT,
-      describes: 'A step that runs several blocks at once and answers when all of them have. They cannot see each other, so use it for work that does not depend on itself.',
-      version: VERSION,
-    },
-    {
-      id: 'nd_repeat',
-      at: NODES_AT,
-      describes: 'A step that runs its block again until the block says it is done — a retry, or an agent loop. A limit is required, so it cannot run forever.',
-      version: VERSION,
-    },
-    {
-      id: 'nd_stop',
-      at: NODES_AT,
-      describes: 'A step that ends the operation early with an answer. Whatever its block returns becomes the result, and nothing after it runs.',
-      version: VERSION,
-    },
-
-  ],
-})
-
-const SHIPS = shipped()
-
-const WHERE: Readonly<Record<string, { readonly into: string; readonly list: string }>> = {
-  nodes: { into: OPERATIONS_FILE, list: 'declares' },
-
-  dispatch: { into: OPERATIONS_FILE, list: 'declares' },
-  access: { into: OPERATIONS_FILE, list: 'declares' },
-  defaults: { into: OPERATIONS_FILE, list: 'declares' },
-  permits: { into: OPERATIONS_FILE, list: 'declares' },
-  trials: { into: OPERATIONS_FILE, list: 'declares' },
-  capabilities: { into: OPERATIONS_FILE, list: 'declares' },
-  openapi: { into: OPERATIONS_FILE, list: 'declares' },
-  tools: { into: OPERATIONS_FILE, list: 'declares' },
-  client: { into: OPERATIONS_FILE, list: 'declares' },
-  dispatching: { into: OPERATIONS_FILE, list: 'declares' },
-  caller: { into: OPERATIONS_FILE, list: 'declares' },
-  reaching: { into: OPERATIONS_FILE, list: 'declares' },
-}
-
-const placed = (id: string): { readonly into: string; readonly list: string } =>
-  WHERE[id] ?? { into: NODES_FILE, list: MEMBERS_LIST }
-
-const NODES_SOURCE = `import type { Threaded } from '${SHAPED}'
-import type { Node } from '${NAMED}/operations/nodes'
-
-export const NODES: Threaded = {
-  id: 'nodes',
-  at: ${quoted(NODES_AT)},
-  describes: ${quoted(NODES)},
-  version: ${String(VERSION)},
-  declares: [],
-}
-
-export const ${MEMBERS_LIST}: readonly Node[] = []
-`
-
-const OPERATIONS_SOURCE = `import type { Threaded } from '${SHAPED}'
-import type { OperationMember } from '${NAMED}/operations/operations'
-
-export const OPERATIONS: Threaded = {
-  id: 'operations',
-  at: ${quoted(OPERATIONS_AT)},
-  describes: ${quoted(DESCRIBES)},
-  version: ${String(VERSION)},
-  declares: [],
-}
-
-export const ${MEMBERS_LIST}: readonly OperationMember[] = []
-`
-
-const SEEDED = {
-  attaches: ['@prestack/thread/derivation/attach'] as const,
-  id: 'operations',
-  declares: [
-    '    {',
-    '      id: \'operations\',',
-    '      at: \'_threads/operations.ts\',',
-    '      describes: \'Everything this app can be asked to do. Each operation is a named job built from steps, and every one of them runs the same way. Add one with `thread create operation`.\',',
-    '      version: 1,',
-    '    },',
-  ].join('\n'),
-}
-
-const SHIPPED: readonly { readonly into: string; readonly list: string; readonly id: string; readonly source: string }[] = [
-  {
-    into: 'derivation.ts',
-    list: 'GENERATORS',
-    id: 'capability-generator',
-    source: "  {\n    id: 'capability-generator',\n    at: 'node_modules/@prestack/thread/dist/operations/generators/capability.js',\n    describes: 'Writes what can be reached and how, and refuses it once it has drifted. It reads each operation for its name, what it does and the shape of its input, so adding or renaming one changes what is reachable without anybody editing a list.',\n    version: 1,\n    by: 'thread capabilities',\n    runs: 'thread capabilities --check',\n  },",
-  },
-  {
-    into: 'derivation.ts',
-    list: 'GENERATORS',
-    id: 'seed-generator',
-    source: "  {\n    id: 'seed-generator',\n    at: 'node_modules/@prestack/thread/dist/operations/generators/seed.js',\n    describes: 'Writes every file an operation puts on disk. The wrapper around each step comes from the rows; the code inside it is yours and is put back untouched. Anything that no longer matches what it writes is refused, so a step cannot be added by editing the file.',\n    version: 1,\n    by: 'thread seed',\n    runs: 'thread seed --check',\n  },",
-  },
-  {
-    into: 'derivation.ts',
-    list: 'GENERATORS',
-    id: 'compile-generator',
-    source: "  {\n    id: 'compile-generator',\n    at: 'node_modules/@prestack/thread/dist/operations/generators/compile.js',\n    describes: 'Turns an operation\\'s steps into one function: each block bound where it is used, and each branch or loop written out as the real thing. What it writes imports nothing from this framework, so what ships is plain code.',\n    version: 1,\n    by: 'thread compile',\n    runs: 'thread compile --check',\n  },",
-  },
-  {
-    into: 'derivation.ts',
-    list: 'GENERATORS',
-    id: 'permits-generator',
-    source: "  {\n    id: 'permits-generator',\n    at: 'node_modules/@prestack/thread/dist/operations/generators/permits.js',\n    describes: 'Writes the check this app runs before any operation — one branch per grant, so who may ask for what comes from one statement rather than being repeated in every handler. It refuses a grant it cannot check honestly, such as one that would admit a caller nobody authenticated.',\n    version: 1,\n    by: 'thread permits',\n    runs: 'thread permits --check',\n  },",
-  },
-  {
-    into: 'derivation.ts',
-    list: 'GENERATORS',
-    id: 'trial-generator',
-    source: "  {\n    id: 'trial-generator',\n    at: 'node_modules/@prestack/thread/dist/operations/generators/trial.js',\n    describes: 'Records what an operation does, and refuses it once it has changed. It runs the compiled operation through this app\\'s own dispatch, so what is checked is the code that ships. Time and randomness are pinned, so a run can be repeated.',\n    version: 1,\n    by: 'thread trials',\n    runs: 'thread trials --check',\n  },",
-  },
-]
-export const ATTACH: Attaching = {
-  attaches: SEEDED.attaches,
-  id: SEEDED.id,
-  declares: SEEDED.declares,
-  writes: [
-    { file: OPERATIONS_FILE, source: OPERATIONS_SOURCE },
-    { file: NODES_FILE, source: NODES_SOURCE },
-
-    { file: 'access.ts', source: ACCESS_SOURCE },
-    { file: 'defaults.ts', source: DEFAULTS_SOURCE },
-  ],
-
-  rows: [
-    ...(SHIPS.declares ?? [])
-      .filter((one) => one.id !== ROOT)
-      .map((one) => {
-        const where = placed(one.id)
-        return { into: where.into, list: where.list, id: one.id, source: said(one, where.list === 'declares' ? '    ' : '  ') }
-      }),
-    ...SHIPPED,
-  ],
-}

package/dist/operations/capabilities.ts

@@ -1,88 +0,0 @@
-import type { Threaded } from '../core/thread.ts'
-
-export const SURFACES = ['cli', 'api', 'mcp', 'webhook'] as const
-
-export type Surface = (typeof SURFACES)[number]
-
-export const isSurface = (one: string): one is Surface => (SURFACES as readonly string[]).includes(one)
-
-export const MEANS: Readonly<Record<Surface, string>> = {
-  cli: 'a command a terminal runs',
-  api: 'a route a request arrives on, and the OpenAPI document written from it. An operation that does not answer on api has no route file and no route row at all',
-  mcp: 'a tool an agent is offered. Switch this off and an AI actor cannot call the operation, while everything else about it goes on working',
-  webhook: 'an address something outside posts to, once a webhook row invokes the operation and the operation names it back',
-}
-
-export const DEFAULTS_AT = '_threads/defaults.ts'
-
-export const UNSTATED: readonly Surface[] = ['cli']
-
-export interface Defaults extends Threaded {
-  readonly live?: readonly Surface[]
-}
-
-export const CAPABILITIES_AT = 'operations/_capabilities.json'
-
-export const CLIENT_AT = 'operations/_client.ts'
-
-export const DISPATCHING_AT = 'app/_generated/dispatching.ts'
-
-export const COMPILED = 'app/_generated/compiled'
-
-export const CHECKED_AT = `${COMPILED}/ui/checked.ts`
-
-export const REACHING_AT = 'src/_generated/reaching.ts'
-
-export const ACTOR_AT = 'src/_generated/actor.ts'
-
-export const routeAt = (operation: string): string => `app/operations/${operation}/route.ts`
-
-export const ROUTE =
-  "The file that answers a request for this one operation. It imports the operation by name, hands it to this app's own dispatch along with what this app hands its operations and the caller worked out from the request, and answers with the result — or with the status matching whatever dispatch refused it for. One per operation rather than one for all of them: a route that looked its operation up by a name off the path would hand dispatch something no check had ever seen, which reads exactly like a name that was checked. An operation that does not answer on api, because its own row turns api off or the defaults sheet leaves it off, has neither this file nor this row: `thread capabilities` takes both out, so it is not served at all rather than served and turned away."
-
-export const inboundAt = (webhook: string): string => `app/inbound/${webhook}/route.ts`
-
-export const OPENAPI_AT = 'operations/_openapi.json'
-
-export const MCP_AT = 'operations/_mcp.json'
-
-export interface Capability {
-  readonly operation: string
-  readonly describes: string
-  readonly requires: readonly string[]
-  readonly nodes: readonly string[]
-  readonly input: unknown
-
-  readonly live: readonly Surface[]
-
-  readonly webhooks: readonly string[]
-
-  readonly signed: boolean
-
-  readonly browsable: boolean
-
-  readonly mcp: { readonly name: string; readonly description: string; readonly inputSchema: unknown }
-  readonly cli: { readonly invocation: string; readonly describes: string }
-  readonly api: { readonly method: 'GET' | 'POST'; readonly path: string }
-}
-
-export const reachable = (one: Capability, surface: Surface): boolean => one.live.includes(surface)
-
-export function switched(text: string | undefined): ReadonlyMap<string, readonly Surface[]> {
-  const found = new Map<string, readonly Surface[]>()
-  if (text === undefined || text.trim() === '') return found
-  let held: unknown
-  try {
-    held = JSON.parse(text)
-  } catch {
-    return found
-  }
-  if (!Array.isArray(held)) return found
-  for (const one of held) {
-    if (typeof one !== 'object' || one === null) continue
-    const row = one as { readonly operation?: unknown; readonly live?: unknown }
-    if (typeof row.operation !== 'string' || !Array.isArray(row.live)) continue
-    found.set(row.operation, row.live.filter((each): each is Surface => typeof each === 'string' && isSurface(each)))
-  }
-  return found
-}