@prestack/thread 0.0.3 → 0.1.1

package/dist/core/descend.js

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { attached, existsSync, kind, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "./files.js";
 import { dirname, join, relative, resolve } from 'node:path';
 import ts from 'typescript';
 import { ignored } from "./init.js";
@@ -26,12 +26,17 @@ function rooted() {
 export const ROOT = TREE_AT?.at ?? NOWHERE;
 export const TREE = `${TREE_AT?.name ?? NOWHERE}/`;
 export const THREAD_AT = `${TREE_AT?.name ?? NOWHERE}/thread.ts`;
-const OWN_IGNORES = (() => {
-    if (spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: ROOT, stdio: 'ignore' }).status === 0) {
-        return undefined;
+let ignores;
+let readIgnores = false;
+function ownIgnores() {
+    if (readIgnores)
+        return ignores;
+    readIgnores = true;
+    if (!attached() && spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: ROOT, stdio: 'ignore' }).status === 0) {
+        return ignores;
     }
     try {
-        return readFileSync(join(ROOT, '.gitignore'), 'utf8')
+        ignores = readFileSync(join(ROOT, '.gitignore'), 'utf8')
             .split('\n')
             .map((one) => one.trim())
             .filter((one) => one !== '' && !one.startsWith('#') && !one.startsWith('!'))
@@ -39,21 +44,24 @@ const OWN_IGNORES = (() => {
             .filter((one) => one !== '' && !one.includes('*'));
     }
     catch {
-        return [];
+        ignores = [];
     }
-})();
+    return ignores;
+}
 const asked = new Map();
 export function unkept(at) {
     const held = asked.get(at);
     if (held !== undefined)
         return held;
-    const found = OWN_IGNORES === undefined
+    const own = ownIgnores();
+    const found = own === undefined
         ? spawnSync('git', ['check-ignore', '-q', '--', at], { cwd: ROOT, stdio: 'ignore' }).status === 0
-        : OWN_IGNORES.some((one) => at === one || at.startsWith(`${one}/`) || at.split('/').includes(one));
+        : own.some((one) => at === one || at.startsWith(`${one}/`) || at.split('/').includes(one));
     asked.set(at, found);
     return found;
 }
 export const LISTS = ['declares', 'derives', 'seeds'];
+export const ROW_LISTS = [...LISTS, 'holds'];
 const SOURCE = /\.(ts|tsx|mts|cts)$/;
 const RUNNER = /^(?:pnpm|npm|yarn) (?:run )?([\w:.-]+)/;
 export function under(pass, id, root, seen = new Set()) {
@@ -148,12 +156,67 @@ const INVARIANT = {
     allowJs: true,
     jsx: ts.JsxEmit.ReactJSX,
 };
+const NEVER = ['node_modules', 'bower_components', 'jspm_packages'];
+function bounds(from, one) {
+    const star = one.indexOf('*');
+    if (star === -1)
+        return { under: resolve(from, one), ending: '' };
+    const head = one.slice(0, star);
+    const cut = head.lastIndexOf('/');
+    const tail = one.slice(star);
+    const dot = tail.lastIndexOf('.');
+    const end = dot === -1 ? '' : tail.slice(dot);
+    return {
+        under: resolve(from, cut === -1 ? '' : head.slice(0, cut)),
+        ending: end.includes('/') || end.includes('*') ? '' : end,
+    };
+}
+function wanted(at, only) {
+    if (only.length === 0)
+        return true;
+    return only.some((one) => (at === one.under || at.startsWith(`${one.under}/`)) && at.endsWith(one.ending));
+}
+function listing(at, take, skip, only, deep) {
+    const found = [];
+    if (deep < 0 || !existsSync(at))
+        return found;
+    for (const one of readdirSync(at, { withFileTypes: true })) {
+        const full = join(at, one.name);
+        if (skip.some((each) => full === each || full.startsWith(`${each}/`)))
+            continue;
+        if (one.isDirectory()) {
+            if (NEVER.includes(one.name))
+                continue;
+            found.push(...listing(full, take, skip, only, deep - 1));
+        }
+        else if (take.some((each) => one.name.endsWith(each)) && wanted(full, only)) {
+            found.push(full);
+        }
+    }
+    return found;
+}
+function parsing(from) {
+    return {
+        useCaseSensitiveFileNames: true,
+        fileExists: (at) => existsSync(at),
+        readFile: (at) => {
+            try {
+                return readFileSync(at);
+            }
+            catch {
+                return undefined;
+            }
+        },
+        readDirectory: (at, take, skip, only, deep) => listing(at, take, (skip ?? []).map((one) => resolve(from, one.endsWith('/**') ? one.slice(0, -3) : one)), only.map((one) => bounds(from, one)), deep ?? Number.MAX_SAFE_INTEGER),
+    };
+}
 export function configured() {
     for (const name of CONFIGS) {
         const at = join(ROOT, name);
-        if (!ts.sys.fileExists(at))
+        if (!existsSync(at))
             continue;
-        const held = ts.readConfigFile(at, ts.sys.readFile.bind(ts.sys));
+        const host = parsing(ROOT);
+        const held = ts.readConfigFile(at, host.readFile);
         if (held.error !== undefined) {
             return {
                 options: { ...FALLBACK, ...INVARIANT },
@@ -161,7 +224,7 @@ export function configured() {
                 trouble: `${name} is there and cannot be read: ${ts.flattenDiagnosticMessageText(held.error.messageText, ' ')}`,
             };
         }
-        const parsed = ts.parseJsonConfigFileContent(held.config, ts.sys, dirname(at));
+        const parsed = ts.parseJsonConfigFileContent(held.config, host, dirname(at));
         const complained = parsed.errors[0];
         if (complained !== undefined) {
             return {
@@ -174,13 +237,37 @@ export function configured() {
     }
     return { options: { ...FALLBACK, ...INVARIANT }, from: '' };
 }
+export function hosting(options) {
+    const host = ts.createCompilerHost(options, true);
+    const lib = host.getDefaultLibLocation?.();
+    const toolchain = (at) => lib !== undefined && (at === lib || at.startsWith(`${lib}/`));
+    return {
+        ...host,
+        fileExists: (at) => (toolchain(at) ? host.fileExists(at) : kind(at) === 'file'),
+        directoryExists: (at) => (toolchain(at) ? (host.directoryExists?.(at) ?? false) : kind(at) === 'folder'),
+        readFile: (at) => (toolchain(at) ? host.readFile(at) : kind(at) === 'file' ? readFileSync(at) : undefined),
+        getSourceFile: (at, version) => {
+            if (toolchain(at))
+                return host.getSourceFile(at, version);
+            if (kind(at) !== 'file')
+                return undefined;
+            return ts.createSourceFile(at, readFileSync(at), version, true);
+        },
+        getDirectories: (at) => kind(at) === 'folder' ? readdirSync(at, { withFileTypes: true }).filter((one) => one.isDirectory()).map((one) => one.name) : [],
+        realpath: (at) => (toolchain(at) ? (host.realpath?.(at) ?? at) : realpathSync(at)),
+        writeFile: (at, said) => {
+            writeFileSync(at, said);
+        },
+    };
+}
 let built;
 function compiled() {
     rooted();
     if (built !== undefined)
         return built;
     const roots = [THREAD_AT, ...sources(), ...shipped()].filter((one) => SOURCE.test(one)).map((one) => resolve(ROOT, one));
-    const program = ts.createProgram([...new Set(roots)], configured().options);
+    const options = configured().options;
+    const program = ts.createProgram([...new Set(roots)], options, hosting(options));
     built = { program, checker: program.getTypeChecker() };
     return built;
 }
@@ -585,6 +672,9 @@ export function forget() {
     scanned = undefined;
     commands = undefined;
     source.clear();
+    asked.clear();
+    ignores = undefined;
+    readIgnores = false;
 }
 export function descend() {
     rooted();
@@ -762,7 +852,10 @@ export function descend() {
                 continue;
             }
             for (const one of value.elements) {
-                if (!ts.isObjectLiteralExpression(one)) {
+                const declaration = ts.isIdentifier(one) ? checker.getSymbolAtLocation(one)?.valueDeclaration : undefined;
+                const initial = declaration !== undefined && ts.isVariableDeclaration(declaration) ? unwrap(declaration.initializer) : undefined;
+                const object = ts.isObjectLiteralExpression(one) ? one : initial !== undefined && ts.isObjectLiteralExpression(initial) ? initial : undefined;
+                if (object === undefined) {
                     findings.push({
                         file: at,
                         detail: `\`${by}\` holds something in \`${list}\` that is not a row written out here`,
@@ -773,7 +866,7 @@ export function descend() {
                 rows += 1;
                 const wanted = checker.getContextualType(one);
                 const kind = wanted === undefined ? undefined : elementOf(checker, wanted);
-                const row = rowOf(one, kind === undefined ? type : checker.typeToString(kind), at, kind);
+                const row = rowOf(object, kind === undefined ? type : checker.typeToString(kind), at, kind);
                 coin(row.id, row.describes, under, by);
                 judge(row, by, list, false);
                 if (row.at !== undefined) {
@@ -782,7 +875,7 @@ export function descend() {
                         derived.set(row.id, row);
                 }
                 if (LISTS.some((name) => row.fields.has(name)))
-                    into(one, row.type, at, under, by, true);
+                    into(object, row.type, at, under, by, true);
                 if (row.at !== undefined)
                     open(row.at, wanted === undefined ? undefined : elementOf(checker, wanted), under, row.id ?? by, by);
             }

package/dist/core/descend.ts

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process'
-import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs'
+import { attached, existsSync, kind, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from './files.ts'
 import { dirname, join, relative, resolve } from 'node:path'
 
 import ts from 'typescript'
@@ -35,37 +35,46 @@ export const ROOT = TREE_AT?.at ?? NOWHERE
 export const TREE = `${TREE_AT?.name ?? NOWHERE}/`
 export const THREAD_AT = `${TREE_AT?.name ?? NOWHERE}/thread.ts`
 
-const OWN_IGNORES: readonly string[] | undefined = (() => {
-  if (spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: ROOT, stdio: 'ignore' }).status === 0) {
-    return undefined
+let ignores: readonly string[] | undefined
+let readIgnores = false
+
+function ownIgnores(): readonly string[] | undefined {
+  if (readIgnores) return ignores
+  readIgnores = true
+  if (!attached() && spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: ROOT, stdio: 'ignore' }).status === 0) {
+    return ignores
   }
   try {
-    return readFileSync(join(ROOT, '.gitignore'), 'utf8')
+    ignores = readFileSync(join(ROOT, '.gitignore'), 'utf8')
       .split('\n')
       .map((one) => one.trim())
       .filter((one) => one !== '' && !one.startsWith('#') && !one.startsWith('!'))
       .map((one) => one.replace(/^\/+|\/+$/g, ''))
       .filter((one) => one !== '' && !one.includes('*'))
   } catch {
-    return []
+    ignores = []
   }
-})()
+  return ignores
+}
 
 const asked = new Map<string, boolean>()
 
 export function unkept(at: string): boolean {
   const held = asked.get(at)
   if (held !== undefined) return held
+  const own = ownIgnores()
   const found =
-    OWN_IGNORES === undefined
+    own === undefined
       ? spawnSync('git', ['check-ignore', '-q', '--', at], { cwd: ROOT, stdio: 'ignore' }).status === 0
-      : OWN_IGNORES.some((one) => at === one || at.startsWith(`${one}/`) || at.split('/').includes(one))
+      : own.some((one) => at === one || at.startsWith(`${one}/`) || at.split('/').includes(one))
   asked.set(at, found)
   return found
 }
 
 export const LISTS = ['declares', 'derives', 'seeds'] as const
 
+export const ROW_LISTS = [...LISTS, 'holds'] as const
+
 const SOURCE = /\.(ts|tsx|mts|cts)$/
 const RUNNER = /^(?:pnpm|npm|yarn) (?:run )?([\w:.-]+)/
 
@@ -198,12 +207,77 @@ const INVARIANT: ts.CompilerOptions = {
   jsx: ts.JsxEmit.ReactJSX,
 }
 
+const NEVER: readonly string[] = ['node_modules', 'bower_components', 'jspm_packages']
+
+interface Wanted {
+  readonly under: string
+  readonly ending: string
+}
+
+function bounds(from: string, one: string): Wanted {
+  const star = one.indexOf('*')
+  if (star === -1) return { under: resolve(from, one), ending: '' }
+  const head = one.slice(0, star)
+  const cut = head.lastIndexOf('/')
+  const tail = one.slice(star)
+  const dot = tail.lastIndexOf('.')
+  const end = dot === -1 ? '' : tail.slice(dot)
+  return {
+    under: resolve(from, cut === -1 ? '' : head.slice(0, cut)),
+    ending: end.includes('/') || end.includes('*') ? '' : end,
+  }
+}
+
+function wanted(at: string, only: readonly Wanted[]): boolean {
+  if (only.length === 0) return true
+  return only.some((one) => (at === one.under || at.startsWith(`${one.under}/`)) && at.endsWith(one.ending))
+}
+
+function listing(at: string, take: readonly string[], skip: readonly string[], only: readonly Wanted[], deep: number): readonly string[] {
+  const found: string[] = []
+  if (deep < 0 || !existsSync(at)) return found
+  for (const one of readdirSync(at, { withFileTypes: true })) {
+    const full = join(at, one.name)
+    if (skip.some((each) => full === each || full.startsWith(`${each}/`))) continue
+    if (one.isDirectory()) {
+      if (NEVER.includes(one.name)) continue
+      found.push(...listing(full, take, skip, only, deep - 1))
+    } else if (take.some((each) => one.name.endsWith(each)) && wanted(full, only)) {
+      found.push(full)
+    }
+  }
+  return found
+}
+
+function parsing(from: string): ts.ParseConfigHost {
+  return {
+    useCaseSensitiveFileNames: true,
+    fileExists: (at) => existsSync(at),
+    readFile: (at) => {
+      try {
+        return readFileSync(at)
+      } catch {
+        return undefined
+      }
+    },
+    readDirectory: (at, take, skip, only, deep) =>
+      listing(
+        at,
+        take,
+        (skip ?? []).map((one) => resolve(from, one.endsWith('/**') ? one.slice(0, -3) : one)),
+        only.map((one) => bounds(from, one)),
+        deep ?? Number.MAX_SAFE_INTEGER,
+      ),
+  }
+}
+
 export function configured(): { readonly options: ts.CompilerOptions; readonly from: string; readonly trouble?: string } {
   for (const name of CONFIGS) {
     const at = join(ROOT, name)
-    if (!ts.sys.fileExists(at)) continue
+    if (!existsSync(at)) continue
 
-    const held = ts.readConfigFile(at, ts.sys.readFile.bind(ts.sys))
+    const host = parsing(ROOT)
+    const held = ts.readConfigFile(at, host.readFile)
     if (held.error !== undefined) {
       return {
         options: { ...FALLBACK, ...INVARIANT },
@@ -212,7 +286,7 @@ export function configured(): { readonly options: ts.CompilerOptions; readonly f
       }
     }
 
-    const parsed = ts.parseJsonConfigFileContent(held.config as object, ts.sys, dirname(at))
+    const parsed = ts.parseJsonConfigFileContent(held.config as object, host, dirname(at))
     const complained = parsed.errors[0]
     if (complained !== undefined) {
       return {
@@ -227,13 +301,37 @@ export function configured(): { readonly options: ts.CompilerOptions; readonly f
   return { options: { ...FALLBACK, ...INVARIANT }, from: '' }
 }
 
+export function hosting(options: ts.CompilerOptions): ts.CompilerHost {
+  const host = ts.createCompilerHost(options, true)
+  const lib = host.getDefaultLibLocation?.()
+  const toolchain = (at: string): boolean => lib !== undefined && (at === lib || at.startsWith(`${lib}/`))
+  return {
+    ...host,
+    fileExists: (at) => (toolchain(at) ? host.fileExists(at) : kind(at) === 'file'),
+    directoryExists: (at) => (toolchain(at) ? (host.directoryExists?.(at) ?? false) : kind(at) === 'folder'),
+    readFile: (at) => (toolchain(at) ? host.readFile(at) : kind(at) === 'file' ? readFileSync(at) : undefined),
+    getSourceFile: (at, version) => {
+      if (toolchain(at)) return host.getSourceFile(at, version)
+      if (kind(at) !== 'file') return undefined
+      return ts.createSourceFile(at, readFileSync(at), version, true)
+    },
+    getDirectories: (at) =>
+      kind(at) === 'folder' ? readdirSync(at, { withFileTypes: true }).filter((one) => one.isDirectory()).map((one) => one.name) : [],
+    realpath: (at) => (toolchain(at) ? (host.realpath?.(at) ?? at) : realpathSync(at)),
+    writeFile: (at, said) => {
+      writeFileSync(at, said)
+    },
+  }
+}
+
 let built: { program: ts.Program; checker: ts.TypeChecker } | undefined
 
 function compiled(): { program: ts.Program; checker: ts.TypeChecker } {
   rooted()
   if (built !== undefined) return built
   const roots = [THREAD_AT, ...sources(), ...shipped()].filter((one) => SOURCE.test(one)).map((one) => resolve(ROOT, one))
-  const program = ts.createProgram([...new Set(roots)], configured().options)
+  const options = configured().options
+  const program = ts.createProgram([...new Set(roots)], options, hosting(options))
   built = { program, checker: program.getTypeChecker() }
   return built
 }
@@ -659,6 +757,9 @@ export function forget(): void {
   scanned = undefined
   commands = undefined
   source.clear()
+  asked.clear()
+  ignores = undefined
+  readIgnores = false
 }
 
 export function descend(): Pass {
@@ -846,7 +947,10 @@ export function descend(): Pass {
       }
 
       for (const one of value.elements) {
-        if (!ts.isObjectLiteralExpression(one)) {
+        const declaration = ts.isIdentifier(one) ? checker.getSymbolAtLocation(one)?.valueDeclaration : undefined
+        const initial = declaration !== undefined && ts.isVariableDeclaration(declaration) ? unwrap(declaration.initializer) : undefined
+        const object = ts.isObjectLiteralExpression(one) ? one : initial !== undefined && ts.isObjectLiteralExpression(initial) ? initial : undefined
+        if (object === undefined) {
           findings.push({
             file: at,
             detail: `\`${by}\` holds something in \`${list}\` that is not a row written out here`,
@@ -857,14 +961,14 @@ export function descend(): Pass {
         rows += 1
         const wanted = checker.getContextualType(one)
         const kind = wanted === undefined ? undefined : elementOf(checker, wanted)
-        const row = rowOf(one, kind === undefined ? type : checker.typeToString(kind), at, kind)
+        const row = rowOf(object, kind === undefined ? type : checker.typeToString(kind), at, kind)
         coin(row.id, row.describes, under, by)
         judge(row, by, list, false)
         if (row.at !== undefined) {
           threaded.set(row.at, [...(threaded.get(row.at) ?? []), { list, by, row }])
           if (list === 'derives' && row.id !== undefined) derived.set(row.id, row)
         }
-        if (LISTS.some((name) => row.fields.has(name))) into(one, row.type, at, under, by, true)
+        if (LISTS.some((name) => row.fields.has(name))) into(object, row.type, at, under, by, true)
         if (row.at !== undefined) open(row.at, wanted === undefined ? undefined : elementOf(checker, wanted), under, row.id ?? by, by)
       }
     }

package/dist/core/files.d.ts

@@ -0,0 +1,45 @@
+import * as disk from 'node:fs';
+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;
+}
+export declare function answeredBy(one: Answering | undefined): void;
+export declare function attached(): boolean;
+export declare function kind(at: string): Kind;
+export declare function existsSync(at: disk.PathLike): boolean;
+export declare function readFileSync(at: disk.PathOrFileDescriptor, how?: BufferEncoding): string;
+export declare function writeFileSync(at: disk.PathOrFileDescriptor, said: string, how?: BufferEncoding): void;
+export interface Named {
+    readonly name: string;
+    readonly isFile: () => boolean;
+    readonly isDirectory: () => boolean;
+}
+export declare function readdirSync(at: disk.PathLike): string[];
+export declare function readdirSync(at: disk.PathLike, how: {
+    readonly withFileTypes: true;
+}): readonly Named[];
+export interface Held extends Named, Measured {
+    readonly mtimeMs: number;
+}
+export declare function statSync(at: disk.PathLike): Held;
+export declare function statSync(at: disk.PathLike, how: {
+    readonly throwIfNoEntry: false;
+}): Held | undefined;
+export declare function rmSync(at: disk.PathLike, how?: disk.RmOptions): void;
+export declare function renameSync(from: disk.PathLike, to: disk.PathLike): void;
+export declare function appendFileSync(at: disk.PathOrFileDescriptor, said: string): void;
+export declare function realpathSync(at: disk.PathLike): string;

package/dist/core/files.js

@@ -0,0 +1,145 @@
+import * as disk from 'node:fs';
+import { dirname } from 'node:path';
+const CHANNEL = 'THREAD_CHANNEL';
+const WAITING = 180000;
+function overFiles(dir) {
+    const idle = new Int32Array(new SharedArrayBuffer(4));
+    let spun = 0;
+    const ask = (body) => {
+        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;
+            try {
+                held = disk.readFileSync(`${name}.answer`, 'utf8');
+            }
+            catch {
+                held = undefined;
+            }
+            if (held !== undefined) {
+                disk.rmSync(`${name}.answer`, { force: true });
+                const said = JSON.parse(held);
+                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,
+        read: (at) => ask({ order: 'read', at }).said,
+        write: (at, said) => {
+            ask({ order: 'write', at, said });
+        },
+        list: (at) => ask({ order: 'list', at }).held,
+        stat: (at) => ask({ order: 'stat', at }).held,
+        remove: (at) => {
+            ask({ order: 'remove', at });
+        },
+        real: (at) => ask({ order: 'real', at }).at,
+    };
+}
+const WHERE = process.env[CHANNEL];
+let answering = WHERE !== undefined && WHERE !== '' ? overFiles(WHERE) : undefined;
+export function answeredBy(one) {
+    answering = one;
+}
+const asked = (at) => (typeof at === 'string' ? answering : undefined);
+export function attached() {
+    return answering !== undefined;
+}
+export function kind(at) {
+    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) {
+    return typeof at === 'string' ? kind(at) !== 'none' : disk.existsSync(at);
+}
+export function readFileSync(at, how) {
+    const one = asked(at);
+    return one === undefined ? disk.readFileSync(at, how ?? 'utf8') : one.read(at);
+}
+export function writeFileSync(at, said, how) {
+    const one = asked(at);
+    if (one !== undefined) {
+        one.write(at, said);
+        return;
+    }
+    if (typeof at === 'string')
+        disk.mkdirSync(dirname(at), { recursive: true });
+    disk.writeFileSync(at, said, how ?? 'utf8');
+}
+export function readdirSync(at, how) {
+    const one = asked(at);
+    if (one === undefined)
+        return how === undefined ? disk.readdirSync(at) : disk.readdirSync(at, how);
+    const held = one.list(at);
+    return how === undefined
+        ? held.map((each) => each.name)
+        : held.map((each) => ({ name: each.name, isFile: () => each.kind === 'file', isDirectory: () => each.kind === 'folder' }));
+}
+export function statSync(at, how) {
+    const one = asked(at);
+    if (one === undefined)
+        return (how === undefined ? disk.statSync(at) : disk.statSync(at, how));
+    const path = at;
+    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, how) {
+    const one = asked(at);
+    if (one === undefined)
+        disk.rmSync(at, how);
+    else
+        one.remove(at);
+}
+export function renameSync(from, to) {
+    const one = asked(from);
+    if (one === undefined) {
+        disk.renameSync(from, to);
+        return;
+    }
+    one.write(to, one.read(from));
+    one.remove(from);
+}
+export function appendFileSync(at, said) {
+    const one = asked(at);
+    if (one === undefined) {
+        disk.appendFileSync(at, said);
+        return;
+    }
+    const path = at;
+    one.write(path, `${one.kind(path) === 'none' ? '' : one.read(path)}${said}`);
+}
+export function realpathSync(at) {
+    const one = asked(at);
+    return one === undefined ? disk.realpathSync(at) : one.real(at);
+}