@qvac/harness 0.4.0 → 0.6.0

package/dist-lib/lib/tools/exec/adapters/python/worker/entry.js

@@ -7,24 +7,27 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import process from 'process';
+import { errorMessage, isRecord } from '../../../../../guards.js';
 import { setHarnessLog, setHarnessLogSink } from '../../../../../log.js';
 import { defaultLoad } from '../loader.js';
 import { performRun } from '../run-session.js';
 import { asHostMessage, toWireResult } from './protocol.js';
 function narrowThreadData(data) {
-    if (typeof data === 'object' && data !== null && 'sab' in data && 'handle' in data) {
+    if (isRecord(data) && 'sab' in data && 'handle' in data) {
         const sab = data.sab;
         const log = 'log' in data && data.log === true;
-        if (sab instanceof SharedArrayBuffer)
+        if (sab instanceof SharedArrayBuffer) {
             return { handle: data.handle, sab, log };
+        }
     }
     throw new Error('python worker started without { handle, sab } thread data');
 }
 async function openBarePort() {
     const { default: Channel } = await import('bare-channel');
     const self = Bare.Thread.self;
-    if (!self)
+    if (!self) {
         throw new Error('python worker entry loaded on the main thread');
+    }
     const { handle, sab, log } = narrowThreadData(self.data);
     const port = Channel.from(handle).connect();
     return {
@@ -40,23 +43,27 @@ async function openBarePort() {
 }
 async function openNodePort() {
     const { parentPort, workerData } = await import('worker_threads');
-    if (!parentPort)
+    if (!parentPort) {
         throw new Error('python worker entry loaded on the main thread');
-    const data = narrowThreadData({ handle: parentPort, ...(workerData ?? {}) });
+    }
+    const data = narrowThreadData({ handle: parentPort, ...workerData });
     const queued = [];
     const waiting = [];
     parentPort.on('message', (value) => {
         const next = waiting.shift();
-        if (next)
+        if (next) {
             next(value);
-        else
+        }
+        else {
             queued.push(value);
+        }
     });
     return {
         port: {
             read() {
-                if (queued.length > 0)
+                if (queued.length > 0) {
                     return Promise.resolve(queued.shift());
+                }
                 return new Promise((resolve) => waiting.push(resolve));
             },
             write: (message) => parentPort.postMessage(message),
@@ -67,13 +74,11 @@ async function openNodePort() {
 }
 async function loadInterpreter() {
     const testLoader = process.env.QVAC_PYODIDE_TEST_LOADER;
-    if (!testLoader)
+    if (!testLoader) {
         return defaultLoad;
+    }
     const loaded = await import(__rewriteRelativeImportExtension(testLoader));
-    if (typeof loaded === 'object' &&
-        loaded !== null &&
-        'default' in loaded &&
-        typeof loaded.default === 'function') {
+    if (isRecord(loaded) && 'default' in loaded && typeof loaded.default === 'function') {
         return loaded.default;
     }
     throw new Error(`QVAC_PYODIDE_TEST_LOADER module has no default export: ${testLoader}`);
@@ -88,29 +93,33 @@ try {
     port.write({ type: 'ready' });
     for (;;) {
         const message = asHostMessage(await port.read());
-        if (!message || message.type === 'close')
+        if (!message || message.type === 'close') {
             break;
-        if (message.type === 'connect-answer')
+        }
+        if (message.type === 'connect-answer') {
             continue;
+        }
         let closing = false;
         const askConnect = async (host) => {
             if (closing)
                 return false;
             port.write({ type: 'connect-ask', host });
             const answer = asHostMessage(await port.read());
-            if (answer?.type === 'connect-answer')
+            if (answer?.type === 'connect-answer') {
                 return answer.allowed;
+            }
             closing = true;
             return false;
         };
         const { result, evict } = await performRun(py, message.spec, { askConnect });
         port.write({ type: 'result', id: message.id, result: toWireResult(result), evict });
-        if (evict || closing)
+        if (evict || closing) {
             break;
+        }
     }
 }
 catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message = errorMessage(error);
     port.write({ type: 'boot-error', message });
 }
 finally {

package/dist-lib/lib/tools/exec/adapters/python/worker/protocol.d.ts

@@ -9,7 +9,7 @@ export type HostMessage = {
     readonly type: 'connect-answer';
     readonly allowed: boolean;
 };
-export type WireResult = {
+export interface WireResult {
     readonly stdout: string;
     readonly stderr: string;
     readonly exitCode: number;
@@ -20,7 +20,7 @@ export type WireResult = {
         readonly reason: string;
     }[];
     readonly undeclared?: readonly string[];
-};
+}
 export type WorkerMessage = {
     readonly type: 'log';
     readonly message: string;

package/dist-lib/lib/tools/exec/adapters/python/worker/protocol.js

@@ -21,25 +21,26 @@ export function fromWireResult(wire) {
     };
 }
 function messageType(value) {
-    if (typeof value !== 'object' || value === null)
+    if (typeof value !== 'object' || value === null || !('type' in value)) {
         return null;
-    const type = value.type;
-    return typeof type === 'string' ? type : null;
+    }
+    return typeof value.type === 'string' ? value.type : null;
 }
-export function asHostMessage(value) {
+function isHostMessage(value) {
     const type = messageType(value);
-    if (type === 'run' || type === 'close' || type === 'connect-answer')
-        return value;
-    return null;
+    return type === 'run' || type === 'close' || type === 'connect-answer';
 }
-export function asWorkerMessage(value) {
+function isWorkerMessage(value) {
     const type = messageType(value);
-    if (type === 'log' ||
+    return (type === 'log' ||
         type === 'ready' ||
         type === 'boot-error' ||
         type === 'result' ||
-        type === 'connect-ask') {
-        return value;
-    }
-    return null;
+        type === 'connect-ask');
+}
+export function asHostMessage(value) {
+    return isHostMessage(value) ? value : null;
+}
+export function asWorkerMessage(value) {
+    return isWorkerMessage(value) ? value : null;
 }

package/dist-lib/lib/tools/exec/adapters/python/worker/spawn-node.d.ts

@@ -1,14 +1,14 @@
-export type WorkerLink = {
+export interface WorkerLink {
     read(): Promise<unknown>;
     write(message: unknown): Promise<void>;
     kill(): void;
     reap(): void;
     ref(): void;
     unref(): void;
-};
-export type WorkerData = {
+}
+export interface WorkerData {
     readonly sab: SharedArrayBuffer;
     readonly log: boolean;
-};
+}
 export declare function spawnPythonWorker(entry: string, data: WorkerData): WorkerLink;
 export declare function spawnInlineThread(source: string, data: object): () => void;

package/dist-lib/lib/tools/exec/adapters/python/worker/spawn-node.js

@@ -9,17 +9,20 @@ export function spawnPythonWorker(entry, data) {
     let died = null;
     const push = (value) => {
         const next = waiting.shift();
-        if (next)
+        if (next) {
             next.resolve(value);
-        else
+        }
+        else {
             queued.push(value);
+        }
     };
     const fail = (error) => {
         if (died)
             return;
         died = error;
-        for (const pending of waiting.splice(0))
+        for (const pending of waiting.splice(0)) {
             pending.reject(error);
+        }
     };
     worker.on('message', push);
     worker.on('error', (error) => fail(error instanceof Error ? error : new Error(String(error))));
@@ -27,10 +30,12 @@ export function spawnPythonWorker(entry, data) {
     worker.unref();
     return {
         read() {
-            if (queued.length > 0)
+            if (queued.length > 0) {
                 return Promise.resolve(queued.shift());
-            if (died)
+            }
+            if (died) {
                 return Promise.reject(died);
+            }
             return new Promise((resolve, reject) => waiting.push({ resolve, reject }));
         },
         write(message) {

package/dist-lib/lib/tools/exec/adapters/shell/shell-adapter.d.ts

@@ -1,12 +1,12 @@
 import { type KillProcess, type SpawnFn } from '../../runner.ts';
 import type { FallbackExecutionAdapter } from '../adapter.ts';
-export type ShellRuntime = {
+export interface ShellRuntime {
     readonly spawn: SpawnFn;
     readonly killProcess?: KillProcess;
-};
-export type ShellAdapterOptions = {
+}
+export interface ShellAdapterOptions {
     readonly spawn?: SpawnFn;
     readonly killProcess?: KillProcess;
     readonly loadRuntime: () => Promise<ShellRuntime>;
-};
+}
 export declare function createShellAdapter(options: ShellAdapterOptions): FallbackExecutionAdapter;

package/dist-lib/lib/tools/exec/adapters/shell/shell-adapter.js

@@ -15,8 +15,9 @@ export function createShellAdapter(options) {
                         killProcess: runtime.killProcess
                     });
                     const note = result.exitCode === 0 ? shellDownloadNote(command) : null;
-                    if (!note)
+                    if (!note) {
                         return result;
+                    }
                     const stdout = `${result.stdout}${result.stdout && !result.stdout.endsWith('\n') ? '\n' : ''}${note}`;
                     return { ...result, stdout };
                 }

package/dist-lib/lib/tools/exec/obsidian/cli-process.d.ts

@@ -4,5 +4,10 @@ import type { KillProcess, SpawnFn } from '../runner.ts';
 export declare function runningCheckCommand(os: string): string;
 export declare function launchCommand(os: string): string;
 export declare function obsidianPathEnv(platform?: NodeJS.Platform, env?: Record<string, string | undefined>, probe?: ObsidianPathProbe): Record<string, string> | undefined;
-export declare function isObsidianRunning(spawn: SpawnFn, killProcess: KillProcess | undefined, signal?: BareAbortSignal, platform?: NodeJS.Platform): Promise<boolean>;
+export interface ObsidianRunningOptions {
+    readonly killProcess?: KillProcess | undefined;
+    readonly signal?: BareAbortSignal | undefined;
+    readonly platform?: NodeJS.Platform;
+}
+export declare function isObsidianRunning(spawn: SpawnFn, { killProcess, signal, platform }?: ObsidianRunningOptions): Promise<boolean>;
 export declare function launchObsidianApp(spawn: SpawnFn, platform?: NodeJS.Platform): void;

package/dist-lib/lib/tools/exec/obsidian/cli-process.js

@@ -21,14 +21,15 @@ export function obsidianPathEnv(platform = process.platform, env = process.env,
     const expand = probe.expand ?? ((candidate) => expandObsidianPath(candidate, env));
     const exists = probe.exists ?? ((candidate) => fs.existsSync(candidate));
     const bin = firstExistingPath(OBSIDIAN_BIN_CANDIDATES[platform] ?? [], expand, exists);
-    if (!bin)
+    if (!bin) {
         return undefined;
+    }
     const binDir = path.dirname(bin);
     const scrubbed = execEnv(env, platform);
     const prev = scrubbed.PATH ?? '';
     return { ...scrubbed, PATH: prev ? `${binDir}${path.delimiter}${prev}` : binDir };
 }
-export function isObsidianRunning(spawn, killProcess, signal, platform = process.platform) {
+export function isObsidianRunning(spawn, { killProcess, signal, platform = process.platform } = {}) {
     return new Promise((resolve) => {
         if (signal?.aborted) {
             resolve(false);
@@ -43,10 +44,12 @@ export function isObsidianRunning(spawn, killProcess, signal, platform = process
             globalThis.clearTimeout(timer);
             signal?.removeEventListener('abort', onAbort);
             try {
-                if (child.pid !== undefined && killProcess)
+                if (child.pid !== undefined && killProcess) {
                     killProcess(-child.pid, 'SIGKILL');
-                else
+                }
+                else {
                     child.kill('SIGKILL');
+                }
             }
             catch {
                 child.kill('SIGKILL');
@@ -65,7 +68,7 @@ export function launchObsidianApp(spawn, platform = process.platform) {
         const env = obsidianPathEnv(platform);
         const child = spawn(launchCommand(platform), {
             shell: true,
-            ...(env ? { env } : {})
+            env
         });
         child.on('error', () => { });
     }

package/dist-lib/lib/tools/exec/obsidian/cli.d.ts

@@ -1,18 +1,18 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import { type ExecResult, type KillProcess, type SpawnFn } from '../runner.ts';
-export type RunObsidianCliOptions = {
+export interface RunObsidianCliOptions {
     readonly timeoutMs?: number;
     readonly maxOutputChars?: number;
     readonly signal?: BareAbortSignal;
-};
-export type RunOutcome = {
+}
+export interface RunOutcome {
     readonly result: string;
     readonly stderr: string;
     readonly exitCode: number | null;
-};
-export type ObsidianCliRuntime = {
+}
+export interface ObsidianCliRuntime {
     readonly spawn: SpawnFn;
     readonly killProcess?: KillProcess;
-};
+}
 export declare function toResult(outcome: RunOutcome): ExecResult;
 export declare function runObsidianCli(command: string, runtime: ObsidianCliRuntime, options?: RunObsidianCliOptions): Promise<ExecResult>;

package/dist-lib/lib/tools/exec/obsidian/cli.js

@@ -67,7 +67,7 @@ export function toResult(outcome) {
         exitCode: 1
     };
 }
-function runOnce(command, runtime, timeoutMs, maxOutputChars, signal) {
+function runOnce(command, runtime, { timeoutMs, maxOutputChars, signal }) {
     return new Promise((resolve) => {
         if (signal?.aborted) {
             resolve({ result: '', stderr: '', exitCode: null });
@@ -77,7 +77,7 @@ function runOnce(command, runtime, timeoutMs, maxOutputChars, signal) {
         const child = runtime.spawn(command, {
             shell: true,
             stdio: ['ignore', 'pipe', 'pipe'],
-            ...(env ? { env } : {})
+            env
         });
         const stdout = createCapturedOutput();
         const stderr = createCapturedOutput();
@@ -130,7 +130,7 @@ export async function runObsidianCli(command, runtime, options = {}) {
     const signal = options.signal;
     const maxOutputChars = options.maxOutputChars ?? MAX_OUTPUT_CHARS;
     const timeoutMs = options.timeoutMs ?? COMMAND_MS;
-    if (!(await isObsidianRunning(runtime.spawn, runtime.killProcess, signal))) {
+    if (!(await isObsidianRunning(runtime.spawn, { killProcess: runtime.killProcess, signal }))) {
         if (signal?.aborted) {
             return { stdout: '', stderr: 'Obsidian command aborted.', exitCode: 1 };
         }
@@ -140,7 +140,7 @@ export async function runObsidianCli(command, runtime, options = {}) {
     if (signal?.aborted) {
         return { stdout: '', stderr: 'Obsidian command aborted.', exitCode: 1 };
     }
-    const outcome = await runOnce(command, runtime, timeoutMs, maxOutputChars, signal);
+    const outcome = await runOnce(command, runtime, { timeoutMs, maxOutputChars, signal });
     if (signal?.aborted) {
         return { stdout: '', stderr: 'Obsidian command aborted.', exitCode: 1 };
     }

package/dist-lib/lib/tools/exec/obsidian/command.d.ts

@@ -1,5 +1,6 @@
-export declare function parseObsidianCommand(command: string): {
+export interface ObsidianCommand {
     action: string;
     args: string[];
-} | null;
+}
+export declare function parseObsidianCommand(command: string): ObsidianCommand | null;
 export declare function normalizeObsidianCommand(command: string): string;

package/dist-lib/lib/tools/exec/obsidian/command.js

@@ -3,13 +3,16 @@ const OBSIDIAN_BIN = /^obsidian(?:\.exe|\.com)?$/i;
 const OBSIDIAN_PREFIX = /^obsidian(?:\.exe|\.com)?(?:\s|$)/i;
 export function parseObsidianCommand(command) {
     const trimmed = command.trim();
-    if (!OBSIDIAN_PREFIX.test(trimmed))
+    if (!OBSIDIAN_PREFIX.test(trimmed)) {
         return null;
+    }
     const tokens = shellArgv(trimmed);
-    if (tokens.length === 0 || !OBSIDIAN_BIN.test(tokens[0] ?? ''))
+    if (tokens.length === 0 || !OBSIDIAN_BIN.test(tokens[0] ?? '')) {
         return null;
-    if (tokens.length === 1)
+    }
+    if (tokens.length === 1) {
         return { action: '', args: [] };
+    }
     const [, action, ...args] = tokens;
     return { action: action ?? '', args };
 }

package/dist-lib/lib/tools/exec/obsidian/output.js

@@ -16,8 +16,9 @@ function isNoiseLine(line) {
             return true;
         if (rule.kind === 'equals' && line === rule.text)
             return true;
-        if (rule.kind === 'includes' && line.includes(rule.text))
+        if (rule.kind === 'includes' && line.includes(rule.text)) {
             return true;
+        }
     }
     return false;
 }

package/dist-lib/lib/tools/exec/obsidian/route.d.ts

@@ -2,18 +2,16 @@ import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { ToolExecuteContext } from '../../../capabilities/completion.ts';
 import { type CredentialStoreFn } from '../../skills/auth-resolver.ts';
 import { type ExecResult, type KillProcess, type SpawnFn } from '../runner.ts';
-export type ObsidianRouteOptions = {
+import type { ShellRuntime } from '../adapters/shell/shell-adapter.ts';
+export interface ObsidianRouteOptions {
     readonly credentialStore?: CredentialStoreFn;
     readonly spawn?: SpawnFn;
     readonly killProcess?: KillProcess;
-    readonly loadRuntime?: () => Promise<{
-        spawn: SpawnFn;
-        killProcess?: KillProcess;
-    }>;
+    readonly loadRuntime?: () => Promise<ShellRuntime>;
     readonly platform?: string;
     readonly env?: Record<string, string | undefined>;
     readonly timeoutMs?: number;
     readonly maxOutputChars?: number;
     readonly signal?: BareAbortSignal;
-};
+}
 export declare function routeObsidianCommand(command: string, ctx: ToolExecuteContext | undefined, options?: ObsidianRouteOptions): Promise<ExecResult | null>;

package/dist-lib/lib/tools/exec/obsidian/route.js

@@ -1,4 +1,5 @@
 import process from 'process';
+import { errorMessage } from '../../../guards.js';
 import { credentialRecord } from '../../skills/auth-resolver.js';
 import { isObsidianVaultPath, isSandboxedWorkbenchInstall, OBSIDIAN_VAULT_PATH_CREDENTIAL_KEY } from '../../skills/obsidian-readiness.js';
 import { capOutput, MAX_OUTPUT_CHARS } from '../runner.js';
@@ -7,6 +8,12 @@ import { normalizeObsidianCommand, parseObsidianCommand } from './command.js';
 import { OBSIDIAN_DESKTOP_AGENT_REQUIRED, OBSIDIAN_NO_SHELL_FALLBACK, OBSIDIAN_VAULT_SETUP_REQUIRED } from './guidance.js';
 import { executeVaultFsAction } from './vault-fs.js';
 const DESKTOP_PLATFORMS = new Set(['darwin', 'linux', 'win32']);
+async function runtimeOf(options) {
+    if (options.spawn) {
+        return { spawn: options.spawn, killProcess: options.killProcess };
+    }
+    return options.loadRuntime ? await options.loadRuntime() : null;
+}
 function limitResult(result, maxOutputChars) {
     return {
         stdout: capOutput(result.stdout, maxOutputChars),
@@ -19,12 +26,12 @@ function vaultFsResult(stdout, exitCode) {
         ? { stdout, stderr: '', exitCode: 0 }
         : { stdout: '', stderr: `${stdout}\n\n${OBSIDIAN_NO_SHELL_FALLBACK}`, exitCode };
 }
-function runVaultFs(vaultPath, action, args, maxOutputChars) {
+function runVaultFs(vaultPath, { action, args, maxOutputChars }) {
     try {
         return limitResult(vaultFsResult(executeVaultFsAction(vaultPath, action, args), 0), maxOutputChars);
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
+        const message = errorMessage(error);
         return limitResult(vaultFsResult(message, 1), maxOutputChars);
     }
 }
@@ -33,14 +40,16 @@ async function resolveVaultPath(credentialStore, ctx) {
         return null;
     const record = credentialRecord(await credentialStore(OBSIDIAN_VAULT_PATH_CREDENTIAL_KEY, ctx));
     const token = record?.token?.trim();
-    if (!token || !isObsidianVaultPath(token))
+    if (!token || !isObsidianVaultPath(token)) {
         return null;
+    }
     return token;
 }
 export async function routeObsidianCommand(command, ctx, options = {}) {
     const parsed = parseObsidianCommand(command);
-    if (!parsed)
+    if (!parsed) {
         return null;
+    }
     const maxOutputChars = options.maxOutputChars ?? MAX_OUTPUT_CHARS;
     const signal = options.signal ?? ctx?.signal;
     if (signal?.aborted) {
@@ -55,8 +64,9 @@ export async function routeObsidianCommand(command, ctx, options = {}) {
         };
     }
     const vaultPath = await resolveVaultPath(options.credentialStore, ctx);
-    if (vaultPath)
-        return runVaultFs(vaultPath, parsed.action, parsed.args, maxOutputChars);
+    if (vaultPath) {
+        return runVaultFs(vaultPath, { action: parsed.action, args: parsed.args, maxOutputChars });
+    }
     if (isSandboxedWorkbenchInstall(options.env ?? process.env)) {
         return {
             stdout: '',
@@ -64,11 +74,7 @@ export async function routeObsidianCommand(command, ctx, options = {}) {
             exitCode: 1
         };
     }
-    const runtime = options.spawn
-        ? { spawn: options.spawn, killProcess: options.killProcess }
-        : options.loadRuntime
-            ? await options.loadRuntime()
-            : null;
+    const runtime = await runtimeOf(options);
     if (!runtime) {
         return {
             stdout: '',

package/dist-lib/lib/tools/exec/obsidian/safe-path.js

@@ -14,8 +14,9 @@ function rejectSymlinkComponents(root, target) {
     for (const segment of segments) {
         current = path.join(current, segment);
         const stat = lstatOrNull(current);
-        if (!stat)
+        if (!stat) {
             return;
+        }
         if (stat.isSymbolicLink()) {
             throw new Error(`Path "${target}" crosses a symlink inside the vault.`);
         }

package/dist-lib/lib/tools/exec/obsidian/vault-create.js

@@ -12,10 +12,11 @@ function createAtPath(vaultPath, target, content) {
     writeNewFileText(filePath, content);
     return `Created: ${path.relative(vaultPath, filePath)}`;
 }
-function createNamed(vaultPath, name, folder, content) {
+function createNamed(vaultPath, { name, folder, content }) {
     const dir = folder ? ensureWithinRoot(vaultPath, folder) : path.resolve(vaultPath);
-    if (!fs.existsSync(dir))
+    if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
+    }
     const fileName = markdownFileName(name);
     const filePath = ensureWithinRoot(vaultPath, path.join(folder, fileName));
     if (fs.existsSync(filePath)) {
@@ -27,14 +28,21 @@ function createNamed(vaultPath, name, folder, content) {
 export function handleCreate(vaultPath, args) {
     const content = getContentArg(args);
     const name = getArg(args, 'name');
-    if (name)
-        return createNamed(vaultPath, name, getArg(args, 'path') || '', content || '');
+    if (name) {
+        return createNamed(vaultPath, {
+            name,
+            folder: getArg(args, 'path') || '',
+            content: content || ''
+        });
+    }
     const filePath = getArg(args, 'path');
     const file = getArg(args, 'file');
-    if (filePath && file)
-        return createNamed(vaultPath, file, filePath, content || '');
+    if (filePath && file) {
+        return createNamed(vaultPath, { name: file, folder: filePath, content: content || '' });
+    }
     const target = filePath ?? file;
-    if (!target)
+    if (!target) {
         throw new Error('Missing required argument: name=, file=, or path=');
+    }
     return createAtPath(vaultPath, target, content || '');
 }

package/dist-lib/lib/tools/exec/obsidian/vault-paths.d.ts

@@ -2,10 +2,10 @@ export { ensureWithinRoot, writeNewFileText } from './safe-path.ts';
 export declare const FRONTMATTER_RE: RegExp;
 export declare function resolveNotePath(vaultPath: string, args: string[]): string | null;
 export declare function readFileText(filePath: string): string;
-export type FileSnapshot = {
+export interface FileSnapshot {
     readonly text: string;
     readonly mtimeMs: number;
-};
+}
 export declare function readFileSnapshot(filePath: string): FileSnapshot | null;
 export declare function writeIfUnchanged(filePath: string, content: string, expectedMtimeMs: number | null): void;
 export declare function updateFileText(filePath: string, transform: (existing: string) => string): void;