cloving 1.2.0 → 1.3.0

package/dist/tools/self-host.js

@@ -1,77 +1,74 @@
+import { turnHarness, harnessDefaults, nativeHarness, } from "../src/harness-defaults.js";
+import { absoluteWorkflowFolder } from "../src/project-settings.js";
+import { projectConfiguration, projectRoot, topLevel, } from "./project-configuration.js";
 import { isProfilesFile } from "../src/turn-profile.js";
+import { parseCommands, parseCommandSeconds, } from "../src/command-settings.js";
 import { parseFallbackModels, parseTokenPrices, } from "../src/token-prices.js";
-import { execFileSync } from "node:child_process";
-import { readFile, realpath, writeFile } from "node:fs/promises";
+import { readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, extname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { preparedProject, } from "./self-host-project.js";
 import { selfUpdateMilliseconds } from "./self-update-host.js";
 import { hostedPrograms } from "./self-host-processes.js";
+import { workflowBundleLoader } from "./self-host-workflows.js";
+import { adoptRuntimeDirectory } from "./self-host-runtime.js";
+import { parseSchedulesSetting } from "../src/workflow-schedule.js";
 const product = resolve(import.meta.dirname, "..");
 const flags = process.argv.slice(2);
 function flag(name) {
-    const index = flags.lastIndexOf(name);
-    return index === -1 ? undefined : flags[index + 1];
-}
-function topLevel(given) {
-    try {
-        return execFileSync("git", ["-C", given, "rev-parse", "--show-toplevel"], {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-        }).trim();
-    }
-    catch {
-        return given;
-    }
+    const index = flags.findLastIndex((argument) => argument === name || argument.startsWith(`${name}=`));
+    const argument = flags[index];
+    return argument === name
+        ? flags[index + 1]
+        : argument?.slice(name.length + 1);
 }
 const runtimeArgument = flag("--runtime");
 if (runtimeArgument === undefined)
     throw new Error("The start program needs --runtime. Use: cloving start");
-const runtime = resolve(runtimeArgument);
+const repository = await projectRoot(flag("--repository") ?? process.cwd());
+const configuration = await projectConfiguration(repository, process.env);
+const environment = configuration.environment;
+const selectedRuntime = await adoptRuntimeDirectory({
+    runtime: resolve(runtimeArgument),
+    repository,
+    legacyRuntime: flag("--legacy-runtime"),
+    adoptionRecord: flag("--adoption-record"),
+});
+const runtime = selectedRuntime.runtime;
 const directory = dirname(runtime);
-const repository = await realpath(topLevel(resolve(flag("--repository") ?? process.cwd())));
 const updateMilliseconds = await selfUpdateMilliseconds({
-    seconds: process.env["CLOVING_SELF_UPDATE_SECONDS"],
+    seconds: environment["CLOVING_SELF_UPDATE_SECONDS"],
     repository,
     product: extname(import.meta.filename) === ".ts" ? topLevel(product) : product,
 });
 const client = flag("--client") ?? "cloving";
 const project = join(directory, "project");
-const concurrency = Number(process.env["CLOVING_HOST_BOUND"] ?? "8");
-const leaseText = process.env["CLOVING_OWNERSHIP_LEASE_SECONDS"];
+const concurrency = Number(environment["CLOVING_HOST_BOUND"] ?? "8");
+const leaseText = environment["CLOVING_OWNERSHIP_LEASE_SECONDS"];
 const leaseSeconds = leaseText === undefined ? undefined : Number(leaseText);
-const defaultCommand = [
-    "claude",
-    "-p",
-    "--output-format",
-    "stream-json",
-    "--verbose",
-    "--permission-mode",
-    "acceptEdits",
-    "--allowedTools",
-    "Bash,Read,Edit,Write,Glob,Grep,WebSearch,WebFetch",
-    "--max-budget-usd",
-    "5",
-];
-const defaultCodexCommand = [
-    "codex",
-    "exec",
-    "--json",
-    "--dangerously-bypass-approvals-and-sandbox",
-    "--skip-git-repo-check",
-    "-",
-];
 function selectedWorker() {
-    const worker = process.env["CLOVING_WORKER"] ?? "claude";
-    if (worker === "claude" || worker === "codex")
-        return worker;
-    throw new Error(`The daemon did not start: invalid-worker: ${worker}`);
+    return checkedWorker(environment["CLOVING_WORKER"] ?? "claude");
+}
+function checkedWorker(name) {
+    try {
+        return turnHarness({
+            worker: name,
+            ...(configuration.harness === undefined
+                ? {}
+                : { harness: configuration.harness }),
+        }).worker;
+    }
+    catch (error) {
+        throw new Error(`The daemon did not start: harness-no-worker: ${name}`, {
+            cause: error,
+        });
+    }
 }
 async function profilesFile() {
-    const path = process.env["CLOVING_PROFILES"];
+    const path = environment["CLOVING_PROFILES"];
     if (path === undefined)
-        return {};
+        return configuration.profiles;
     try {
         const value = JSON.parse(await readFile(path, "utf8"));
         if (isProfilesFile(value))
@@ -83,17 +80,17 @@ async function profilesFile() {
     throw new Error("The daemon did not start: invalid-profiles");
 }
 function queueLanes() {
-    const value = process.env["CLOVING_QUEUE_LANES"];
+    const value = environment["CLOVING_QUEUE_LANES"];
     if (value === undefined)
         return 1;
     if (!/^[1-4]$/.test(value))
         throw new Error("The daemon did not start: invalid-queue-lanes");
-    if (process.env["CLOVING_QUEUE_SECONDS"] === undefined)
+    if (environment["CLOVING_QUEUE_SECONDS"] === undefined)
         throw new Error("The daemon did not start: queue-lanes-needs-queue");
     return Number(value);
 }
 function queueInterval(commands) {
-    const value = process.env["CLOVING_QUEUE_SECONDS"];
+    const value = environment["CLOVING_QUEUE_SECONDS"];
     if (value === undefined)
         return undefined;
     const seconds = Number(value);
@@ -109,7 +106,7 @@ function queueInterval(commands) {
     return seconds * 1000;
 }
 function listed(name) {
-    const given = process.env[name];
+    const given = environment[name];
     if (given === undefined)
         return undefined;
     const list = JSON.parse(given);
@@ -135,22 +132,27 @@ await import("./main.mjs");
     await writeFile(join(project, "main.mjs"), `import * as workflows from "./artifacts/client.mjs";
 import { POST } from "./artifacts/flow.mjs";
 import { startDaemon } from ${source("src/daemon/daemon.ts")};
-const opening = await startDaemon({ ...JSON.parse(${JSON.stringify(JSON.stringify(settings))}), workflows, handler: POST });
+${workflowBundleLoader()}
+const opening = await startDaemon({ ...JSON.parse(${JSON.stringify(JSON.stringify(settings))}), workflows, handler: POST, loadBundle: loadWorkflowBundle });
 if (opening.kind !== "started") {
   process.stderr.write("The daemon did not start: " + opening.reason + ": " + opening.detail + "\\n");
   process.exit(1);
 }
-process.stdout.write(${JSON.stringify(guide())});
+process.stdout.write(${JSON.stringify(guide(workflows))});
 const stop = async () => { await opening.daemon.close(); process.exit(0); };
 process.once("SIGINT", stop);
 process.once("SIGTERM", stop);
 `);
 }
-function guide() {
+function guide(workflows) {
     return [
         "Cloving runs. Stop it with Control-C.",
         `Repository: ${repository}`,
+        `Runtime directory: ${runtime}`,
         `Work trees: ${join(directory, "worktrees")}`,
+        ...(selectedRuntime.note === "" ? [] : [selectedRuntime.note]),
+        ...Object.entries(configuration.sources).map(([field, source]) => `${field}: ${source}`),
+        ...workflows.workflowRefusals.map((refusal) => `Refused workflow ${refusal.scope} ${refusal.label}: ${refusal.codes.join(", ")}`),
         "Commands for a second terminal:",
         `  ${client} run develop-ticket --ticket <ticket-id>`,
         `  ${client} run develop-issue --ticket <ticket-id>`,
@@ -162,13 +164,27 @@ function guide() {
         "",
     ].join("\n");
 }
-const tokenPrices = parseTokenPrices(process.env["CLOVING_TOKEN_PRICES"]);
-const fallbackModels = parseFallbackModels(process.env["CLOVING_FALLBACK_MODELS"]);
+const tokenPrices = parseTokenPrices(environment["CLOVING_TOKEN_PRICES"]);
+const commands = parseCommands(environment["CLOVING_COMMANDS"]);
+const commandSeconds = parseCommandSeconds(environment["CLOVING_COMMAND_SECONDS"]);
+const fallbackModels = parseFallbackModels(environment["CLOVING_FALLBACK_MODELS"]);
 const profiles = await profilesFile();
+const schedules = parseSchedulesSetting(environment["CLOVING_SCHEDULES"]);
 const worker = selectedWorker();
-const command = worker === "codex"
-    ? (listed("CLOVING_CODEX_COMMAND") ?? defaultCodexCommand)
-    : (listed("CLOVING_CLAUDE_COMMAND") ?? defaultCommand);
+function nativeCommands() {
+    const names = new Set([
+        worker,
+        ...Object.values(profiles).map((profile) => checkedWorker(profile.harness ?? worker)),
+    ]);
+    return Object.fromEntries([...names].filter(nativeHarness).flatMap((name) => {
+        const variable = harnessDefaults(name).variable;
+        const command = variable === undefined ? undefined : listed(variable);
+        return command === undefined ? [] : [[name, command]];
+    }));
+}
+const workerCommands = nativeCommands();
+const harness = configuration.harness ?? {};
+const command = turnHarness({ worker, workerCommands, harness }).command;
 const nextCommand = listed("CLOVING_NEXT_COMMAND");
 const ticketCommand = listed("CLOVING_TICKET_COMMAND");
 const lanes = queueLanes();
@@ -178,12 +194,19 @@ const manifests = await preparedProject({
     project,
     repository,
     home: homedir(),
-    xdgConfigHome: process.env["XDG_CONFIG_HOME"],
+    xdgConfigHome: environment["XDG_CONFIG_HOME"],
+    userFolder: absoluteWorkflowFolder(environment["CLOVING_WORKFLOW_FOLDER"]),
 });
 await launchers({
+    commands,
+    commandSeconds,
+    schedules,
     tokenPrices,
     fallbackModels,
     worker,
+    workerCommands,
+    harness,
+    shell: environment["SHELL"] ?? "/bin/sh",
     profiles,
     command,
     ticketCommand,
@@ -193,6 +216,7 @@ await launchers({
     resetQueue: flags.includes("--reset-queue"),
     notifyCommand: listed("CLOVING_NOTIFY_COMMAND"),
     githubCommand: listed("CLOVING_GH_COMMAND"),
+    requiredChecks: listed("CLOVING_REQUIRED_CHECKS") ?? null,
     checkCommand: listed("CLOVING_CHECK_COMMAND"),
     privateTexts: listed("CLOVING_PRIVATE_TEXTS"),
 }, manifests);
@@ -203,5 +227,6 @@ process.exitCode = await hostedPrograms({
     directory,
     repository,
     updateMilliseconds,
-    watchPort: process.env["CLOVING_WATCH_PORT"] ?? "3663",
+    watchPort: environment["CLOVING_WATCH_PORT"] ?? "3663",
+    phoneRelay: environment["CLOVING_PHONE_RELAY"] ?? "on",
 });

package/dist/tools/workflow-candidate-counts.d.ts

@@ -1,8 +1,12 @@
 import ts from "typescript";
 import { type CandidateSymbols } from "./workflow-candidate-syntax.ts";
-interface Totals {
+export interface Totals {
     readonly knownCallCount: number;
     readonly knownUnitTotal: number;
 }
-export declare function candidateEffectTotals(source: ts.SourceFile, symbols: CandidateSymbols): Totals;
+interface CountSymbols extends CandidateSymbols {
+    readonly localTotals?: (node: ts.Node) => Totals | undefined;
+}
+export declare function candidateEffectTotals(source: ts.Node, symbols: CountSymbols): Totals;
+export declare function candidateLoopRepetitions(node: ts.IterationStatement, symbols: CandidateSymbols): number | undefined;
 export {};

package/dist/tools/workflow-candidate-counts.js

@@ -1,5 +1,6 @@
 import ts from "typescript";
-import { protectedCall, handoffCall, propertyName, } from "./workflow-candidate-syntax.js";
+import { protectedCall, helperCall, } from "./workflow-candidate-syntax.js";
+import { propertyName } from "./workflow-candidate-fields.js";
 import { referenceSymbol } from "./workflow-source-effects.js";
 const zero = { knownCallCount: 0, knownUnitTotal: 0 };
 function add(first, second) {
@@ -21,7 +22,7 @@ function multiply(total, repetitions) {
     };
 }
 function units(node, symbols) {
-    if (handoffCall(node, symbols))
+    if (helperCall(node, symbols))
         return 1;
     const argument = node.arguments[0];
     if (!argument || !ts.isObjectLiteralExpression(argument))
@@ -29,10 +30,8 @@ function units(node, symbols) {
     const property = argument.properties.find((entry) => entry.name && propertyName(entry.name) === "units");
     if (!property || !ts.isPropertyAssignment(property))
         return 0;
-    const value = constantNumber(property.initializer);
-    return value !== undefined && Number.isSafeInteger(value) && value > 0
-        ? value
-        : 0;
+    const value = Number(constantNumber(property.initializer));
+    return Number.isSafeInteger(value) && value > 0 ? value : 0;
 }
 function loopIncrement(node, variable) {
     if ((ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node)) &&
@@ -210,19 +209,35 @@ export function candidateEffectTotals(source, symbols) {
             return add(count(node.expression), multiply(add(count(node.initializer), count(node.statement)), arrayIterations(node, symbols)));
         if (ts.isSwitchStatement(node))
             return add(count(node.expression), switchTotals(node.caseBlock, count));
-        let total = protectedCall(node, symbols)
-            ? {
-                knownCallCount: 1,
-                knownUnitTotal: units(node, symbols),
-            }
-            : zero;
-        ts.forEachChild(node, (child) => {
-            total = add(total, count(child));
-        });
-        return total;
+        return nodeTotals(node, { symbols, count });
     }
     return count(source);
 }
+function nodeTotals(node, input) {
+    const local = input.symbols.localTotals?.(node);
+    if (local && ts.isFunctionLike(node))
+        return local;
+    let total = local ??
+        (protectedCall(node, input.symbols)
+            ? { knownCallCount: 1, knownUnitTotal: units(node, input.symbols) }
+            : zero);
+    ts.forEachChild(node, (child) => {
+        total = add(total, input.count(child));
+    });
+    return total;
+}
+export function candidateLoopRepetitions(node, symbols) {
+    if (ts.isForStatement(node))
+        return loopIterations(node, symbols);
+    if (ts.isForOfStatement(node) &&
+        ts.isArrayLiteralExpression(node.expression) &&
+        !uncertainLoopBody(node.statement, {
+            checker: symbols.checker,
+            counter: undefined,
+        }))
+        return node.expression.elements.length;
+    return undefined;
+}
 function arrayIterations(node, symbols) {
     if (!ts.isArrayLiteralExpression(node.expression))
         return 1;

package/dist/tools/workflow-candidate-fields.d.ts

@@ -0,0 +1,5 @@
+import ts from "typescript";
+export declare function propertyName(name: ts.PropertyName): string | undefined;
+export declare function propertyInitializer(node: ts.Node | undefined, field: string): ts.Expression | undefined;
+export declare function literalField(node: ts.Node | undefined, field: string): string | null;
+export declare function invalidFields(object: ts.ObjectLiteralExpression): boolean;

package/dist/tools/workflow-candidate-fields.js

@@ -0,0 +1,24 @@
+import ts from "typescript";
+export function propertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name))
+        return name.text;
+    return undefined;
+}
+export function propertyInitializer(node, field) {
+    if (!node || !ts.isObjectLiteralExpression(node))
+        return undefined;
+    const property = node.properties.find((entry) => entry.name && propertyName(entry.name) === field);
+    return property && ts.isPropertyAssignment(property)
+        ? property.initializer
+        : undefined;
+}
+export function literalField(node, field) {
+    const value = propertyInitializer(node, field);
+    return value && ts.isStringLiteral(value) ? value.text : null;
+}
+export function invalidFields(object) {
+    const names = object.properties.map((entry) => entry.name && propertyName(entry.name));
+    return (names.includes(undefined) ||
+        new Set(names).size !== names.length ||
+        object.properties.some((entry) => !ts.isPropertyAssignment(entry)));
+}

package/dist/tools/workflow-candidate-helper-counts.d.ts

@@ -0,0 +1,10 @@
+import ts from "typescript";
+import { type Totals } from "./workflow-candidate-counts.ts";
+import { type CandidateSymbols } from "./workflow-candidate-syntax.ts";
+export declare function helperEffectTotals(input: {
+    readonly symbols: CandidateSymbols;
+    readonly sources: readonly ts.SourceFile[];
+}): {
+    readonly totals?: Totals;
+    readonly unsupportedForms: readonly string[];
+};

package/dist/tools/workflow-candidate-helper-counts.js

@@ -0,0 +1,129 @@
+import ts from "typescript";
+import { candidateEffectTotals, candidateLoopRepetitions, } from "./workflow-candidate-counts.js";
+import { protectedCall, } from "./workflow-candidate-syntax.js";
+import { resolvedSymbol } from "./workflow-candidate-program.js";
+import { referenceSymbol, typeOnlyEffectNode, } from "./workflow-source-effects.js";
+const zero = { knownCallCount: 0, knownUnitTotal: 0 };
+export function helperEffectTotals(input) {
+    const { symbols, sources } = input;
+    const unsupportedForms = [];
+    if (sources.length === 1)
+        return { unsupportedForms };
+    const active = new Set();
+    const totals = new Map();
+    const functions = localFunctions(sources);
+    const functionAt = (node) => localFunctionAt(node, { checker: symbols.checker, functions });
+    function count(declaration) {
+        const cached = totals.get(declaration);
+        if (cached)
+            return cached;
+        if (active.has(declaration)) {
+            unsupportedForms.push("recursive-helper-effects");
+            return zero;
+        }
+        active.add(declaration);
+        const result = candidateEffectTotals(declaration, {
+            ...symbols,
+            localTotals: (node) => {
+                if (ts.isFunctionLike(node) && node !== declaration)
+                    return zero;
+                if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression))
+                    return undefined;
+                const called = functionAt(node.expression);
+                return called && effectful.has(called) ? count(called) : undefined;
+            },
+        });
+        active.delete(declaration);
+        totals.set(declaration, result);
+        return result;
+    }
+    const effectful = effectfulFunctions({ functions, functionAt, symbols });
+    if ([...effectful].every((entry) => entry.getSourceFile() === symbols.source))
+        return { unsupportedForms };
+    for (const source of sources)
+        inspectHelperReferences(source, {
+            functionAt,
+            effectful,
+            symbols,
+            unsupportedForms,
+        });
+    for (const declaration of effectful)
+        count(declaration);
+    const workflow = [...functions].find((entry) => entry.getSourceFile() === symbols.source &&
+        (ts.getCombinedModifierFlags(entry) & ts.ModifierFlags.Export) !== 0);
+    return { totals: workflow ? count(workflow) : zero, unsupportedForms };
+}
+function localFunctions(sources) {
+    return new Set(sources.flatMap((source) => source.statements.filter((node) => ts.isFunctionDeclaration(node) && node.body !== undefined)));
+}
+function localFunctionAt(node, input) {
+    const symbol = resolvedSymbol(input.checker, referenceSymbol(node, {
+        parent: node.parent,
+        checker: input.checker,
+    }));
+    return symbol?.declarations?.find((entry) => ts.isFunctionDeclaration(entry) && input.functions.has(entry));
+}
+function effectfulFunctions(input) {
+    const effectful = new Set();
+    const calls = (node) => {
+        if (typeOnlyEffectNode(node))
+            return false;
+        if (protectedCall(node, input.symbols))
+            return true;
+        const called = ts.isIdentifier(node) ? input.functionAt(node) : undefined;
+        if (called && effectful.has(called))
+            return true;
+        return ts.forEachChild(node, (child) => calls(child) || undefined) ?? false;
+    };
+    let previous = -1;
+    while (previous !== effectful.size) {
+        previous = effectful.size;
+        for (const declaration of input.functions)
+            if (calls(declaration))
+                effectful.add(declaration);
+    }
+    return effectful;
+}
+function inspectHelperReferences(source, input) {
+    function visit(node) {
+        if (typeOnlyEffectNode(node))
+            return;
+        if (source !== input.symbols.source &&
+            protectedCall(node, input.symbols) &&
+            !checkedHelperContext(node, input.symbols))
+            input.unsupportedForms.push("uncheckable-helper-effects");
+        const declaration = ts.isIdentifier(node)
+            ? input.functionAt(node)
+            : undefined;
+        if (declaration &&
+            input.effectful.has(declaration) &&
+            ts.isIdentifier(node) &&
+            !checkedHelperReference(node, input.symbols))
+            input.unsupportedForms.push("uncheckable-helper-effects");
+        ts.forEachChild(node, visit);
+    }
+    visit(source);
+}
+function checkedHelperReference(node, symbols) {
+    if (ts.isFunctionDeclaration(node.parent) && node.parent.name === node)
+        return true;
+    if (ts.isImportSpecifier(node.parent))
+        return true;
+    if (!ts.isCallExpression(node.parent) ||
+        node.parent.expression !== node ||
+        node.parent.questionDotToken !== undefined)
+        return false;
+    return checkedHelperContext(node.parent, symbols);
+}
+function checkedHelperContext(node, symbols) {
+    let parent = node;
+    while (!ts.isFunctionLike(parent)) {
+        if (ts.isSourceFile(parent))
+            return false;
+        if (ts.isIterationStatement(parent, false) &&
+            candidateLoopRepetitions(parent, symbols) === undefined)
+            return false;
+        parent = parent.parent;
+    }
+    return ts.isFunctionDeclaration(parent) && ts.isSourceFile(parent.parent);
+}

package/dist/tools/workflow-candidate-program.d.ts

@@ -2,10 +2,12 @@ import ts from "typescript";
 export declare const candidatePackageRoot: string;
 export interface CandidatePackageOptions {
     readonly packageRoot?: string;
+    readonly helpers?: Readonly<Record<string, string>>;
 }
 export declare function resolvedSymbol(checker: ts.TypeChecker, symbol: ts.Symbol | undefined): ts.Symbol | undefined;
 export declare function candidateProgram(text: string, installed?: CandidatePackageOptions): {
     readonly program: ts.Program;
     readonly source: ts.SourceFile;
+    readonly sources: readonly ts.SourceFile[];
     readonly modules: ReadonlyMap<string, ts.SourceFile>;
 };

package/dist/tools/workflow-candidate-program.js

@@ -2,6 +2,7 @@ import { dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import ts from "typescript";
 import metadata from "#package" with { type: "json" };
+import { workflowHelperPath } from "../src/workflow-candidate.js";
 export const candidatePackageRoot = dirname(fileURLToPath(import.meta.resolve("#package")));
 export function resolvedSymbol(checker, symbol) {
     if (!symbol || (symbol.flags & ts.SymbolFlags.Alias) === 0)
@@ -11,6 +12,12 @@ export function resolvedSymbol(checker, symbol) {
 export function candidateProgram(text, installed = {}) {
     const packageRoot = resolve(installed.packageRoot ?? candidatePackageRoot);
     const candidate = join(packageRoot, "candidate.ts");
+    const sources = new Map([[candidate, text]]);
+    for (const [name, content] of Object.entries(installed.helpers ?? {})) {
+        if (workflowHelperPath("candidate.ts", `./${name}`) !== name)
+            throw new Error("invalid-workflow-helper");
+        sources.set(join(packageRoot, name), content);
+    }
     const entries = new Map(Object.entries(metadata.exports).map(([name, entry]) => [
         `cloving${name.slice(1)}`,
         resolve(packageRoot, entry.types),
@@ -24,8 +31,8 @@ export function candidateProgram(text, installed = {}) {
         strict: true,
         noEmit: true,
     };
-    const host = trustedHost({ candidate, text, options, entries, packageRoot });
-    const program = ts.createProgram([candidate, ...entries.values()], options, host);
+    const host = trustedHost({ sources, options, entries, packageRoot });
+    const program = ts.createProgram([...sources.keys(), ...entries.values()], options, host);
     const source = program.getSourceFile(candidate);
     if (!source)
         throw new Error("candidate-analysis-unavailable");
@@ -36,15 +43,25 @@ export function candidateProgram(text, installed = {}) {
             throw new Error("candidate-surface-unavailable");
         modules.set(name, declaration);
     }
-    return { program, source, modules };
+    return {
+        program,
+        source,
+        modules,
+        sources: [...sources.keys()].map((name) => {
+            const entry = program.getSourceFile(name);
+            if (!entry)
+                throw new Error("candidate-analysis-unavailable");
+            return entry;
+        }),
+    };
 }
 function trustedHost(input) {
-    const { candidate, text, options, entries, packageRoot } = input;
+    const { sources, options, entries, packageRoot } = input;
     const libraries = dirname(ts.getDefaultLibFilePath(options)) + sep;
     const declarations = join(packageRoot, "dist/src") + sep;
     const readFile = (file) => {
-        if (file === candidate)
-            return text;
+        if (sources.has(file))
+            return sources.get(file);
         const absolute = resolve(file);
         if (!absolute.endsWith(".d.ts"))
             return undefined;
@@ -70,8 +87,19 @@ function trustedHost(input) {
                     extension: ts.Extension.Dts,
                 },
             };
-        if (containingFile === candidate)
-            return { resolvedModule: undefined };
+        if (sources.has(containingFile)) {
+            const importer = containingFile
+                .slice(packageRoot.length + 1)
+                .split(sep)
+                .join("/");
+            const local = workflowHelperPath(importer, name);
+            const target = local && join(packageRoot, local);
+            return {
+                resolvedModule: target && sources.has(target)
+                    ? { resolvedFileName: target, extension: ts.Extension.Ts }
+                    : undefined,
+            };
+        }
         return ts.resolveModuleName(name, containingFile, options, host);
     });
     return host;