@prestack/thread 0.0.3 → 0.1.1

package/dist/core/files.ts

@@ -0,0 +1,193 @@
+import * as disk from 'node:fs'
+import { dirname } from 'node:path'
+
+export type Kind = 'file' | 'folder' | 'other' | 'none'
+
+export interface Listed {
+  readonly name: string
+  readonly kind: Exclude<Kind, 'none'>
+}
+
+export interface Measured {
+  readonly size: number
+  readonly modified: number
+}
+
+export interface Answering {
+  readonly kind: (at: string) => Kind
+  readonly read: (at: string) => string
+  readonly write: (at: string, said: string) => void
+  readonly list: (at: string) => readonly Listed[]
+  readonly stat: (at: string) => Measured
+  readonly remove: (at: string) => void
+  readonly real: (at: string) => string
+}
+
+const CHANNEL = 'THREAD_CHANNEL'
+
+const WAITING = 180000
+
+function overFiles(dir: string): Answering {
+  const idle = new Int32Array(new SharedArrayBuffer(4))
+  let spun = 0
+
+  const ask = (body: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>> => {
+    spun += 1
+    const name = `${dir}/${String(process.pid)}-${String(spun)}`
+    disk.writeFileSync(`${name}.asking`, JSON.stringify(body))
+    disk.renameSync(`${name}.asking`, `${name}.order`)
+    const until = Date.now() + WAITING
+    for (;;) {
+      let held: string | undefined
+      try {
+        held = disk.readFileSync(`${name}.answer`, 'utf8')
+      } catch {
+        held = undefined
+      }
+      if (held !== undefined) {
+        disk.rmSync(`${name}.answer`, { force: true })
+        const said = JSON.parse(held) as Readonly<Record<string, unknown>>
+        if (said.answered === 'refused') throw new Error(String(said.because))
+        return said
+      }
+      if (Date.now() > until)
+        throw new Error(
+          'nothing answered ' +
+            String(body.order) +
+            ' ' +
+            String(body.at) +
+            ' for three minutes, so this stopped waiting rather than spinning forever. Whoever was answering is gone. It waits longer than a server waits before giving up on a run, on purpose: if an answer were still coming it would have arrived. Nothing here is half-written — one order is one file, and it was either answered or it was not.',
+        )
+      Atomics.wait(idle, 0, 0, 2)
+    }
+  }
+
+  return {
+    kind: (at) => ask({ order: 'kind', at }).held as Kind,
+    read: (at) => ask({ order: 'read', at }).said as string,
+    write: (at, said) => {
+      ask({ order: 'write', at, said })
+    },
+    list: (at) => ask({ order: 'list', at }).held as readonly Listed[],
+    stat: (at) => ask({ order: 'stat', at }).held as Measured,
+    remove: (at) => {
+      ask({ order: 'remove', at })
+    },
+    real: (at) => ask({ order: 'real', at }).at as string,
+  }
+}
+
+const WHERE = process.env[CHANNEL]
+
+let answering: Answering | undefined = WHERE !== undefined && WHERE !== '' ? overFiles(WHERE) : undefined
+
+export function answeredBy(one: Answering | undefined): void {
+  answering = one
+}
+
+const asked = (at: unknown): Answering | undefined => (typeof at === 'string' ? answering : undefined)
+
+export function attached(): boolean {
+  return answering !== undefined
+}
+
+export function kind(at: string): Kind {
+  const one = answering
+  if (one !== undefined) return one.kind(at)
+  const held = disk.statSync(at, { throwIfNoEntry: false })
+  if (held === undefined) return 'none'
+  return held.isFile() ? 'file' : held.isDirectory() ? 'folder' : 'other'
+}
+
+export function existsSync(at: disk.PathLike): boolean {
+  return typeof at === 'string' ? kind(at) !== 'none' : disk.existsSync(at)
+}
+
+export function readFileSync(at: disk.PathOrFileDescriptor, how?: BufferEncoding): string {
+  const one = asked(at)
+  return one === undefined ? disk.readFileSync(at, how ?? 'utf8') : one.read(at as string)
+}
+
+export function writeFileSync(at: disk.PathOrFileDescriptor, said: string, how?: BufferEncoding): void {
+  const one = asked(at)
+  if (one !== undefined) {
+    one.write(at as string, said)
+    return
+  }
+  if (typeof at === 'string') disk.mkdirSync(dirname(at), { recursive: true })
+  disk.writeFileSync(at, said, how ?? 'utf8')
+}
+
+export interface Named {
+  readonly name: string
+  readonly isFile: () => boolean
+  readonly isDirectory: () => boolean
+}
+
+export function readdirSync(at: disk.PathLike): string[]
+export function readdirSync(at: disk.PathLike, how: { readonly withFileTypes: true }): readonly Named[]
+export function readdirSync(at: disk.PathLike, how?: { readonly withFileTypes: true }): string[] | readonly Named[] {
+  const one = asked(at)
+  if (one === undefined) return how === undefined ? disk.readdirSync(at) : disk.readdirSync(at, how)
+  const held = one.list(at as string)
+  return how === undefined
+    ? held.map((each) => each.name)
+    : held.map((each) => ({ name: each.name, isFile: () => each.kind === 'file', isDirectory: () => each.kind === 'folder' }))
+}
+
+export interface Held extends Named, Measured {
+  readonly mtimeMs: number
+}
+
+export function statSync(at: disk.PathLike): Held
+export function statSync(at: disk.PathLike, how: { readonly throwIfNoEntry: false }): Held | undefined
+export function statSync(at: disk.PathLike, how?: { readonly throwIfNoEntry: false }): Held | undefined {
+  const one = asked(at)
+  if (one === undefined) return (how === undefined ? disk.statSync(at) : disk.statSync(at, how)) as Held | undefined
+  const path = at as string
+  const held = one.kind(path)
+  if (held === 'none') {
+    if (how !== undefined) return undefined
+    throw new Error(`${path} is not there, so nothing can be said about it.`)
+  }
+  const measured = one.stat(path)
+  return {
+    name: path,
+    size: measured.size,
+    modified: measured.modified,
+    mtimeMs: measured.modified,
+    isFile: () => held === 'file',
+    isDirectory: () => held === 'folder',
+  }
+}
+
+export function rmSync(at: disk.PathLike, how?: disk.RmOptions): void {
+  const one = asked(at)
+  if (one === undefined) disk.rmSync(at, how)
+  else one.remove(at as string)
+}
+
+export function renameSync(from: disk.PathLike, to: disk.PathLike): void {
+  const one = asked(from)
+  if (one === undefined) {
+    disk.renameSync(from, to)
+    return
+  }
+  one.write(to as string, one.read(from as string))
+  one.remove(from as string)
+}
+
+export function appendFileSync(at: disk.PathOrFileDescriptor, said: string): void {
+  const one = asked(at)
+  if (one === undefined) {
+    disk.appendFileSync(at, said)
+    return
+  }
+  const path = at as string
+  one.write(path, `${one.kind(path) === 'none' ? '' : one.read(path)}${said}`)
+}
+
+export function realpathSync(at: disk.PathLike): string {
+  const one = asked(at)
+  return one === undefined ? disk.realpathSync(at as string) : one.real(at as string)
+}

package/dist/core/init.d.ts

@@ -6,6 +6,7 @@ export declare class AlreadyThreadedError extends Error {
 }
 export declare const COMPILER = "tsconfig.json";
 export declare const LOCKFILES: readonly ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb"];
+export declare function manager(into: string): readonly string[];
 export declare const MANIFEST = "package.json";
 export declare const REGISTRY: string;
 export declare const IGNORED: string;

package/dist/core/init.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from "./files.js";
 import { join, relative, resolve } from 'node:path';
 import { quoted } from "./rows.js";
 export const TREE = '_threads';
@@ -15,6 +15,15 @@ export class AlreadyThreadedError extends Error {
 }
 export const COMPILER = 'tsconfig.json';
 export const LOCKFILES = ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb'];
+export function manager(into) {
+    if (existsSync(join(into, 'pnpm-lock.yaml')))
+        return ['pnpm', 'add'];
+    if (existsSync(join(into, 'yarn.lock')))
+        return ['yarn', 'add'];
+    if (existsSync(join(into, 'bun.lockb')))
+        return ['bun', 'add'];
+    return ['npm', 'install'];
+}
 export const MANIFEST = 'package.json';
 const MODULE = 'module';
 export const REGISTRY = '.npm' + 'rc';
@@ -104,7 +113,6 @@ export function init(into) {
     const at = join(dir, ROOT);
     if (existsSync(at))
         throw new AlreadyThreadedError(relative(into, at));
-    mkdirSync(dir, { recursive: true });
     const written = [];
     const held = join(into, COMPILER);
     if (!existsSync(held)) {

package/dist/core/init.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { existsSync, readFileSync, writeFileSync } from './files.ts'
 import { join, relative, resolve } from 'node:path'
 
 import { quoted } from './rows.ts'
@@ -24,6 +24,13 @@ export const COMPILER = 'tsconfig.json'
 
 export const LOCKFILES = ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb'] as const
 
+export function manager(into: string): readonly string[] {
+  if (existsSync(join(into, 'pnpm-lock.yaml'))) return ['pnpm', 'add']
+  if (existsSync(join(into, 'yarn.lock'))) return ['yarn', 'add']
+  if (existsSync(join(into, 'bun.lockb'))) return ['bun', 'add']
+  return ['npm', 'install']
+}
+
 export const MANIFEST = 'package.json'
 
 const MODULE = 'module'
@@ -134,7 +141,6 @@ export function init(into: string): readonly string[] {
   const dir = resolve(into, TREE)
   const at = join(dir, ROOT)
   if (existsSync(at)) throw new AlreadyThreadedError(relative(into, at))
-  mkdirSync(dir, { recursive: true })
   const written: string[] = []
 
   const held = join(into, COMPILER)

package/dist/core/invoked.js

@@ -21,7 +21,7 @@ export const BESIDE = (name) => `${name}${SOURCE ? '.ts' : '.js'}`;
 export const LOADER = SOURCE ? ['--import', 'tsx'] : [];
 export const CLI = [
     ...LOADER,
-    join(dirname(fileURLToPath(import.meta.url)), BESIDE('cli')),
+    join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'cli', BESIDE('cli')),
 ];
 export const REFUSED = Symbol.for('thread.refused');
 let sharing = false;

package/dist/core/invoked.ts

@@ -24,7 +24,7 @@ export const LOADER: readonly string[] = SOURCE ? ['--import', 'tsx'] : []
 
 export const CLI: readonly string[] = [
   ...LOADER,
-  join(dirname(fileURLToPath(import.meta.url)), BESIDE('cli')),
+  join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'cli', BESIDE('cli')),
 ]
 
 export const REFUSED = Symbol.for('thread.refused')

package/dist/core/rows.d.ts

@@ -18,6 +18,8 @@ export declare function withRequires(text: string, where: Bounds, id: string, re
 export declare function seedsIn(text: string, where: Bounds, id: string): Bounds | undefined;
 export declare function afterRow(text: string, where: Bounds, follows: string, row: string): string | undefined;
 export declare const quoted: (one: string) => string;
+export declare function valuesIn(text: string): Readonly<Record<string, unknown>>;
+export declare function unread(text: string): readonly string[];
 export declare const STATED: string[];
 export declare function reconciled(held: string, source: string, fields: readonly string[]): string;
 export declare function fieldIn(text: string, where: Bounds, id: string, field: string): string | undefined;

package/dist/core/rows.js

@@ -239,6 +239,71 @@ function stated(node, field) {
     return undefined;
 }
 export const quoted = (one) => `'${one.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n')}'`;
+const UNREAD = Symbol.for('thread.unread');
+function valued(node) {
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+        return node.text;
+    if (ts.isNumericLiteral(node))
+        return Number(node.text);
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+        return true;
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+        return false;
+    if (node.kind === ts.SyntaxKind.NullKeyword)
+        return null;
+    if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isParenthesizedExpression(node))
+        return valued(node.expression);
+    if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken) {
+        const held = valued(node.operand);
+        return typeof held === 'number' ? -held : UNREAD;
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        const held = [];
+        for (const one of node.elements) {
+            const each = valued(one);
+            if (each === UNREAD)
+                return UNREAD;
+            held.push(each);
+        }
+        return held;
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        const held = {};
+        for (const one of node.properties) {
+            if (!ts.isPropertyAssignment(one))
+                return UNREAD;
+            const key = keyed(one);
+            if (key === undefined)
+                return UNREAD;
+            const each = valued(one.initializer);
+            if (each === UNREAD)
+                return UNREAD;
+            held[key] = each;
+        }
+        return held;
+    }
+    return UNREAD;
+}
+function taken(text) {
+    const found = [];
+    walk(tree(text), (node) => {
+        if (!ts.isVariableDeclaration(node) || node.initializer === undefined || !ts.isIdentifier(node.name))
+            return;
+        found.push([node.name.text, valued(node.initializer)]);
+    });
+    return found;
+}
+export function valuesIn(text) {
+    const found = {};
+    for (const [name, held] of taken(text)) {
+        if (held !== UNREAD)
+            found[name] = held;
+    }
+    return found;
+}
+export function unread(text) {
+    return taken(text).filter(([, held]) => held === UNREAD).map(([name]) => name);
+}
 export const STATED = ['at', 'describes', 'version'];
 export function reconciled(held, source, fields) {
     const ships = headed(source);

package/dist/core/rows.ts

@@ -252,6 +252,64 @@ function stated(node: ts.ObjectLiteralExpression, field: string): Bounds | undef
 
 export const quoted = (one: string): string => `'${one.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n')}'`
 
+const UNREAD = Symbol.for('thread.unread')
+
+function valued(node: ts.Expression): unknown {
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text
+  if (ts.isNumericLiteral(node)) return Number(node.text)
+  if (node.kind === ts.SyntaxKind.TrueKeyword) return true
+  if (node.kind === ts.SyntaxKind.FalseKeyword) return false
+  if (node.kind === ts.SyntaxKind.NullKeyword) return null
+  if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isParenthesizedExpression(node)) return valued(node.expression)
+  if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken) {
+    const held = valued(node.operand)
+    return typeof held === 'number' ? -held : UNREAD
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    const held: unknown[] = []
+    for (const one of node.elements) {
+      const each = valued(one)
+      if (each === UNREAD) return UNREAD
+      held.push(each)
+    }
+    return held
+  }
+  if (ts.isObjectLiteralExpression(node)) {
+    const held: Record<string, unknown> = {}
+    for (const one of node.properties) {
+      if (!ts.isPropertyAssignment(one)) return UNREAD
+      const key = keyed(one)
+      if (key === undefined) return UNREAD
+      const each = valued(one.initializer)
+      if (each === UNREAD) return UNREAD
+      held[key] = each
+    }
+    return held
+  }
+  return UNREAD
+}
+
+function taken(text: string): readonly (readonly [string, unknown])[] {
+  const found: (readonly [string, unknown])[] = []
+  walk(tree(text), (node) => {
+    if (!ts.isVariableDeclaration(node) || node.initializer === undefined || !ts.isIdentifier(node.name)) return
+    found.push([node.name.text, valued(node.initializer)])
+  })
+  return found
+}
+
+export function valuesIn(text: string): Readonly<Record<string, unknown>> {
+  const found: Record<string, unknown> = {}
+  for (const [name, held] of taken(text)) {
+    if (held !== UNREAD) found[name] = held
+  }
+  return found
+}
+
+export function unread(text: string): readonly string[] {
+  return taken(text).filter(([, held]) => held === UNREAD).map(([name]) => name)
+}
+
 export const STATED = ['at', 'describes', 'version']
 
 export function reconciled(held: string, source: string, fields: readonly string[]): string {

package/dist/core/tree.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from "./files.js";
 import { dirname, join, relative, resolve } from 'node:path';
 import { cwd } from 'node:process';
 const NAMES = ['_threads', 'threads'];

package/dist/core/tree.ts

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, statSync } from 'node:fs'
+import { existsSync, readdirSync, statSync } from './files.ts'
 import { dirname, join, relative, resolve } from 'node:path'
 import { cwd } from 'node:process'
 

package/dist/derivation/attach.js

@@ -39,18 +39,6 @@ const SHIPPED = [
         id: 'release-generator',
         source: "  {\n    id: 'release-generator',\n    at: 'node_modules/@prestack/thread/dist/derivation/generators/release.js',\n    describes: 'The writer of what a host reads to run this app — it derives the config from what the app already declares, its own build and start commands and the names of every secret it says it must be given, and refuses to write while this app installs a package of this framework as a dependency, because what a host runs may hold nothing of the scaffolding that assembled it.',\n    version: 1,\n    by: 'thread release',\n    runs: 'thread release --check',\n  },",
     },
-    {
-        into: 'derivation.ts',
-        list: 'GENERATORS',
-        id: 'release-noun',
-        source: "  {\n    id: 'release-noun',\n    at: 'node_modules/@prestack/thread/dist/derivation/makers/release.js',\n    describes: 'The command that declares where this app goes when it leaves your machine. It writes the row saying where this app goes and nothing else, because everything the config needs is already declared somewhere and asking for it again would be the app’s own facts typed a second time.',\n    version: 1,\n    by: 'thread create release',\n  },",
-    },
-    {
-        into: 'derivation.ts',
-        list: 'GENERATORS',
-        id: 'generator-noun',
-        source: "  {\n    id: 'generator-noun',\n    at: 'node_modules/@prestack/thread/dist/derivation/generators/derivation.js',\n    describes: 'Declares a generator this app derives a file with. `thread create generator` asks what it is, where its file goes and the command that writes it, then writes the row and seeds the file beside it — so a generator arrives through the same wizard as everything else, and the command it names exists from that moment because the CLI reads every `by:` the tree states.',\n    version: 1,\n    by: 'thread create generator',\n  },",
-    },
 ];
 export const ATTACH = {
     attaches: SEEDED.attaches,

package/dist/derivation/attach.ts

@@ -46,18 +46,6 @@ const SHIPPED: readonly { readonly into: string; readonly list: string; readonly
     id: 'release-generator',
     source: "  {\n    id: 'release-generator',\n    at: 'node_modules/@prestack/thread/dist/derivation/generators/release.js',\n    describes: 'The writer of what a host reads to run this app — it derives the config from what the app already declares, its own build and start commands and the names of every secret it says it must be given, and refuses to write while this app installs a package of this framework as a dependency, because what a host runs may hold nothing of the scaffolding that assembled it.',\n    version: 1,\n    by: 'thread release',\n    runs: 'thread release --check',\n  },",
   },
-  {
-    into: 'derivation.ts',
-    list: 'GENERATORS',
-    id: 'release-noun',
-    source: "  {\n    id: 'release-noun',\n    at: 'node_modules/@prestack/thread/dist/derivation/makers/release.js',\n    describes: 'The command that declares where this app goes when it leaves your machine. It writes the row saying where this app goes and nothing else, because everything the config needs is already declared somewhere and asking for it again would be the app’s own facts typed a second time.',\n    version: 1,\n    by: 'thread create release',\n  },",
-  },
-  {
-    into: 'derivation.ts',
-    list: 'GENERATORS',
-    id: 'generator-noun',
-    source: "  {\n    id: 'generator-noun',\n    at: 'node_modules/@prestack/thread/dist/derivation/generators/derivation.js',\n    describes: 'Declares a generator this app derives a file with. `thread create generator` asks what it is, where its file goes and the command that writes it, then writes the row and seeds the file beside it — so a generator arrives through the same wizard as everything else, and the command it names exists from that moment because the CLI reads every `by:` the tree states.',\n    version: 1,\n    by: 'thread create generator',\n  },",
-  },
 ]
 export const ATTACH: Attaching = {
   attaches: SEEDED.attaches,

package/dist/derivation/generators/build.js

@@ -6,13 +6,14 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { existsSync, readFileSync } from 'node:fs';
 import { relative, resolve } from 'node:path';
 import { argv, stderr, stdout } from 'node:process';
 import { pathToFileURL } from 'node:url';
 import { build } from 'esbuild';
 import { descend, reached } from "../../core/descend.js";
+import { existsSync, readFileSync } from "../../core/files.js";
 import { exit, invoked } from "../../core/invoked.js";
+import { valuesIn } from "../../core/rows.js";
 import { findTree } from "../../core/tree.js";
 import { servesBrowser } from "../../integrations/target.js";
 const TREE = findTree();
@@ -57,23 +58,23 @@ const JSX = /\.(c|m)?(t|j)sx$/;
 function browsing(entry) {
     return JSX.test(entry);
 }
-async function sheet(file, list) {
+function sheet(file, list) {
     const path = resolve(ROOT, `${TREE.name}/${file}`);
     if (!existsSync(path))
         return [];
     try {
-        const held = (await import(__rewriteRelativeImportExtension(pathToFileURL(path).href)));
+        const held = valuesIn(readFileSync(path, 'utf8'));
         return held[list] ?? [];
     }
     catch {
         return [];
     }
 }
-async function withheld(pass) {
-    const targets = await sheet('targets.ts', 'TARGETS');
+function withheld(pass) {
+    const targets = sheet('targets.ts', 'TARGETS');
     if (targets.length === 0)
         return new Map();
-    const secrets = await sheet('secrets.ts', 'SECRETS');
+    const secrets = sheet('secrets.ts', 'SECRETS');
     const because = new Map();
     for (const one of targets) {
         const said = servesBrowser(one, secrets);
@@ -184,7 +185,7 @@ async function main() {
             exit(1);
         }
         const forBrowser = browsing(entry);
-        const refusals = forBrowser ? await withheld(pass) : new Map();
+        const refusals = forBrowser ? withheld(pass) : new Map();
         const held = await build({
             entryPoints: [resolve(ROOT, entry)],
             bundle: true,

package/dist/derivation/generators/build.ts

@@ -1,4 +1,3 @@
-import { existsSync, readFileSync } from 'node:fs'
 import { relative, resolve } from 'node:path'
 import { argv, stderr, stdout } from 'node:process'
 import { pathToFileURL } from 'node:url'
@@ -6,7 +5,9 @@ import { pathToFileURL } from 'node:url'
 import { build } from 'esbuild'
 
 import { descend, reached, type Pass } from '../../core/descend.ts'
+import { existsSync, readFileSync } from '../../core/files.ts'
 import { exit, invoked } from '../../core/invoked.ts'
+import { valuesIn } from '../../core/rows.ts'
 import { findTree } from '../../core/tree.ts'
 import type { Secret } from '../../integrations/secret.ts'
 import { servesBrowser, type Target } from '../../integrations/target.ts'
@@ -59,21 +60,21 @@ function browsing(entry: string): boolean {
   return JSX.test(entry)
 }
 
-async function sheet<T>(file: string, list: string): Promise<readonly T[]> {
+function sheet<T>(file: string, list: string): readonly T[] {
   const path = resolve(ROOT, `${TREE.name}/${file}`)
   if (!existsSync(path)) return []
   try {
-    const held = (await import(pathToFileURL(path).href)) as Record<string, readonly T[] | undefined>
+    const held = valuesIn(readFileSync(path, 'utf8')) as Record<string, readonly T[] | undefined>
     return held[list] ?? []
   } catch {
     return []
   }
 }
 
-async function withheld(pass: Pass): Promise<ReadonlyMap<string, string>> {
-  const targets = await sheet<Target>('targets.ts', 'TARGETS')
+function withheld(pass: Pass): ReadonlyMap<string, string> {
+  const targets = sheet<Target>('targets.ts', 'TARGETS')
   if (targets.length === 0) return new Map()
-  const secrets = await sheet<Secret>('secrets.ts', 'SECRETS')
+  const secrets = sheet<Secret>('secrets.ts', 'SECRETS')
 
   const because = new Map<string, string>()
   for (const one of targets) {
@@ -193,7 +194,7 @@ async function main(): Promise<void> {
     }
 
     const forBrowser = browsing(entry)
-    const refusals = forBrowser ? await withheld(pass) : new Map<string, string>()
+    const refusals = forBrowser ? withheld(pass) : new Map<string, string>()
 
     const held = await build({
       entryPoints: [resolve(ROOT, entry)],

package/dist/derivation/generators/release.d.ts

@@ -1,3 +1,3 @@
 import { CHECKED_BY, WRITES } from '../release.ts';
-declare function made(): Promise<ReadonlyMap<string, string>>;
+declare function made(): ReadonlyMap<string, string>;
 export { CHECKED_BY, WRITES, made };