@prestack/thread 0.1.3 → 0.1.5

package/dist/derivation/generators/release.ts

@@ -1,10 +1,9 @@
 import { join } from 'node:path'
 import { argv, stderr, stdout } from 'node:process'
 
-import { marked, wordsIn } from '../../core/answers.ts'
-import { existsSync, readFileSync, writeFileSync } from '../../core/files.ts'
+import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
 import { exit, invoked } from '../../core/invoked.ts'
-import { valuesIn } from '../../core/rows.ts'
+import { marked, valuesIn } from '../../core/rows.ts'
 import { ours } from '../../core/scope.ts'
 import { findTree, inTree } from '../../core/tree.ts'
 
@@ -17,8 +16,12 @@ const MANIFEST = 'package.json'
 interface Row {
   readonly id?: string
   readonly at?: string
+  readonly derives?: readonly Row[]
 }
 
+const addressed = (rows: readonly Row[]): readonly string[] =>
+  rows.flatMap((one) => [...(one.at === undefined ? [] : [one.at]), ...addressed(one.derives ?? [])])
+
 const mark = (one: Row): string => marked([one.id ?? '', one.at ?? ''])
 
 function releases(): readonly Row[] {
@@ -32,46 +35,44 @@ function releases(): readonly Row[] {
   }
 }
 
-function named(): readonly string[] {
-  const at = inTree(TREE, 'secrets.ts')
-  if (!existsSync(at)) return []
+function manager(): string {
   try {
-    const held = valuesIn(readFileSync(at, 'utf8')) as { SECRETS?: readonly { readonly id: string }[] }
-    return (held.SECRETS ?? []).map((one) => one.id.toUpperCase()).sort()
+    const held = JSON.parse(readFileSync(join(TREE.at, MANIFEST), 'utf8')) as { packageManager?: unknown }
+    const said = typeof held.packageManager === 'string' ? held.packageManager.split('@')[0] : undefined
+    return said === undefined || said === '' ? 'npm' : said
   } catch {
-    return []
+    return 'npm'
   }
 }
 
 function scripted(): { readonly build: string; readonly start: string } {
-  try {
-    const held = JSON.parse(readFileSync(join(TREE.at, MANIFEST), 'utf8')) as {
-      scripts?: Readonly<Record<string, string>>
-    }
-    const scripts = held.scripts ?? {}
-    return {
-      build: scripts['build'] === undefined ? 'npm run build' : 'npm run build',
-      start: scripts['start'] === undefined ? 'npm start' : 'npm start',
-    }
-  } catch {
-    return { build: 'npm run build', start: 'npm start' }
-  }
+  const tool = manager()
+  return { build: `${tool} run build`, start: tool === 'npm' ? 'npm start' : `${tool} start` }
 }
 
 function dockerfile(build: string, start: string): string {
+  const tool = manager()
+  const corepack = tool === 'npm' ? [] : ['RUN corepack enable']
+  const lock = tool === 'npm' ? 'package-lock.json*' : `${tool}-lock.yaml*`
+  const first =
+    tool === 'npm'
+      ? 'RUN npm ci --omit=dev --ignore-scripts || npm install --omit=dev --ignore-scripts'
+      : `RUN ${tool} install --prod --frozen-lockfile --ignore-scripts || ${tool} install --prod --ignore-scripts`
+  const all = tool === 'npm' ? 'RUN npm install --ignore-scripts' : `RUN ${tool} install --ignore-scripts`
+
   return [
-    '# GENERATED by thread — do not edit. It is derived from what this app declares.',
-    '',
     'FROM node:22-slim AS build',
     'WORKDIR /app',
-    'COPY package.json package-lock.json* ./',
-    'RUN npm ci --omit=dev --ignore-scripts || npm install --omit=dev --ignore-scripts',
+    ...corepack,
+    `COPY package.json ${lock} ./`,
+    first,
     'COPY . .',
-    'RUN npm install --ignore-scripts',
+    all,
     `RUN ${build}`,
     '',
     'FROM node:22-slim',
     'WORKDIR /app',
+    ...corepack,
     'ENV NODE_ENV=production',
     'COPY --from=build /app ./',
     `EXPOSE ${String(LISTENS)}`,
@@ -80,22 +81,22 @@ function dockerfile(build: string, start: string): string {
   ].join('\n')
 }
 
-function compose(id: string, secrets: readonly string[]): string {
+function compose(id: string): string {
   return [
-    '# GENERATED by thread — do not edit. It is derived from what this app declares.',
-    '',
     'services:',
     `  ${id}:`,
     '    build: .',
     '    ports:',
     `      - "${String(LISTENS)}:${String(LISTENS)}"`,
-    ...(secrets.length === 0
-      ? []
-      : [
-          '    environment:',
+    '',
+  ].join('\n')
+}
 
-          ...secrets.map((one) => `      ${one}: \${${one}}`),
-        ]),
+function withheld(): string {
+  return [
+    '.thread',
+    'node_modules',
+    '.git',
     '',
   ].join('\n')
 }
@@ -103,7 +104,6 @@ function compose(id: string, secrets: readonly string[]): string {
 function made(): ReadonlyMap<string, string> {
   const found = new Map<string, string>()
   const rows = releases()
-  const secrets = named()
   const { build, start } = scripted()
 
   for (const one of rows) {
@@ -113,7 +113,8 @@ function made(): ReadonlyMap<string, string> {
     if (kind === undefined) continue
     if (kind === 'docker') {
       found.set('Dockerfile', dockerfile(build, start))
-      found.set('compose.yaml', compose(id, secrets))
+      found.set('compose.yaml', compose(id))
+      found.set('.dockerignore', withheld())
     }
   }
   return found
@@ -138,7 +139,14 @@ function run(): number {
     return 0
   }
 
-  const words = wordsIn(['read'])
+  const words = argv.slice(2).filter((one) => !one.startsWith('-'))
+  if (words[0] !== undefined && words[0] !== 'read') {
+    stderr.write(
+      'release: `' + words[0] + '` is not something this command does. `thread release` writes the release, and ' +
+        '`thread release read <mark>` prints one. Nothing was written.\n',
+    )
+    return 1
+  }
   if (words[0] === 'read') {
     const which = words[1]
     const one = rows.find((row) => mark(row) === which)
@@ -153,10 +161,10 @@ function run(): number {
 
     const kind = kindOf(one.id ?? '')
     stdout.write(`${String(one.id)} — ${kind === undefined ? 'a release of a kind this generator does not recognise' : SAID[kind]}\n`)
-    for (const file of kind === undefined ? [] : WRITES[kind]) {
-      stdout.write(`\n${file}\n`)
+    for (const one of kind === undefined ? [] : WRITES[kind]) {
+      stdout.write(`\n${one.at} — ${one.describes}\n`)
       try {
-        stdout.write(readFileSync(join(TREE.at, file), 'utf8'))
+        stdout.write(readFileSync(join(TREE.at, one.at), 'utf8'))
       } catch {
         stdout.write('(nothing is there)\n')
       }
@@ -167,6 +175,19 @@ function run(): number {
   const files = made()
   const checking = argv.includes('--check')
 
+  const stated = new Set(addressed(rows))
+  const stray = [...files.keys()].filter((one) => !stated.has(one))
+  if (stray.length > 0) {
+    stderr.write(
+      `release: this release produces ${stray.join(', ')}, and no row names ${stray.length === 1 ? 'it' : 'them'}. ` +
+        `Writing ${stray.length === 1 ? 'it' : 'them'} would leave a file this tree does not declare, and the descent ` +
+        'reports that three steps later as a file nobody can account for. Take the release out with `thread remove ' +
+        '<its id>` and declare it again — the maker writes one row per file this kind produces, so all of them arrive ' +
+        'together. Nothing was written.\n',
+    )
+    return 1
+  }
+
   const shipped = installed()
   if (shipped.length > 0) {
     stderr.write(
@@ -202,8 +223,10 @@ function run(): number {
 
   for (const [at, text] of files) writeFileSync(join(TREE.at, at), text, 'utf8')
   stdout.write(
-    `release: wrote ${[...files.keys()].join(', ')} — built and started by what this app's own manifest ` +
-      `declares, listening on ${String(LISTENS)}, naming ${String(named().length)} secret(s) and holding none of them.\n`,
+    'release: wrote ' + [...files.keys()].join(', ') + ' — built and started by what this app\'s own manifest ' +
+      'declares, listening on ' + String(LISTENS) + '.\n' +
+      'release: no secret is named there. A secret is read from the sealed store at the moment it is used, and ' +
+      'naming it here would be telling whoever deploys this to put a credential in the environment instead.\n',
   )
   return 0
 }

package/dist/derivation/release.d.ts

@@ -1,8 +1,12 @@
 export declare const PREFIXES: {
-    readonly docker: "dk_";
+    readonly docker: 'dk_';
 };
-export declare const KINDS: readonly ["docker"];
-export declare const WRITES: Readonly<Record<(typeof KINDS)[number], readonly string[]>>;
+export declare const KINDS: readonly ['docker'];
+export interface Written {
+    readonly at: string;
+    readonly describes: string;
+}
+export declare const WRITES: Readonly<Record<(typeof KINDS)[number], readonly Written[]>>;
 export declare const LISTENS = 3000;
 export declare const SAID: Readonly<Record<(typeof KINDS)[number], string>>;
 export declare const kindOf: (id: string) => (typeof KINDS)[number] | undefined;

package/dist/derivation/release.js

@@ -1,7 +1,20 @@
 export const PREFIXES = { docker: 'dk_' };
 export const KINDS = ['docker'];
 export const WRITES = {
-    docker: ['Dockerfile', 'compose.yaml'],
+    docker: [
+        {
+            at: 'Dockerfile',
+            describes: 'How this app becomes an image and what starts it inside one — the build and start commands its own manifest declares, run with the package manager that manifest names, and the port its server listens on.',
+        },
+        {
+            at: 'compose.yaml',
+            describes: 'What runs the image this release builds, named beside it because one row states one address.',
+        },
+        {
+            at: '.dockerignore',
+            describes: 'What a build of this image must never carry out of this directory: the sealed store and the key that opens it, the installed packages, and the history. Without it the build copies everything beside it, and every sealed value goes into the image and into whoever pulls it.',
+        },
+    ],
 };
 export const LISTENS = 3000;
 export const SAID = {

package/dist/derivation/release.ts

@@ -4,8 +4,28 @@ export const PREFIXES = { docker: 'dk_' } as const
 
 export const KINDS = ['docker'] as const
 
-export const WRITES: Readonly<Record<(typeof KINDS)[number], readonly string[]>> = {
-  docker: ['Dockerfile', 'compose.yaml'],
+export interface Written {
+  readonly at: string
+  readonly describes: string
+}
+
+export const WRITES: Readonly<Record<(typeof KINDS)[number], readonly Written[]>> = {
+  docker: [
+    {
+      at: 'Dockerfile',
+      describes:
+        'How this app becomes an image and what starts it inside one — the build and start commands its own manifest declares, run with the package manager that manifest names, and the port its server listens on.',
+    },
+    {
+      at: 'compose.yaml',
+      describes: 'What runs the image this release builds, named beside it because one row states one address.',
+    },
+    {
+      at: '.dockerignore',
+      describes:
+        'What a build of this image must never carry out of this directory: the sealed store and the key that opens it, the installed packages, and the history. Without it the build copies everything beside it, and every sealed value goes into the image and into whoever pulls it.',
+    },
+  ],
 }
 
 export const LISTENS = 3000

package/dist/integrations/attach.d.ts

@@ -2,5 +2,9 @@ import type { Attaching } from '../core/attach.ts';
 export declare const CONCEPTS: readonly {
     readonly id: string;
     readonly describes: string;
+    readonly cites: readonly {
+        readonly on: string;
+        readonly said: string;
+    }[];
 }[];
 export declare const ATTACH: Attaching;

package/dist/integrations/attach.js

@@ -1,18 +1,35 @@
-import { named } from "../core/scope.js";
+import { SHAPED } from '../core/init.js';
+import { NAMED } from '../core/scope.js';
 const VERSION = 1;
-const DESCRIBES = 'The system that states every place this app reaches and every credential it reaches with. A target is a destination and the prefix on its id is how it is reached; what it accepts is entities if it keeps them, calls if it is called over https, and the methods or subcommands it answers to if it is an npm package or a program; what it requires is secrets, and where the reach has an address one of them is it. Nothing else in this app names a host, a connection string or an environment variable, so an operation says which place it needs and the rest is worked out from the declaration.';
-const TARGETS = 'Where this app states the places it reaches and what each one accepts. Declare one with `thread create target`, which asks how it is reached and puts the matching prefix on its id — `pg_` for a postgres over the network, `pl_` for one in this process, `zu_` for a store in the browser, `ht_` for something called over https, `mod_` for something this app brings in from outside the repository and calls, `cli_` for a program it runs at a command line — and writes what it accepts and the secrets reaching it needs. A place that keeps things accepts entities; a place that is called accepts the calls declared beside it; a package or a program says in `uses` what it is and in `offers` what it responds to, and takes nothing, because a method name belongs to something outside this tree and `takes` is a demand this tree has to be able to meet. This is the one place the split between what reaches a server and what stays local is written down.';
-const SECRETS = 'Where this app states every value it must be given and may not hold. A row here is a name and a sentence and never a value: `sec_` for one only a server may ever hold, `pub_` for one that may reach a browser, and that prefix is the whole of what decides where the target requiring it can be reached from. A secret with a `sends` goes into a header on every call; the one without is the address of the target that requires it.';
+const DESCRIBES = 'The system that states every place this app reaches and every credential it reaches with. A target is a destination and the prefix on its id is how it is reached; what it accepts is entities if it keeps them, and calls if it is called: an endpoint over https, a subcommand of a program, a method of a package; a disk accepts nothing, because every disk answers the same orders; what it requires is secrets, and the target it is reached through when the place can only be got at by way of another one; where it is goes on the row as its address when anybody may read it, and is one of the secrets when it carries a password. Nothing else in this app names a host, a connection string or an environment variable, so an operation says which place it needs and the rest is worked out from the declaration.';
+const TARGETS = 'Where this app states everything outside itself that it deals with, and every way in. An integration is one outside thing — a vendor, a service, a program on the machine — and nothing is reached that is not part of one; declare it with `thread create integration`. A target is one way out of this app into an integration: `thread create target` prints every way a place can be reached, asks which, and puts that prefix on the id, so how it is reached is the prefix and no field says so. A call is one thing a target can be asked to do, declared beside it with `thread create target call`. A webhook is the way back in: `thread create webhook` asks which integration it sits under, the path something outside posts to, and the operation it invokes, and that operation names the webhook back, so neither half opens a door on its own. Nobody writes the file that answers that address, because `thread capabilities` derives it from those two rows. What a target accepts goes in `takes` — entities where it keeps things, calls where it is called, and nothing for a disk. What it needs goes in `requires`: its credentials, and the target it is reached through; where it is goes in address, and a header every call carries goes in headers. This is the one place the split between what reaches a server and what stays local is written down.';
+const SECRETS = 'Where this app states every value it must be given and may not hold. A row here is a name and a sentence and never a value, and every id wears sec_, because only a server may ever hold a secret: a value anybody may read is not one, and goes on the row that needs it instead, as the address of a target or a header it sends. A secret with a sends goes into a header on every call, one with a signs is the key a body is signed with, and one with neither is the connection string of a database, the one address that carries a password.';
 const VAULT = 'What opens a secret\'s value at the moment of use, written once and then yours. It reads the names off _threads/secrets.ts and opens the values sealed beside the tree, refusing any other name; add a secret with `thread create secret`, which is the only thing that ever takes a value. To open values from somewhere else in production, replace what opens them here.';
-const SECRET = 'A value this app must be given and may never hold — a key, a token, a connection string. The row names it and says what it is for, and there is no field on it for the value, because a row is read by everything and a credential is read by one thing at one moment. The prefix says who may ever hold it: `sec_` a server and nothing else, `pub_` anybody including whoever opens the page. That one letter is what refuses a server credential its way into a browser bundle, so it is on the id rather than in a field somebody could forget.';
-const CALL = 'One thing a target can be asked to do — the verb and the path, named so that a node names the call and never writes a url. It is a row rather than a field because it is a thing with a name and a sentence like everything else here, and because what a vendor offers is a list that grows: an app reaches one more endpoint by declaring one more of these, not by editing a body.';
-const REACH = 'How a target is got at — over a network to a postgres, inside this process, in the browser\'s own memory, over https, as an npm package this app installs and calls directly, or as a program run at a command line. It is the prefix on the target\'s id and never a field, because how a thing is reached decides everything else that may be said about it: what it accepts, whether it can be reached from a page at all, whether anything has to say where it is, and whether anything has to arrive on the machine before it can be reached at all. A field beside the id would be a second answer to a question the id already answers.';
+const SECRET = 'A value this app must be given and may never hold: a key, a token, a connection string. The row names it and says what it is for, and there is no field on it for the value, because a row is read by everything and a credential is read by one thing at one moment. Every id wears sec_, and that prefix says only a server may ever hold it: everything a browser bundle reaches is in the bundle, so a target requiring a secret is refused a browser entry when it is built. A value anybody may read is not a secret and is never sealed; it is written on the row that needs it, as the address of a target or a header every call carries.';
+const CALL = 'One thing a target can be asked to do, named so that a node names the call and never writes a url, a subcommand or a method. Over https it is a verb and a path; on a program it is a subcommand; on a package it is a method. It is a row rather than a field because it is a thing with a name and a sentence like everything else here, and because what a place offers is a list that grows: an app reaches one more endpoint, subcommand or method by declaring one more of these, not by editing a body.';
+const REACH = 'How a target is got at — over a network to a postgres, inside this process, in the browser\'s own memory, over https, as a package this app calls in its own process, as a program run at a command line, or as the disk under it. It is the prefix on the target\'s id and never a field, because how a thing is reached decides everything else that may be said about it: what it accepts, whether it can be reached from a page at all, and whether anything has to say where it is. A field beside the id would be a second answer to a question the id already answers.';
+const INTEGRATION = 'Something outside this app that it reaches into: a vendor, a service, a program on the machine. Every target says which integration it is part of, so supabase is one thing made of its postgres, its https endpoint, the calls on each and the secrets they need, rather than five rows that happen to share a word. Declare it before the first target that reaches into it.';
+const WEBHOOK = 'A way in that something outside uses: it posts to one address this app declares, and that address is the whole of what anybody out there is given. It sits under an integration beside the targets that reach the other way, and it names the operation it runs and the secret its signature is checked against, so what arrives is refused or dispatched and never anything else. Declare one with `thread create webhook`.';
+const INVOKES = 'Which operation a webhook runs when something posts to it. That operation names the webhook back, so both halves agree before anything outside reaches it, and a pairing only one of them states is refused.';
+const ARRIVES = 'Which header a value comes in on. A webhook says which one carries its signature, and an entity that names its callers says which one carries their token — one word, because it answers the same question about a request.';
+const SIGNS = 'What a secret does to a body on its way out: its value is the key a signature is computed with, and the digest goes on the header named here. It is `sends` turned around — `sends` puts the value itself on a header, and this puts the value nowhere at all.';
+const ADDRESS = 'Where a target reached over https is: the one absolute url every call on it is written from, stated on the row because a place is a fact anybody may read. Only the address of a database is sealed instead, because a connection string carries a password.';
+const HEADERS = 'The headers every call on a target carries, stated on its row as name and value: the version of an API this app is written against, or a fixed way of asking. A credential never goes here, because anybody may read a row; a value that has to be withheld is a secret with a sends.';
+const SSOT = { on: '2026-08-29', said: 'SSOT for the integrations, as a whole meta inside thread core' };
+const RULED = { on: '2026-09-22', said: 'remove pub then as an acceptable thing, that\'s definitely slop and it\'s not the first time such a fucking thing has surfaced. Delete and redo it properly.' };
 export const CONCEPTS = [
-    { id: 'secret', describes: SECRET },
-    { id: 'call', describes: CALL },
-    { id: 'reach', describes: REACH },
+    { id: 'secret', describes: SECRET, cites: [SSOT] },
+    { id: 'webhook', describes: WEBHOOK, cites: [SSOT] },
+    { id: 'invokes', describes: INVOKES, cites: [SSOT] },
+    { id: 'arrives', describes: ARRIVES, cites: [SSOT] },
+    { id: 'signs', describes: SIGNS, cites: [SSOT] },
+    { id: 'address', describes: ADDRESS, cites: [RULED] },
+    { id: 'headers', describes: HEADERS, cites: [RULED] },
+    { id: 'call', describes: CALL, cites: [SSOT] },
+    { id: 'reach', describes: REACH, cites: [SSOT] },
+    { id: 'integration', describes: INTEGRATION, cites: [SSOT] },
 ];
-import { quoted } from "../core/rows.js";
+import { quoted } from '../core/rows.js';
 const concept = (one) => [
     '  {',
     `    id: '${one.id}',`,
@@ -20,12 +37,11 @@ const concept = (one) => [
     `    describes: ${quoted(one.describes)},`,
     `    version: ${String(VERSION)},`,
     '    cites: [',
-    "      { on: '2026-08-29', said: 'SSOT for the integrations, as a whole meta inside thread core' },",
-    "      { on: '2026-08-29', said: 'seams declare BOTH target AND secrets' },",
+    ...one.cites.map((each) => "      { on: '" + each.on + "', said: " + quoted(each.said) + ' },'),
     '    ],',
     '  },',
 ].join('\n');
-const INTEGRATIONS_SOURCE = `import type { Threaded } from '../core/thread.ts'
+const INTEGRATIONS_SOURCE = `import type { Threaded } from '${SHAPED}'
 
 export const INTEGRATIONS: Threaded = {
   id: 'integrations',
@@ -48,13 +64,17 @@ export const INTEGRATIONS: Threaded = {
   ],
 }
 `;
-const TARGETS_SOURCE = `import type { Call, Target } from './target.ts'
+const TARGETS_SOURCE = `import type { Call, Integration, Target, Webhook } from '${NAMED}/integrations/target'
+
+export const INTEGRATIONS: readonly Integration[] = []
 
 export const TARGETS: readonly Target[] = []
 
 export const CALLS: readonly Call[] = []
+
+export const WEBHOOKS: readonly Webhook[] = []
 `;
-const SECRETS_SOURCE = `import type { Secret } from './secret.ts'
+const SECRETS_SOURCE = `import type { Secret } from '${NAMED}/integrations/secret'
 
 export const SECRETS: readonly Secret[] = []
 `;
@@ -88,7 +108,7 @@ const SEEDED = {
         '    {',
         '      id: \'integrations\',',
         '      at: \'_threads/integrations.ts\',',
-        '      describes: \'The system that states every place this app reaches and every credential it reaches with. A target is a destination and the prefix on its id is how it is reached; what it accepts is entities if it keeps them, calls if it is called over https, and the methods or subcommands it answers to if it is an npm package or a program; what it requires is secrets, and where the reach has an address one of them is it. Nothing else in this app names a host, a connection string or an environment variable, so an operation says which place it needs and the rest is worked out from the declaration.\',',
+        '      describes: \'The system that states every place this app reaches and every credential it reaches with. A target is a destination and the prefix on its id is how it is reached; what it accepts is entities if it keeps them, and calls if it is called: an endpoint over https, a subcommand of a program, a method of a package; a disk accepts nothing, because every disk answers the same orders; what it requires is secrets, and the target it is reached through when the place can only be got at by way of another one; where it is goes on the row as its address when anybody may read it, and is one of the secrets when it carries a password. Nothing else in this app names a host, a connection string or an environment variable, so an operation says which place it needs and the rest is worked out from the declaration.\',',
         '      version: 1,',
         '    },',
     ].join('\n'),
@@ -117,43 +137,4 @@ export const ATTACH = {
         { file: 'secrets.ts', source: SECRETS_SOURCE },
     ],
     rows: [...OWN, ...SHIPPED],
-    retires: [
-        {
-            into: 'derivation.ts',
-            list: 'GENERATORS',
-            id: 'read-generator',
-            why: 'renamed to `inspect-generator`. `thread read` is a verb of the CLI itself now — it reads FILES, and this package reads ROWS, which is `thread inspect`. Both were called read, and only one of them could answer.',
-        },
-        {
-            into: 'integrations.ts',
-            list: 'declares',
-            id: 'trace',
-            made: `src/integrations.trace.${'jsonl'}`,
-            why: 'the record of what went out through an integration is gone. It sealed every line against the one before it, and a chain nobody reads guards nothing. What an integration did is what the tool itself reports, at the moment it runs',
-        },
-        {
-            into: 'derivation.ts',
-            list: 'GENERATORS',
-            id: 'trace-generator',
-            why: 'the record it wrote is gone, so there is nothing for it to make and nothing for `--check` to read',
-        },
-        {
-            into: 'derivation.ts',
-            list: 'GENERATORS',
-            id: 'sdk-generator',
-            why: '`sdk` is a way a target is reached now, not a noun beside one — `thread create target` declares an SDK with ' +
-                '`--reach sdk`, which installs it, reads what it answers to, and writes one row instead of three. The noun ' +
-                'also raised the collision guard against any app declaring a meta called `sdk`, which made every other ' +
-                'withdrawal this package ships undeliverable to the trees that needed them.',
-        },
-        {
-            into: 'concepts.ts',
-            list: 'CONCEPTS',
-            id: 'sdk',
-            why: '`sdk` is no longer a noun beside a target — it is one of the ways a target is reached, and its meaning is ' +
-                `now \`SAID.module\` in \`${named('integrations')}/target\`, beside \`https\` and every other reach, none of which is ` +
-                'coined here either. It also collided with an app declaring a meta called `sdk`, which coins the word: two ' +
-                'meanings for one word is what `twice-meant` refuses, and it was holding the glossary and the docs red.',
-        },
-    ],
 };