@prestack/thread 0.0.1 → 0.0.2

package/dist/integrity/slopnators/sl_stale_path.ts

@@ -0,0 +1,94 @@
+import { existsSync, readdirSync, statSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import type { Slopnator } from '../slopnator.ts'
+import { descend } from '../../core/descend.ts'
+import { findTree } from '../../core/tree.ts'
+
+const ROOT = findTree().at
+const NAMES_A_FILE = /\.[a-z]{1,5}$/
+
+/*
+ * A FILE A GENERATOR WRITES IS ABSENT UNTIL THE GENERATOR HAS RUN, AND THAT IS NOT A STALE PATH.
+ *
+ * This law and the descent disagreed about the same file, and the descent was right. A row carrying
+ * `by:` names a file a command writes; the descent reports it missing as a WARNING for exactly that
+ * reason — "a derived file is absent until it is derived". This read the same path with a bare
+ * `existsSync` and refused it, with advice — "fix the path, or delete the sentence naming it" —
+ * that would have deleted a correct declaration.
+ *
+ * Measured 2026-08-29 on a real install: `thread init`, `thread attach @thread/integrations`,
+ * `thread gate`, and the sweep was red on `_threads/glossary.ts` — a file `thread glossary` writes,
+ * on the first gate run of an app whose author had written nothing. Every other check in that gate
+ * answers this state by saying there is nothing to check yet.
+ *
+ * Read off the tree rather than guessed from the text. The descent already knows which rows carry a
+ * `by`, so the two can no longer come apart, and a path nothing derives is refused exactly as before.
+ */
+const derived = ((): ReadonlySet<string> => {
+  const found = new Set<string>()
+  try {
+    const pass = descend()
+    for (const [at, held] of pass.threaded) {
+      if (held.some((one) => one.row.by !== undefined)) found.add(at)
+    }
+    for (const one of pass.derived.values()) if (one.at !== undefined) found.add(one.at)
+  } catch {
+    /* A tree that cannot be descended is reported by the descent's own step, not swallowed here. */
+  }
+  return found
+})()
+
+const ours = (): ReadonlySet<string> => {
+  try {
+    return new Set(
+      readdirSync(ROOT).filter(
+        (one) => one !== 'node_modules' && statSync(resolve(ROOT, one), { throwIfNoEntry: false })?.isDirectory() === true,
+      ),
+    )
+  } catch {
+    return new Set()
+  }
+}
+
+export const slopnator: Slopnator = {
+  on: ['Literal'],
+  holds: (node) => {
+    const value = (node as { value?: unknown }).value
+    if (typeof value !== 'string' || !value.includes('/')) return false
+
+    const tops = ours()
+    if (tops.size === 0 || !tops.has(value.split('/')[0] ?? '')) return false
+
+    const brace = value.indexOf('{')
+    if (brace !== -1) {
+      const cut = value.lastIndexOf('/', brace)
+      const dir = cut === -1 ? '.' : value.slice(0, cut)
+      if (statSync(resolve(ROOT, dir), { throwIfNoEntry: false })?.isDirectory() === true) return false
+      return `\`${value}\` writes into \`${dir}\`, which is not a directory on disk`
+    }
+
+    if (!NAMES_A_FILE.test(value)) return false
+    if (existsSync(resolve(ROOT, value))) return false
+    if (derived.has(value)) return false
+    return `\`${value}\` is not on disk`
+  },
+  proves: {
+    wrong: [
+      "const at = 'threads/nope.ts'",
+      "const at = 'scripts/gone.ts'",
+      "const at = 'docs/nowhere/{page}.md'",
+      "const at = 'migrations/gone.sql'",
+      "const at = 'plans/gone.md'",
+    ],
+    right: [
+      "const at = 'packages/core/integrity/src/constraint.ts'",
+      "const at = 'packages/core/integrity/src/lint.ts'",
+      "const at = 'docs/reference/{page}.md'",
+      "const at = 'threads/'",
+      "const said = 'a sentence about packages/core/integrity/src/constraint.ts and nothing else'",
+      "const at = 'app/layout.tsx'",
+      "const at = 'node_modules/thread/package.json'",
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_twice_meant.ts

@@ -0,0 +1,31 @@
+import type { Slopnator } from '../slopnator.ts'
+import { here, index, meaningsIn, parses, unreadable } from './sl_unthreaded.ts'
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => {
+    const path = here(at.filename)
+    if (unreadable(path, at.text) !== undefined) return false
+    const mine = parses(path) ? meaningsIn(at.text) : []
+    if (mine.length === 0) return false
+
+    const meanings = index().meanings
+
+    for (const one of mine) {
+      const held = meanings.get(one.id)
+      if (held === undefined || held.size < 2) continue
+      return `\`${one.id}\` is coined with ${String(held.size)} different \`describes\`, and the glossary holds one meaning per word`
+    }
+    return false
+  },
+  proves: {
+    wrong: [
+      "const M: Threaded = {\n  declares: [\n    {\n      id: 'one',\n      describes: 'The first thing.',\n    },\n    {\n      id: 'one',\n      describes: 'A different thing entirely.',\n    },\n  ],\n}",
+      "const M: Threaded = {\n  declares: [\n    {\n      id: 'two',\n      describes: 'The stated meaning.',\n    },\n    {\n      id: 'two',\n    },\n  ],\n}",
+    ],
+    right: [
+      "const M: Threaded = {\n  declares: [\n    {\n      id: 'one',\n      describes: 'The first thing.',\n    },\n    {\n      id: 'one',\n      describes: 'The first thing.',\n    },\n  ],\n}",
+      "const M: Threaded = {\n  declares: [\n    {\n      id: 'one',\n      describes: 'The first thing.',\n    },\n    {\n      id: 'two',\n      describes: 'A different thing entirely.',\n    },\n  ],\n}",
+      'const M = { declares: [] }',
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_twice_parented.ts

@@ -0,0 +1,37 @@
+import type { Slopnator } from '../slopnator.ts'
+import { atsIn, here, index, parses, unreadable } from './sl_unthreaded.ts'
+
+const ONLY_DECLARES = new Set(['declares'])
+
+const declaredIn = (text: string): readonly string[] => atsIn(text, ONLY_DECLARES)
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => {
+    const path = here(at.filename)
+    if (unreadable(path, at.text) !== undefined) return false
+    const mine = parses(path) ? declaredIn(at.text) : []
+    if (mine.length === 0) return false
+
+    const threaded = index().declared
+
+    for (const claimed of mine) {
+      const times = threaded.get(claimed) ?? 0
+      if (times > 1) return `${claimed} is declared ${String(times)} times, and \`declares\` is exactly one parent ever`
+    }
+    return false
+  },
+  proves: {
+    wrong: [
+      "const M: Threaded = {\n  declares: [\n    {\n      at: 'threads/one.ts',\n    },\n    {\n      at: 'threads/one.ts',\n    },\n  ],\n}",
+      "const M: Threaded = {\n  declares: [\n    {\n      at: 'threads/two.ts',\n    },\n    {\n      at: 'threads/three.ts',\n    },\n    {\n      at: 'threads/two.ts',\n    },\n  ],\n}",
+      "const ROW = {\n  at: 'threads/one.ts',\n}\nconst M: Threaded = {\n  declares: [ROW, ROW],\n}",
+    ],
+    right: [
+      "const M: Threaded = {\n  declares: [\n    {\n      at: 'threads/one.ts',\n    },\n    {\n      at: 'threads/two.ts',\n    },\n  ],\n}",
+      "const M: Threaded = {\n  derives: [\n    {\n      at: 'threads/one.ts',\n    },\n    {\n      at: 'threads/one.ts',\n    },\n  ],\n}",
+      'const M = { declares: [] }',
+      "const ROW = {\n  at: 'threads/one.ts',\n}\nconst M: Threaded = {\n  declares: [ROW],\n}",
+      "const M: Threaded = {\n  declares: [\n    {\n      at: 'threads/one.ts',\n      declares: [\n        {\n          at: 'threads/two.ts',\n        },\n      ],\n    },\n  ],\n}",
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_undeclared_crossing.ts

@@ -0,0 +1,87 @@
+import { descend, under } from '../../core/descend.ts'
+
+import type { Slopnator } from '../slopnator.ts'
+import { here } from './sl_unthreaded.ts'
+
+interface Crossing {
+  readonly what: string
+  readonly finds: RegExp
+}
+
+const CROSSINGS: readonly Crossing[] = [
+  { what: 'the network', finds: /(?<![.\w])fetch\s*\(/ },
+  { what: 'the network', finds: /(?<![.\w])XMLHttpRequest\b/ },
+  { what: 'the clock', finds: /\bDate\s*\.\s*now\s*\(/ },
+  { what: 'the clock', finds: /\bperformance\s*\.\s*now\s*\(/ },
+  { what: 'the clock', finds: /\bsetInterval\s*\(/ },
+  { what: 'the clock', finds: /\bsetTimeout\s*\(/ },
+  { what: 'the clock', finds: /\brequestAnimationFrame\s*\(/ },
+  { what: 'randomness', finds: /\bMath\s*\.\s*random\s*\(/ },
+  { what: 'randomness', finds: /\bcrypto\s*\.\s*randomUUID\s*\(/ },
+  { what: 'the queue', finds: /\bqueue\s*\.\s*enqueue\s*\(/ },
+  { what: 'a seam', finds: /\b(?:files|llm|http)\s*\.\s*(?:call|run|complete|put|signedUrl|remove|get)\s*\(/ },
+]
+
+const OPERATIONS_ID = 'operations'
+
+const NODES_ID = 'nodes'
+
+let bodies: ReadonlySet<string> | undefined
+
+/*
+ * The files this law is about, read off the tree rather than off a path.
+ *
+ * A crossing belongs in a declared node and nowhere else, so what the law has to know is which
+ * files ARE declared nodes — every row in an operation's `seeds` that requires a node type. It
+ * cannot be a path rule: an operation seeds its node bodies and its input file into the same
+ * directory, so excepting the directory would except the input file too and leave a hole exactly
+ * one file wide per operation. Measured 2026-08-27: with the directory excepted instead, this law
+ * fired on `operations/wf_asks/asks_it.ts` — a node body calling the model its operation had
+ * declared, which is the one place the law's own `instead` sends you.
+ */
+function declared(): ReadonlySet<string> {
+  if (bodies !== undefined) return bodies
+  const pass = descend()
+  const found = new Set<string>()
+  for (const [at, threadings] of pass.threaded) {
+    for (const one of threadings) {
+      if (one.list !== 'seeds') continue
+      if (!under(pass, one.by, OPERATIONS_ID) || under(pass, one.by, NODES_ID)) continue
+      if ((one.row.requires ?? []).length === 0) continue
+      found.add(at)
+    }
+  }
+  bodies = found
+  return found
+}
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => {
+    if (declared().has(here(at.filename))) return false
+    for (const crossing of CROSSINGS) {
+      if (!crossing.finds.test(at.text)) continue
+      return (
+        `${crossing.what} reached outside a declared node — nothing recorded this crossing, so it ` +
+        'cannot be replayed, retried, priced or unwound, and the page renders exactly the same either way'
+      )
+    }
+    return false
+  },
+  proves: {
+    wrong: [
+      "const res = await fetch('https://api.stripe.com/v1/charges')",
+      'const at = Date.now()',
+      'const id = crypto.randomUUID()',
+      "await queue.enqueue('job', payload)",
+      "await files.put('receipt.pdf', bytes)",
+      'const t = setInterval(() => refetch(), 5000)',
+      'const t = setTimeout(function again() { refetch(); setTimeout(again, 5000) }, 5000)',
+      'window.requestAnimationFrame(step)',
+    ],
+    right: [
+      "const node = { id: 'st_charge', kind: 'action', action: 'payment.charge', declares: { seams: ['http'] } }",
+      'const rows = useRead(recentOrders)',
+      "const { data } = useRead(recentOrders, { refresh: 'every-5s' })",
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_undeclared_destination.ts

@@ -0,0 +1,65 @@
+import type { Slopnator } from '../slopnator.ts'
+
+interface Held {
+  readonly type?: string
+  readonly name?: unknown
+  readonly value?: unknown
+  readonly computed?: boolean
+  readonly object?: Held
+  readonly property?: Held
+  readonly key?: Held
+}
+
+const HREF = 'href'
+const GLOBALS = new Set(['window', 'globalThis', 'self'])
+const HISTORIES = new Set(['router', 'navigation', 'history'])
+const MOVES = new Set(['push', 'replace', 'prefetch'])
+
+const named = (held: Held | undefined): string | undefined => {
+  if (held?.type === 'Identifier' || held?.type === 'JSXIdentifier') return typeof held.name === 'string' ? held.name : undefined
+  if (held?.type === 'Literal' && typeof held.value === 'string') return held.value
+  return undefined
+}
+
+const spoken = (held: Held): string | undefined => {
+  if (held.type === 'JSXAttribute') return named(held.name as Held | undefined)
+  if (held.type === 'Property') return held.computed === true ? undefined : named(held.key)
+  return undefined
+}
+
+function moving(held: Held): string | undefined {
+  if (held.type !== 'MemberExpression' || held.computed === true) return undefined
+  const on = named(held.object)
+  const reached = named(held.property)
+  if (on === undefined || reached === undefined) return undefined
+  if (GLOBALS.has(on) && reached === 'location') return `${on}.location`
+  if (HISTORIES.has(on) && MOVES.has(reached)) return `${on}.${reached}()`
+  return undefined
+}
+
+export const slopnator: Slopnator = {
+  on: ['JSXAttribute', 'Property', 'MemberExpression'],
+  holds: (node) => {
+    const held = node as Held
+    const written = spoken(held) === HREF ? '`href`' : moving(held)
+    if (written === undefined) return false
+    return (
+      `${written} moves somebody without naming a screen, so the map holds no link for it — ` +
+      'the destination reads as unreachable to the orphan pass, the app reads as having no path to it, and it navigates correctly'
+    )
+  },
+  proves: {
+    wrong: [
+      "const link = { href: '/orders/42' }",
+      "window.location = '/orders/42'",
+      "router.push('/orders/42')",
+      'history.replace(next)',
+      'navigation.prefetch(next)',
+    ],
+    right: [
+      '<Link.label navigateTo="Home" labelKey="home.title" />',
+      "const to = { navigateTo: 'Order', labelKey: 'order.title' }",
+      'const rows = orders.push(one)',
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_undeclared_element.ts

@@ -0,0 +1,44 @@
+import type { Slopnator } from '../slopnator.ts'
+
+interface Tag {
+  readonly type?: string
+  readonly name?: unknown
+  readonly namespace?: { readonly name?: unknown }
+}
+
+const HOST = /^[a-z]/
+
+function tagOf(node: unknown): string | undefined {
+  const name = (node as { name?: Tag } | undefined)?.name
+  if (name?.type === 'JSXNamespacedName') {
+    const space = typeof name.namespace?.name === 'string' ? name.namespace.name : ''
+    const local = typeof (name.name as Tag | undefined)?.name === 'string' ? String((name.name as Tag).name) : ''
+    return `${space}:${local}`
+  }
+  if (name?.type !== 'JSXIdentifier') return undefined
+  return typeof name.name === 'string' ? name.name : undefined
+}
+
+export const slopnator: Slopnator = {
+  on: ['JSXOpeningElement'],
+  holds: (node) => {
+    const tag = tagOf(node)
+    if (tag === undefined || !HOST.test(tag)) return false
+    return (
+      `<${tag}> is a host element, so it wears no declared style, sits in no catalogue, and the style guide, ` +
+      'a rebrand and every overlay read past it — it renders and nothing downstream knows it is there'
+    )
+  },
+  proves: {
+    wrong: [
+      '<div className="row" />',
+      '<button onClick={save}>save</button>',
+      '<svg:path d="M0 0" />',
+    ],
+    right: [
+      '<Box.card />',
+      '<Column>{rows}</Column>',
+      '<Button.buttonPrimary label="save" />',
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_undeclared_node.ts

@@ -0,0 +1,69 @@
+import { dirname, join, normalize } from 'node:path'
+
+import type { Slopnator } from '../slopnator.ts'
+import { here, index, parses, unreadable } from './sl_unthreaded.ts'
+
+/*
+ * Every string this file writes, whatever it writes it for.
+ *
+ * The first reading matched `node: '<name>'`, which was the shape when an operation named its node
+ * in a string beside a step of its own; a node builds its own span now, so that matched nothing on
+ * any real file. The second matched `import … from '<path>'`, which was the one route anybody had
+ * thought of — and a dynamic `import()`, a `require()` and an `export … from` each walked straight
+ * through it, measured on a real tree. Enumerating the ways in is how a refusal ends up as a list of
+ * whatever somebody happened to try. What matters is the path, not the syntax carrying it.
+ */
+const SAID = /'((?:[^'\\\n]|\\.)*)'|"((?:[^"\\\n]|\\.)*)"|`((?:[^`\\$]|\\.)*)`/g
+
+const RELATIVE = /^\.\.?\//
+
+const UNDER = 'nodes/'
+
+const slash = (one: string): string => one.split('\\').join('/')
+
+function nodeAt(said: string, from: string): string | undefined {
+  if (said === '') return undefined
+  const path = slash(normalize(RELATIVE.test(said) ? join(from, said) : said))
+  return path.startsWith(UNDER) ? path : undefined
+}
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => {
+    const path = here(at.filename)
+    if (unreadable(path, at.text) !== undefined) return false
+    if (!parses(path)) return false
+
+    const declared = index().reached
+    const from = dirname(path)
+
+    for (const found of String(at.text).matchAll(SAID)) {
+      const named = nodeAt(found[1] ?? found[2] ?? found[3] ?? '', from)
+      if (named === undefined || declared.has(named)) continue
+
+      return (
+        `this reaches \`${named}\`, and the descent from the tree root never arrives there — so one of ` +
+        'its steps is a node nobody declared. An operation that takes a step nothing agreed to is doing ' +
+        'something this app never said it could do, and the flow reads as agreed the whole way down'
+      )
+    }
+
+    return false
+  },
+  proves: {
+    wrong: [
+      "import { node as ghost } from '../nodes/nd_ghost.ts'",
+      "const held = await import('../nodes/nd_ghost.ts')",
+      "const held = require('../nodes/nd_ghost.ts')",
+      "export { node as ghost } from '../nodes/nd_ghost.ts'",
+      "const AT = '../nodes/nd_ghost.ts'",
+      "import { node as invented } from 'nodes/nd_nowhere.ts'",
+    ],
+    right: [
+      "import { node as read } from '../nodes/nd_read.ts'",
+      "import { node as action } from '../nodes/nd_action.ts'\nimport { node as read } from '../nodes/nd_read.ts'",
+      "import { z } from 'zod'",
+      "import type { Operation } from '../../operations/operations.ts'",
+      "import type { Held } from '../../operations/nodes.ts'",
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_undeclared_operation.ts

@@ -0,0 +1,147 @@
+import type { Slopnator } from '../slopnator.ts'
+
+import { descend, read, reached } from '../../core/descend.ts'
+
+import { rowsIn } from './sl_unthreaded.ts'
+
+const UNDER = 'operations/'
+
+const DISPATCH = 'dispatch'
+
+function declared(): ReadonlySet<string> {
+  const found = new Set<string>()
+
+  descend()
+
+  for (const at of reached()) {
+    const text = read(at)
+    if (text === undefined) continue
+
+    for (const one of rowsIn(text)) {
+      const where = one.at?.split('\\').join('/')
+      if (where === undefined || !where.includes(UNDER)) continue
+      if (one.id !== undefined) found.add(one.id)
+      const named = where.split('/').at(-1)?.replace(/\.[^.]+$/, '')
+      if (named !== undefined) found.add(named)
+    }
+  }
+
+  return found
+}
+
+interface Called {
+  readonly callee?: { readonly type?: string; readonly name?: string; readonly property?: { readonly type?: string; readonly name?: string } }
+  readonly arguments?: readonly { readonly type?: string; readonly value?: unknown; readonly name?: string }[]
+}
+
+export const slopnator: Slopnator = {
+  on: ['CallExpression'],
+  holds: (node) => {
+    const call = node as Called | undefined
+    const callee = call?.callee
+    const named =
+      callee?.type === 'Identifier'
+        ? callee.name
+        : callee?.property?.type === 'Identifier'
+          ? callee.property.name
+          : undefined
+    if (named !== DISPATCH) return false
+
+    const first = call?.arguments?.[0]
+    if (first === undefined) {
+      return (
+        'dispatch is called with nothing to dispatch, so no operation is named and none can be found — the name ' +
+        'is the whole of what makes an operation reachable'
+      )
+    }
+
+    /*
+     * THE OPERATION ITSELF IS A BETTER ANSWER THAN ITS NAME, AND THIS USED TO REFUSE IT.
+     *
+     * This asked for a string literal and refused everything else, which was right when the only
+     * caller was a UI seam handed a bare name. It has been wrong since dispatch stopped taking one:
+     * the note above says so in as many words — "`dispatch` in packages/core/operations/src/dispatch.ts
+     * takes an Operation object rather than a name". What ships now imports the compiled operation
+     * and hands over the binding, and a binding cannot be assembled at run time: if it named nothing,
+     * the file would not compile.
+     *
+     * Measured 2026-08-31 on a registry install: an operations-only app, everything made by the CLI,
+     * failed its own sweep on `operations/_client.ts` — a file its own generator had just written,
+     * naming an operation the same tree declares. The gate refuses the build now, so a law that
+     * refuses a generated file is an app that cannot ship.
+     *
+     * Narrow on purpose. An identifier is accepted only when it IS one of the declared operations,
+     * which is the shape the generators emit — `import { operation as wf_charge }` and then
+     * `dispatch(wf_charge, …)`. A variable holding a computed name is still refused, because it does
+     * not match a declaration, and that is the hole this law was written for.
+     */
+    const all = declared()
+
+    if (first.type === 'Identifier' && typeof first.name === 'string') {
+      if (all.has(first.name)) return false
+      return (
+        `dispatch is handed \`${first.name}\`, and nothing declares an operation by that name. A binding is only ` +
+        'checkable when it is the operation — import the compiled operation and hand that over, so what runs and ' +
+        'what was declared are the same thing rather than two things that agree today'
+      )
+    }
+
+    if (first.type !== 'Literal' || typeof first.value !== 'string') {
+      return (
+        'dispatch is handed a name this file does not write down, so nothing can hold it against what is declared. ' +
+        'A name assembled at runtime reads from every check exactly like a name that was checked and found — the ' +
+        'operation is reachable and no declaration was ever consulted'
+      )
+    }
+
+    if (all.has(first.value)) return false
+
+    return (
+      `dispatch names \`${String(first.value)}\` and nothing declares an operation by that name, so this reaches for ` +
+      'something that does not exist and fails where a person is waiting rather than where it was written. ' +
+      (all.size === 0
+        ? 'Nothing declares an operation at all, so no name would have been accepted — the declaration is what has to change'
+        : `Declared: ${[...all].sort().join(', ')}`)
+    )
+  },
+  proves: {
+    wrong: [
+      {
+        files: [
+          {
+            at: 'threads/_probe_operations.ts',
+            source:
+              "export const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      at: 'operations/wf_send_invoice.ts',\n    },\n  ],\n}\n",
+          },
+          { at: 'app/_probe_unknown.tsx', source: "export const HELD = dispatch('wf_not_declared')\n" },
+        ],
+        at: 'app/_probe_unknown.tsx',
+      },
+      {
+        files: [
+          {
+            at: 'threads/_probe_operations.ts',
+            source:
+              "export const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      at: 'operations/wf_send_invoice.ts',\n    },\n  ],\n}\n",
+          },
+          { at: 'app/_probe_built.tsx', source: "export const HELD = dispatch(`wf_${name}`)\n" },
+        ],
+        at: 'app/_probe_built.tsx',
+      },
+    ],
+    right: [
+      {
+        files: [
+          {
+            at: 'threads/_probe_operations.ts',
+            source:
+              "export const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      at: 'operations/wf_send_invoice.ts',\n    },\n  ],\n}\n",
+          },
+          { at: 'app/_probe_known.tsx', source: "export const HELD = dispatch('wf_send_invoice')\n" },
+        ],
+        at: 'app/_probe_known.tsx',
+      },
+      "export const HELD = translate('order.place')",
+    ],
+  },
+}