@prestack/thread 0.1.4 → 0.1.6

package/dist/core/attach.js

@@ -12,10 +12,10 @@ import { createRequire } from 'node:module';
 import { join, relative, resolve } from 'node:path';
 import { stdout } from 'node:process';
 import { LISTS } from './descend.js';
-import { ROOT, TREE, root as rooted } from './init.js';
+import { ROOT, SHAPED, TREE, root as rooted } from './init.js';
 import { BESIDE } from './invoked.js';
 import { STATED, holdsRow, listBounds, quoted, reconciled, rowsIn, withRow, withoutRow } from './rows.js';
-import { idOf, ours as isOurs } from './scope.js';
+import { idOf, installed, ours as isOurs } from './scope.js';
 const SHAPE = /export interface [A-Za-z0-9_]+ extends Threaded \{[\s\S]*?\n\}\n/;
 const MEMBERS = 'MEMBERS';
 const DOOR = '/attach';
@@ -178,7 +178,6 @@ export async function attach(into, name, touched = new Set(), under = []) {
     const ours = [...one.declares.matchAll(/\bid: '([^']+)'/g)].map((found) => found[1]);
     const mine = declares !== undefined &&
         (holdsRow(held, declares, one.id) || ours.some((id) => id !== undefined && holdsRow(held, declares, id)));
-    const installed = (at) => at.startsWith('node_modules/') && isOurs(at.split('/').slice(1, 3).join('/'));
     const pathIn = (source) => {
         const listed = `const HELD = {\n  declares: [\n${source}\n  ],\n}\n`;
         const span = listBounds(listed, 'declares');
@@ -485,7 +484,7 @@ export async function detach(into, name) {
     return [...touched].sort();
 }
 const DESCRIBES = 'The package every tree installs first: the descent that reads a tree, the gate that checks it, and the generators every tree runs.';
-const CORE_SOURCE = `import type { Threaded } from '../core/thread.ts'
+const CORE_SOURCE = `import type { Threaded } from '${SHAPED}'
 
 export const CORE: Threaded = {
   id: 'core',
@@ -509,7 +508,14 @@ const SEEDED = {
         '    },',
     ].join('\n'),
 };
-const SHIPPED = [];
+const SHIPPED = [
+    {
+        into: 'derivation.ts',
+        list: 'GENERATORS',
+        id: 'commit',
+        source: "  {\n    id: 'commit',\n    at: 'node_modules/@prestack/thread/dist/core/generators/commit.js',\n    describes: 'Commits every change in this app, so a create or an edit leaves a mark in version control without anyone typing a git command. Unlike `cl_commit`, which runs real git to record a release on the machine the command runs on, this writes the commit in the node the command already runs in, so it works inside the permission fence an attached app runs behind, where no program may be started. It stages what changed, records it under the message it is given, and starts a repository the first time there is none. Pushing and undoing stay deliberate.',\n    version: 1,\n    by: 'thread commit',\n  },",
+    },
+];
 export const ATTACH = {
     attaches: SEEDED.attaches,
     id: SEEDED.id,

package/dist/core/attach.ts

@@ -5,10 +5,10 @@ import { join, relative, resolve } from 'node:path'
 import { stdout } from 'node:process'
 
 import { LISTS } from './descend.ts'
-import { ROOT, TREE, root as rooted } from './init.ts'
+import { ROOT, SHAPED, TREE, root as rooted } from './init.ts'
 import { BESIDE } from './invoked.ts'
 import { STATED, holdsRow, listBounds, quoted, reconciled, rowsIn, withRow, withoutRow } from './rows.ts'
-import { idOf, ours as isOurs } from './scope.ts'
+import { idOf, installed, ours as isOurs } from './scope.ts'
 
 const SHAPE = /export interface [A-Za-z0-9_]+ extends Threaded \{[\s\S]*?\n\}\n/
 
@@ -230,8 +230,6 @@ export async function attach(
     declares !== undefined &&
     (holdsRow(held, declares, one.id) || ours.some((id) => id !== undefined && holdsRow(held, declares, id)))
 
-  const installed = (at: string): boolean => at.startsWith('node_modules/') && isOurs(at.split('/').slice(1, 3).join('/'))
-
   const pathIn = (source: string): string | undefined => {
     const listed = `const HELD = {\n  declares: [\n${source}\n  ],\n}\n`
     const span = listBounds(listed, 'declares')
@@ -540,7 +538,7 @@ export async function detach(into: string, name: string): Promise<readonly strin
 const DESCRIBES =
   'The package every tree installs first: the descent that reads a tree, the gate that checks it, and the generators every tree runs.'
 
-const CORE_SOURCE = `import type { Threaded } from '../core/thread.ts'
+const CORE_SOURCE = `import type { Threaded } from '${SHAPED}'
 
 export const CORE: Threaded = {
   id: 'core',
@@ -567,6 +565,12 @@ const SEEDED = {
 }
 
 const SHIPPED: readonly { readonly into: string; readonly list: string; readonly id: string; readonly source: string }[] = [
+  {
+    into: 'derivation.ts',
+    list: 'GENERATORS',
+    id: 'commit',
+    source: "  {\n    id: 'commit',\n    at: 'node_modules/@prestack/thread/dist/core/generators/commit.js',\n    describes: 'Commits every change in this app, so a create or an edit leaves a mark in version control without anyone typing a git command. Unlike `cl_commit`, which runs real git to record a release on the machine the command runs on, this writes the commit in the node the command already runs in, so it works inside the permission fence an attached app runs behind, where no program may be started. It stages what changed, records it under the message it is given, and starts a repository the first time there is none. Pushing and undoing stay deliberate.',\n    version: 1,\n    by: 'thread commit',\n  },",
+  },
 ]
 export const ATTACH: Attaching = {
   attaches: SEEDED.attaches,

package/dist/core/descend.js

@@ -2,8 +2,8 @@ import { starts } from '../integrations/cli.js';
 import { attached, beyond, existsSync, here as answering, kind, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from '../integrations/disk.js';
 import { dirname, join, relative, resolve } from 'node:path';
 import ts from 'typescript';
-import { ignored } from './init.js';
-import { NAMED, ORGANISATION } from './scope.js';
+import { SHAPED, ignored } from './init.js';
+import { ORGANISATION, installed } from './scope.js';
 import { findTree } from './tree.js';
 const BUILT = new Set(ignored()
     .split('\n')
@@ -780,7 +780,7 @@ export function descend() {
         broken.push({
             file: THREAD_AT,
             detail: 'the root does not resolve `Threaded`, so nothing here can be recognised as a declaration and every file reads as unthreaded',
-            instead: `import \`Threaded\` from \`${NAMED}/thread\` in the root, or run \`thread init\`. Without the shape there is nothing to hold anything to`,
+            instead: `import \`Threaded\` from \`${SHAPED}\` in the root, or run \`thread init\`. Without the shape there is nothing to hold anything to`,
         });
         passed = { threaded, mentioned, derived, stated, coined, broken, findings, declarations, rows, sources: sources() };
         return passed;
@@ -849,7 +849,7 @@ export function descend() {
             return;
         }
         const target = resolve(ROOT, row.at);
-        if (unkept(row.at)) {
+        if (!installed(row.at) && unkept(row.at)) {
             findings.push({
                 file: at,
                 detail: `\`${names(row)}\` names \`${row.at}\`, which git ignores, so it is on this machine and in no clone of it`,

package/dist/core/descend.ts

@@ -5,8 +5,8 @@ import { dirname, join, relative, resolve } from 'node:path'
 import ts from 'typescript'
 
 import type { Finding } from './finding.ts'
-import { ignored } from './init.ts'
-import { NAMED, ORGANISATION } from './scope.ts'
+import { SHAPED, ignored } from './init.ts'
+import { ORGANISATION, installed } from './scope.ts'
 import { findTree } from './tree.ts'
 
 const BUILT: ReadonlySet<string> = new Set(
@@ -869,7 +869,7 @@ export function descend(): Pass {
     broken.push({
       file: THREAD_AT,
       detail: 'the root does not resolve `Threaded`, so nothing here can be recognised as a declaration and every file reads as unthreaded',
-      instead: `import \`Threaded\` from \`${NAMED}/thread\` in the root, or run \`thread init\`. Without the shape there is nothing to hold anything to`,
+      instead: `import \`Threaded\` from \`${SHAPED}\` in the root, or run \`thread init\`. Without the shape there is nothing to hold anything to`,
     })
     passed = { threaded, mentioned, derived, stated, coined, broken, findings, declarations, rows, sources: sources() }
     return passed
@@ -940,7 +940,7 @@ export function descend(): Pass {
     }
 
     const target = resolve(ROOT, row.at)
-    if (unkept(row.at)) {
+    if (!installed(row.at) && unkept(row.at)) {
       findings.push({
         file: at,
         detail: `\`${names(row)}\` names \`${row.at}\`, which git ignores, so it is on this machine and in no clone of it`,

package/dist/core/generators/commit.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/generators/commit.js

@@ -0,0 +1,150 @@
+import { createHash } from 'node:crypto';
+import { deflateSync, inflateSync } from 'node:zlib';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import { argv, cwd, stdout, stderr } from 'node:process';
+const dir = cwd();
+const message = (argv[2] ?? 'thread').slice(0, 400);
+const NL = String.fromCharCode(10);
+const NUL = String.fromCharCode(0);
+const SLASH = String.fromCharCode(47);
+const matches = (pat, name) => {
+    const parts = pat.split('*');
+    if (parts.length === 1)
+        return name === pat;
+    const first = parts[0];
+    if (!name.startsWith(first))
+        return false;
+    let at = first.length;
+    for (let k = 1; k < parts.length - 1; k += 1) {
+        const found = name.indexOf(parts[k], at);
+        if (found === -1)
+            return false;
+        at = found + parts[k].length;
+    }
+    const last = parts[parts.length - 1];
+    return name.length - last.length >= at && name.endsWith(last);
+};
+let text = '';
+try {
+    text = readFileSync(join(dir, '.gitignore'), 'utf8');
+}
+catch {
+    text = '';
+}
+const patterns = [];
+for (const raw of text.split(NL)) {
+    let line = raw.trim();
+    if (line === '' || line.startsWith('#'))
+        continue;
+    const negate = line.startsWith('!');
+    if (negate)
+        line = line.slice(1);
+    const dirOnly = line.endsWith(SLASH);
+    if (dirOnly)
+        line = line.slice(0, -1);
+    let anchored = line.startsWith(SLASH);
+    if (anchored)
+        line = line.slice(1);
+    if (line.includes(SLASH))
+        anchored = true;
+    if (line !== '')
+        patterns.push({ negate, dirOnly, anchored, pat: line });
+}
+const ignored = (rel, name, isDir) => {
+    if (name === '.git')
+        return true;
+    let hit = false;
+    for (const one of patterns) {
+        if (one.dirOnly && !isDir)
+            continue;
+        if (matches(one.pat, one.anchored ? rel : name))
+            hit = !one.negate;
+    }
+    return hit;
+};
+const BRANCH = ['refs', 'heads', 'main'].join(SLASH);
+const store = (kind, body) => {
+    const whole = Buffer.concat([Buffer.from(kind + ' ' + String(body.length) + NUL), body]);
+    const sha = createHash('sha1').update(whole).digest('hex');
+    const at = join(dir, '.git', 'objects', sha.slice(0, 2), sha.slice(2));
+    if (!existsSync(at)) {
+        mkdirSync(join(dir, '.git', 'objects', sha.slice(0, 2)), { recursive: true });
+        writeFileSync(at, deflateSync(whole));
+    }
+    return sha;
+};
+const tree = (at) => {
+    const entries = [];
+    for (const name of readdirSync(at)) {
+        const full = join(at, name);
+        const stat = statSync(full);
+        const rel = relative(dir, full).split(sep).join(SLASH);
+        if (ignored(rel, name, stat.isDirectory()))
+            continue;
+        if (stat.isDirectory()) {
+            const sub = tree(full);
+            if (sub !== '')
+                entries.push({ mode: '40000', name, sha: sub });
+        }
+        else if (stat.isFile()) {
+            const sha = store('blob', readFileSync(full));
+            entries.push({ mode: (stat.mode & 0o111) !== 0 ? '100755' : '100644', name, sha });
+        }
+    }
+    if (entries.length === 0)
+        return '';
+    const key = (one) => one.name + (one.mode === '40000' ? SLASH : '');
+    entries.sort((one, two) => (key(one) < key(two) ? -1 : key(one) > key(two) ? 1 : 0));
+    const body = Buffer.concat(entries.map((one) => Buffer.concat([Buffer.from(one.mode + ' ' + one.name + NUL), Buffer.from(one.sha, 'hex')])));
+    return store('tree', body);
+};
+const treeOf = (sha) => {
+    const at = join(dir, '.git', 'objects', sha.slice(0, 2), sha.slice(2));
+    const raw = inflateSync(readFileSync(at));
+    const body = raw.slice(raw.indexOf(0) + 1).toString('utf8');
+    const first = body.split(NL)[0] ?? '';
+    return first.startsWith('tree ') ? first.slice(5) : '';
+};
+const record = () => {
+    const gitDir = join(dir, '.git');
+    if (!existsSync(join(gitDir, 'HEAD'))) {
+        mkdirSync(join(gitDir, 'objects'), { recursive: true });
+        mkdirSync(join(gitDir, 'refs', 'heads'), { recursive: true });
+        writeFileSync(join(gitDir, 'HEAD'), 'ref: ' + BRANCH + NL);
+    }
+    const head = readFileSync(join(gitDir, 'HEAD'), 'utf8').trim();
+    const ref = head.startsWith('ref: ') ? head.slice(5) : BRANCH;
+    const refAt = join(gitDir, ref);
+    const parent = existsSync(refAt) ? readFileSync(refAt, 'utf8').trim() : '';
+    const root = tree(dir);
+    if (root === '') {
+        stdout.write('commit: nothing to commit' + NL);
+        return;
+    }
+    if (parent !== '' && treeOf(parent) === root) {
+        stdout.write('commit: nothing changed' + NL);
+        return;
+    }
+    const when = String(Math.floor(Date.now() / 1000)) + ' +0000';
+    const who = 'thread <thread@prestack> ' + when;
+    const body = [
+        'tree ' + root,
+        ...(parent === '' ? [] : ['parent ' + parent]),
+        'author ' + who,
+        'committer ' + who,
+        '',
+        message,
+        '',
+    ].join(NL);
+    const sha = store('commit', Buffer.from(body));
+    writeFileSync(refAt, sha + NL);
+    stdout.write('commit: ' + sha.slice(0, 8) + ' on ' + (ref.split(SLASH).pop() ?? 'main') + NL);
+};
+try {
+    record();
+}
+catch (thrown) {
+    stderr.write('commit: ' + (thrown instanceof Error ? thrown.message : String(thrown)) + NL);
+    process.exit(1);
+}

package/dist/core/generators/commit.ts

@@ -0,0 +1,157 @@
+import { createHash } from 'node:crypto'
+import { deflateSync, inflateSync } from 'node:zlib'
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs'
+import { join, relative, sep } from 'node:path'
+import { argv, cwd, stdout, stderr } from 'node:process'
+
+const dir = cwd()
+const message = (argv[2] ?? 'thread').slice(0, 400)
+const NL = String.fromCharCode(10)
+const NUL = String.fromCharCode(0)
+const SLASH = String.fromCharCode(47)
+const matches = (pat: string, name: string): boolean => {
+  const parts = pat.split('*')
+  if (parts.length === 1) return name === pat
+  const first = parts[0]
+  if (!name.startsWith(first)) return false
+  let at = first.length
+  for (let k = 1; k < parts.length - 1; k += 1) {
+    const found = name.indexOf(parts[k], at)
+    if (found === -1) return false
+    at = found + parts[k].length
+  }
+  const last = parts[parts.length - 1]
+  return name.length - last.length >= at && name.endsWith(last)
+}
+
+interface Ignore {
+  readonly negate: boolean
+  readonly dirOnly: boolean
+  readonly anchored: boolean
+  readonly pat: string
+}
+
+let text = ''
+try {
+  text = readFileSync(join(dir, '.gitignore'), 'utf8')
+} catch {
+  text = ''
+}
+const patterns: Ignore[] = []
+for (const raw of text.split(NL)) {
+  let line = raw.trim()
+  if (line === '' || line.startsWith('#')) continue
+  const negate = line.startsWith('!')
+  if (negate) line = line.slice(1)
+  const dirOnly = line.endsWith(SLASH)
+  if (dirOnly) line = line.slice(0, -1)
+  let anchored = line.startsWith(SLASH)
+  if (anchored) line = line.slice(1)
+  if (line.includes(SLASH)) anchored = true
+  if (line !== '') patterns.push({ negate, dirOnly, anchored, pat: line })
+}
+
+const ignored = (rel: string, name: string, isDir: boolean): boolean => {
+  if (name === '.git') return true
+  let hit = false
+  for (const one of patterns) {
+    if (one.dirOnly && !isDir) continue
+    if (matches(one.pat, one.anchored ? rel : name)) hit = !one.negate
+  }
+  return hit
+}
+const BRANCH = ['refs', 'heads', 'main'].join(SLASH)
+
+interface Entry {
+  readonly mode: string
+  readonly name: string
+  readonly sha: string
+}
+
+const store = (kind: string, body: Buffer): string => {
+  const whole = Buffer.concat([Buffer.from(kind + ' ' + String(body.length) + NUL), body])
+  const sha = createHash('sha1').update(whole).digest('hex')
+  const at = join(dir, '.git', 'objects', sha.slice(0, 2), sha.slice(2))
+  if (!existsSync(at)) {
+    mkdirSync(join(dir, '.git', 'objects', sha.slice(0, 2)), { recursive: true })
+    writeFileSync(at, deflateSync(whole))
+  }
+  return sha
+}
+
+const tree = (at: string): string => {
+  const entries: Entry[] = []
+  for (const name of readdirSync(at)) {
+    const full = join(at, name)
+    const stat = statSync(full)
+    const rel = relative(dir, full).split(sep).join(SLASH)
+    if (ignored(rel, name, stat.isDirectory())) continue
+    if (stat.isDirectory()) {
+      const sub = tree(full)
+      if (sub !== '') entries.push({ mode: '40000', name, sha: sub })
+    } else if (stat.isFile()) {
+      const sha = store('blob', readFileSync(full))
+      entries.push({ mode: (stat.mode & 0o111) !== 0 ? '100755' : '100644', name, sha })
+    }
+  }
+  if (entries.length === 0) return ''
+  const key = (one: Entry): string => one.name + (one.mode === '40000' ? SLASH : '')
+  entries.sort((one, two) => (key(one) < key(two) ? -1 : key(one) > key(two) ? 1 : 0))
+  const body = Buffer.concat(
+    entries.map((one) => Buffer.concat([Buffer.from(one.mode + ' ' + one.name + NUL), Buffer.from(one.sha, 'hex')])),
+  )
+  return store('tree', body)
+}
+
+const treeOf = (sha: string): string => {
+  const at = join(dir, '.git', 'objects', sha.slice(0, 2), sha.slice(2))
+  const raw = inflateSync(readFileSync(at))
+  const body = raw.slice(raw.indexOf(0) + 1).toString('utf8')
+  const first = body.split(NL)[0] ?? ''
+  return first.startsWith('tree ') ? first.slice(5) : ''
+}
+
+const record = (): void => {
+  const gitDir = join(dir, '.git')
+  if (!existsSync(join(gitDir, 'HEAD'))) {
+    mkdirSync(join(gitDir, 'objects'), { recursive: true })
+    mkdirSync(join(gitDir, 'refs', 'heads'), { recursive: true })
+    writeFileSync(join(gitDir, 'HEAD'), 'ref: ' + BRANCH + NL)
+  }
+  const head = readFileSync(join(gitDir, 'HEAD'), 'utf8').trim()
+  const ref = head.startsWith('ref: ') ? head.slice(5) : BRANCH
+  const refAt = join(gitDir, ref)
+  const parent = existsSync(refAt) ? readFileSync(refAt, 'utf8').trim() : ''
+
+  const root = tree(dir)
+  if (root === '') {
+    stdout.write('commit: nothing to commit' + NL)
+    return
+  }
+  if (parent !== '' && treeOf(parent) === root) {
+    stdout.write('commit: nothing changed' + NL)
+    return
+  }
+
+  const when = String(Math.floor(Date.now() / 1000)) + ' +0000'
+  const who = 'thread <thread@prestack> ' + when
+  const body = [
+    'tree ' + root,
+    ...(parent === '' ? [] : ['parent ' + parent]),
+    'author ' + who,
+    'committer ' + who,
+    '',
+    message,
+    '',
+  ].join(NL)
+  const sha = store('commit', Buffer.from(body))
+  writeFileSync(refAt, sha + NL)
+  stdout.write('commit: ' + sha.slice(0, 8) + ' on ' + (ref.split(SLASH).pop() ?? 'main') + NL)
+}
+
+try {
+  record()
+} catch (thrown) {
+  stderr.write('commit: ' + (thrown instanceof Error ? thrown.message : String(thrown)) + NL)
+  process.exit(1)
+}

package/dist/core/init.d.ts

@@ -1,5 +1,6 @@
 export declare const TREE = "_threads";
 export declare const ROOT = "thread.ts";
+export declare const SHAPED = "@prestack/thread/core/thread";
 export declare class AlreadyThreadedError extends Error {
     readonly at: string;
     constructor(at: string);

package/dist/core/init.js

@@ -4,8 +4,10 @@ import { createRequire } from 'node:module';
 import { join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { quoted } from './rows.js';
+import { NAMED } from './scope.js';
 export const TREE = '_threads';
 export const ROOT = 'thread.ts';
+export const SHAPED = `${NAMED}/core/thread`;
 export class AlreadyThreadedError extends Error {
     at;
     constructor(at) {
@@ -90,7 +92,7 @@ export function root(into) {
         '    },',
     ]);
     return [
-        "import type { Threaded } from './thread.ts'",
+        `import type { Threaded } from '${SHAPED}'`,
         '',
         'export const THREAD: Threaded = {',
         "  id: 'thread',",

package/dist/core/init.ts

@@ -5,11 +5,14 @@ import { join, relative, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 import { quoted } from './rows.ts'
+import { NAMED } from './scope.ts'
 
 
 export const TREE = '_threads'
 export const ROOT = 'thread.ts'
 
+export const SHAPED = `${NAMED}/core/thread`
+
 export class AlreadyThreadedError extends Error {
   readonly at: string
   constructor(at: string) {
@@ -123,7 +126,7 @@ export function root(into: string): string {
     '    },',
   ])
   return [
-    "import type { Threaded } from './thread.ts'",
+    `import type { Threaded } from '${SHAPED}'`,
     '',
     'export const THREAD: Threaded = {',
     "  id: 'thread',",

package/dist/core/scope.d.ts

@@ -4,3 +4,4 @@ export declare const NAMED = "@prestack/thread";
 export declare const named: (id: string) => string;
 export declare const idOf: (name: string) => string | undefined;
 export declare const ours: (name: string) => boolean;
+export declare const installed: (at: string) => boolean;

package/dist/core/scope.js

@@ -10,3 +10,4 @@ export const idOf = (name) => {
     return name.startsWith(HEAD) ? name.slice(HEAD.length) : undefined;
 };
 export const ours = (name) => idOf(name) !== undefined;
+export const installed = (at) => at.startsWith('node_modules/') && ours(at.split('/').slice(1, 3).join('/'));

package/dist/core/scope.ts

@@ -16,3 +16,5 @@ export const idOf = (name: string): string | undefined => {
 }
 
 export const ours = (name: string): boolean => idOf(name) !== undefined
+
+export const installed = (at: string): boolean => at.startsWith('node_modules/') && ours(at.split('/').slice(1, 3).join('/'))

package/dist/derivation/attach.js

@@ -1,7 +1,8 @@
+import { SHAPED } from '../core/init.js';
 import { quoted } from '../core/rows.js';
 const DESCRIBES = 'What turns a declaration into a file: the rows that state something is to be made, and the generators that make it. They are kept apart so you can read what an app declares without opening the machinery that builds it.';
 const DERIVATION_SOURCE = [
-    "import type { Threaded } from '../core/thread.ts'",
+    `import type { Threaded } from '${SHAPED}'`,
     '',
     'export const DERIVATION: Threaded = {',
     "  id: 'derivation',",

package/dist/derivation/attach.ts

@@ -1,12 +1,13 @@
 import type { Attaching } from '../core/attach.ts'
 
+import { SHAPED } from '../core/init.ts'
 import { quoted } from '../core/rows.ts'
 
 const DESCRIBES =
   'What turns a declaration into a file: the rows that state something is to be made, and the generators that make it. They are kept apart so you can read what an app declares without opening the machinery that builds it.'
 
 const DERIVATION_SOURCE = [
-  "import type { Threaded } from '../core/thread.ts'",
+  `import type { Threaded } from '${SHAPED}'`,
   '',
   'export const DERIVATION: Threaded = {',
   "  id: 'derivation',",

package/dist/integrations/attach.js

@@ -1,3 +1,5 @@
+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, 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.';
@@ -39,7 +41,7 @@ const concept = (one) => [
     '    ],',
     '  },',
 ].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',
@@ -62,7 +64,7 @@ export const INTEGRATIONS: Threaded = {
   ],
 }
 `;
-const TARGETS_SOURCE = `import type { Call, Integration, Target, Webhook } from './target.ts'
+const TARGETS_SOURCE = `import type { Call, Integration, Target, Webhook } from '${NAMED}/integrations/target'
 
 export const INTEGRATIONS: readonly Integration[] = []
 
@@ -72,7 +74,7 @@ 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[] = []
 `;

package/dist/integrations/attach.ts

@@ -1,5 +1,6 @@
 import type { Attaching } from '../core/attach.ts'
-import { named } from '../core/scope.ts'
+import { SHAPED } from '../core/init.ts'
+import { NAMED, named } from '../core/scope.ts'
 
 const VERSION = 1
 
@@ -77,7 +78,7 @@ const concept = (one: (typeof CONCEPTS)[number]): string =>
     '  },',
   ].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',
@@ -101,7 +102,7 @@ export const INTEGRATIONS: Threaded = {
 }
 `
 
-const TARGETS_SOURCE = `import type { Call, Integration, Target, Webhook } from './target.ts'
+const TARGETS_SOURCE = `import type { Call, Integration, Target, Webhook } from '${NAMED}/integrations/target'
 
 export const INTEGRATIONS: readonly Integration[] = []
 
@@ -112,7 +113,7 @@ 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[] = []
 `

package/dist/integrity/attach.js

@@ -1,12 +1,13 @@
-import { named } from '../core/scope.js';
+import { SHAPED } from '../core/init.js';
+import { NAMED } from '../core/scope.js';
 import { quoted } from '../core/rows.js';
 const DESCRIBES = 'What this app refuses, and the checks that make each refusal actually happen. Every check has one owner, so none of them can be switched off somewhere nobody is looking.';
 const CONSTRAINT = 'The rules the framework enforces on every app that installs it. They are read from the installed package rather than from this tree, so there is nothing here to weaken.';
 const RULES = 'What this app refuses on top of what the framework already does. `thread create rule` asks what to ban, where it applies and what to do instead, then writes the row and the check beside it.';
-const HOME = `node_modules/${named('integrity')}/dist`;
+const HOME = `node_modules/${NAMED}/dist/integrity`;
 const GATE = 'Every surface that can refuse, each naming where it lives and the command that runs it, so the gate is derived from what this system declares rather than kept as a string beside it.';
 const COMPILER = 'The compiler run over the files this app declares and no others. A type error is the plainest kind of broken build, so it is refused here rather than found by whoever runs the app next.';
-const INTEGRITY_SOURCE = `import type { Threaded } from '../core/thread.ts'
+const INTEGRITY_SOURCE = `import type { Threaded } from '${SHAPED}'
 
 export const INTEGRITY: Threaded = {
   id: 'integrity',
@@ -42,11 +43,11 @@ export const INTEGRITY: Threaded = {
   ],
 }
 `;
-const RULES_SOURCE = `import type { Constraint } from './constraint.ts'
+const RULES_SOURCE = `import type { Constraint } from '${NAMED}/integrity/constraint'
 
 export const RULES: readonly Constraint[] = []
 `;
-const GATE_SOURCE = `import type { Threaded } from '../core/thread.ts'
+const GATE_SOURCE = `import type { Threaded } from '${SHAPED}'
 
 export const GATE: Threaded = {
   id: 'gate',