cloving 1.3.0 → 1.5.0

package/dist/tools/template-command.js

@@ -0,0 +1,160 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { parseArgs } from "node:util";
+import { absoluteWorkflowFolder } from "../src/project-settings.js";
+import { record } from "../src/protocol.js";
+import { isCandidateDeclaration } from "../src/workflow-candidate.js";
+import { projectConfiguration, projectRoot } from "./project-configuration.js";
+import { copyTemplate } from "./template-copy.js";
+import { exportedFunctions, readTemplate, templateList, templateRoot, } from "./template-files.js";
+import { userLocation } from "./workflow-folders.js";
+const usage = "Usage: cloving templates list [--json]\n       cloving templates show <name> [--json]\n       cloving templates copy <name> [--id <workflow-id>] [--json] [--repository <directory>]\n";
+function invocation(argumentsList) {
+    const { values, positionals } = parseArgs({
+        args: [...argumentsList],
+        allowPositionals: true,
+        options: {
+            json: { type: "boolean" },
+            id: { type: "string" },
+            repository: { type: "string" },
+            help: { type: "boolean", short: "h" },
+        },
+    });
+    const [command, name, ...extra] = positionals;
+    if (values.help === true)
+        return { ...values, command: "help", name: "" };
+    if (!["list", "show", "copy"].includes(command ?? ""))
+        throw new Error("unknown-command");
+    if (extra.length > 0 || (command === "list") !== (name === undefined))
+        throw new Error("unexpected-argument");
+    if (command !== "copy" && (values.id !== undefined || values.repository))
+        throw new Error("unexpected-option");
+    return { ...values, command, name: name ?? "" };
+}
+export async function templateCommand(argumentsList) {
+    let selected;
+    try {
+        selected = invocation(argumentsList);
+    }
+    catch {
+        process.stderr.write("invalid-invocation: " + usage);
+        return 2;
+    }
+    if (selected.help) {
+        process.stdout.write(usage);
+        return 0;
+    }
+    try {
+        const root = templateRoot();
+        const json = selected.json === true;
+        if (selected.command === "list")
+            return await listed(root, { json });
+        if (selected.command === "show")
+            return await shown(root, { name: selected.name, json });
+        return await copied(root, {
+            name: selected.name,
+            id: selected.id ?? selected.name,
+            json,
+            repository: selected.repository ?? process.cwd(),
+        });
+    }
+    catch (error) {
+        process.stderr.write((error instanceof Error ? error.message : "template-command-failed") +
+            "\n");
+        return 1;
+    }
+}
+async function listed(root, input) {
+    const templates = await templateList(root);
+    if (input.json)
+        process.stdout.write(JSON.stringify(templates) + "\n");
+    else
+        for (const template of templates)
+            process.stdout.write(`${template.name}: ${template.summary} (${String(template.points)} decision points)\n`);
+    return 0;
+}
+async function shown(root, input) {
+    const template = await readTemplate(root, input.name);
+    if (input.json) {
+        process.stdout.write(JSON.stringify({
+            template: template.description,
+            files: template.files,
+        }) + "\n");
+        return 0;
+    }
+    process.stdout.write(`${template.name}: ${String(template.description["summary"])}\n${pointText(template.points)}Files:\n${template.files.map((file) => `  ${file}\n`).join("")}`);
+    return 0;
+}
+async function copied(root, input) {
+    const repository = await projectRoot(input.repository);
+    const folder = join(repository, ".cloving", "workflows");
+    const folders = [folder, await userFolder(repository)];
+    const packageRoot = dirname(root);
+    const takenNames = await exportedFunctions([
+        join(packageRoot, "workflows"),
+        join(packageRoot, "dist", "workflows"),
+        ...folders,
+    ]);
+    const result = await copyTemplate({ ...input, root, folder, takenNames });
+    const queued = (await Promise.all(folders.map(queuedIn))).flat().sort();
+    if (input.json)
+        process.stdout.write(JSON.stringify({
+            workflowId: input.id,
+            template: input.name,
+            files: result.files,
+            queueWorkflows: queued,
+        }) + "\n");
+    else
+        process.stdout.write(`Copied the template ${input.name} to .cloving/workflows as the workflow ${input.id}.\nDecision points:\n${pointText(result.template.points)}Next: cloving workflows test ${input.id}\n`);
+    if (queued.length > 1)
+        process.stderr.write(`queue-workflow-conflict: ${queued.join(", ")} have "queue": true. Select "a person" for the select point of one copy: remove workflow.queue from its declaration.\n`);
+    return 0;
+}
+function pointText(points) {
+    return points
+        .map((value) => {
+        const point = record(value);
+        const options = point?.["options"];
+        const lines = (Array.isArray(options) ? options : []).map((option, index) => {
+            const fields = record(option);
+            return `    - ${String(fields?.["id"])}: ${String(fields?.["label"])}${index === 0 ? " (default)" : ""}\n`;
+        });
+        return `  ${String(point?.["id"])}: ${String(point?.["question"])}\n${lines.join("")}`;
+    })
+        .join("");
+}
+async function userFolder(repository) {
+    const settings = await projectConfiguration(repository, process.env);
+    const user = userLocation({
+        home: homedir(),
+        xdgConfigHome: process.env["XDG_CONFIG_HOME"],
+        userFolder: absoluteWorkflowFolder(settings.environment["CLOVING_WORKFLOW_FOLDER"]),
+    });
+    return join(user.root, ...user.parts);
+}
+async function queuedIn(folder) {
+    const names = await readdir(folder).catch(() => []);
+    const ids = await Promise.all(names
+        .filter((name) => name.endsWith(".declaration.json"))
+        .map((name) => queuedId(folder, name)));
+    return ids.flatMap((id) => (id === undefined ? [] : [id]));
+}
+async function queuedId(folder, name) {
+    const text = await readFile(join(folder, name), "utf8").catch(() => "");
+    let declaration;
+    try {
+        declaration = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isCandidateDeclaration(declaration) ||
+        declaration.workflow.queue !== true)
+        return undefined;
+    const source = join(folder, name.replace(/\.declaration\.json$/, ".ts"));
+    const entry = await stat(source).catch(() => undefined);
+    return entry?.isFile() === true ? declaration.workflow.workflowId : undefined;
+}
+if (process.argv[1] === import.meta.filename)
+    process.exitCode = await templateCommand(process.argv.slice(2));

package/dist/tools/template-copy.d.ts

@@ -0,0 +1,11 @@
+import { type Template } from "./template-files.ts";
+export declare function copyTemplate(input: {
+    readonly root: string;
+    readonly name: string;
+    readonly id: string;
+    readonly folder: string;
+    readonly takenNames: ReadonlySet<string>;
+}): Promise<{
+    readonly template: Template;
+    readonly files: readonly string[];
+}>;

package/dist/tools/template-copy.js

@@ -0,0 +1,130 @@
+import { link, mkdir, mkdtemp, readFile, rm, writeFile, } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import ts from "typescript";
+import { record } from "../src/protocol.js";
+import { readTemplate, templateName } from "./template-files.js";
+export async function copyTemplate(input) {
+    if (!templateName.test(input.id) || input.id.length > 64)
+        throw new Error(`invalid-workflow-id: ${input.id}`);
+    const template = await readTemplate(input.root, input.name);
+    const sources = await Promise.all(template.files.map(async (file) => ({
+        file,
+        text: await readFile(join(input.root, input.name, file), "utf8"),
+    })));
+    const renaming = functionRenaming(sources, input);
+    const plan = sources.map(({ file, text }) => ({
+        target: input.id + file.slice(input.name.length),
+        content: copiedContent({ file, text }, renaming),
+    }));
+    await writePlan(input.folder, plan);
+    return { template, files: plan.map((item) => item.target) };
+}
+function camelName(id) {
+    return id.replace(/-([a-z0-9])/g, (_, letter) => letter.toUpperCase());
+}
+function functionRenaming(sources, input) {
+    const from = camelName(input.name);
+    const names = new Set(sources
+        .filter(({ file }) => file.endsWith(".ts"))
+        .flatMap(({ text }) => text.match(/[A-Za-z_$][\w$]*/g) ?? []));
+    for (const name of input.takenNames)
+        names.add(name);
+    let to = camelName(input.id);
+    while (to !== from && (names.has(to) || reservedWord(to)))
+        to += "Workflow";
+    return { template: input.name, id: input.id, from, to };
+}
+function reservedWord(name) {
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, true);
+    scanner.setText(name);
+    const kind = scanner.scan();
+    return ((kind >= ts.SyntaxKind.FirstReservedWord &&
+        kind <= ts.SyntaxKind.LastFutureReservedWord) ||
+        ["await", "eval", "arguments"].includes(name));
+}
+function copiedContent(source, renaming) {
+    const { file, text } = source;
+    if (file.endsWith(".declaration.json"))
+        return copiedDeclaration(text, renaming);
+    if (!file.endsWith(".ts") || renaming.id === renaming.template)
+        return text;
+    return renamedSource(source, renaming);
+}
+function copiedDeclaration(text, renaming) {
+    const declaration = record(JSON.parse(text));
+    const workflow = record(declaration?.["workflow"]);
+    if (declaration === undefined || workflow === undefined)
+        throw new Error(`invalid-template: ${renaming.template}`);
+    return (JSON.stringify({
+        template: renaming.template,
+        ...declaration,
+        workflow: { ...workflow, workflowId: renaming.id },
+    }, null, 2) + "\n");
+}
+function renamedSource(input, renaming) {
+    const { file, text } = input;
+    const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true);
+    const edits = [];
+    const prefix = new RegExp(`^(\\.\\.?/)${renaming.template}(?=[./])`);
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && node.text === renaming.from)
+            edits.push({ start: node.getStart(), end: node.end, text: renaming.to });
+        if (ts.isStringLiteral(node) &&
+            (ts.isImportDeclaration(node.parent) ||
+                ts.isExportDeclaration(node.parent)) &&
+            prefix.test(node.text))
+            edits.push({
+                start: node.getStart() + 1,
+                end: node.end - 1,
+                text: node.text.replace(prefix, `$1${renaming.id}`),
+            });
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return edits
+        .sort((left, right) => right.start - left.start)
+        .reduce((current, edit) => current.slice(0, edit.start) + edit.text + current.slice(edit.end), text);
+}
+async function writePlan(folder, plan) {
+    await mkdir(folder, { recursive: true });
+    const staging = await mkdtemp(join(dirname(folder), ".template-copy-"));
+    const created = [];
+    try {
+        for (const item of plan) {
+            await mkdir(dirname(join(staging, item.target)), { recursive: true });
+            await writeFile(join(staging, item.target), item.content);
+        }
+        for (const item of plan)
+            await placed({ folder, staging, item }, created);
+    }
+    catch (error) {
+        for (const path of created.reverse())
+            await rm(path, { recursive: true, force: true });
+        throw error;
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}
+async function placed(input, created) {
+    const parts = input.item.target.split("/");
+    for (let depth = 1; depth < parts.length; depth += 1) {
+        const directory = join(input.folder, ...parts.slice(0, depth));
+        if (created.includes(directory))
+            continue;
+        await mkdir(directory).catch((error) => {
+            throw present(error, parts.slice(0, depth).join("/"));
+        });
+        created.push(directory);
+    }
+    const target = join(input.folder, input.item.target);
+    await link(join(input.staging, input.item.target), target).catch((error) => {
+        throw present(error, input.item.target);
+    });
+    created.push(target);
+}
+function present(error, target) {
+    return error instanceof Error && "code" in error && error.code === "EEXIST"
+        ? new Error(`workflow-exists: ${target}`)
+        : error;
+}

package/dist/tools/template-files.d.ts

@@ -0,0 +1,17 @@
+import { type Fields } from "../src/protocol.ts";
+export interface TemplateSummary {
+    readonly name: string;
+    readonly summary: string;
+    readonly points: number;
+}
+export interface Template {
+    readonly name: string;
+    readonly description: Fields;
+    readonly points: readonly unknown[];
+    readonly files: readonly string[];
+}
+export declare const templateName: RegExp;
+export declare function templateRoot(start?: string): string;
+export declare function templateList(root: string): Promise<readonly TemplateSummary[]>;
+export declare function readTemplate(root: string, name: string): Promise<Template>;
+export declare function exportedFunctions(folders: readonly string[]): Promise<ReadonlySet<string>>;

package/dist/tools/template-files.js

@@ -0,0 +1,74 @@
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { record } from "../src/protocol.js";
+export const templateName = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const descriptionFiles = ["template.json", "README.md"];
+export function templateRoot(start = import.meta.dirname) {
+    let directory = start;
+    while (!existsSync(join(directory, "package.json"))) {
+        const parent = dirname(directory);
+        if (parent === directory)
+            throw new Error("templates-not-found");
+        directory = parent;
+    }
+    return join(directory, "templates");
+}
+export async function templateList(root) {
+    const entries = await readdir(root, { withFileTypes: true });
+    const names = entries
+        .filter((entry) => entry.isDirectory() && templateName.test(entry.name))
+        .map((entry) => entry.name)
+        .sort();
+    const templates = await Promise.all(names.map((name) => readTemplate(root, name).catch(() => undefined)));
+    return templates.flatMap((template) => template === undefined
+        ? []
+        : [
+            {
+                name: template.name,
+                summary: String(template.description["summary"]),
+                points: template.points.length,
+            },
+        ]);
+}
+export async function readTemplate(root, name) {
+    if (!templateName.test(name))
+        throw new Error(`unknown-template: ${name}`);
+    const folder = join(root, name);
+    const text = await readFile(join(folder, "template.json"), "utf8").catch(() => {
+        throw new Error(`unknown-template: ${name}`);
+    });
+    const description = record(JSON.parse(text));
+    const points = description?.["points"];
+    if (description === undefined ||
+        typeof description["summary"] !== "string" ||
+        !Array.isArray(points))
+        throw new Error(`invalid-template: ${name}`);
+    return { name, description, points, files: await workflowFiles(folder) };
+}
+export async function exportedFunctions(folders) {
+    const names = new Set();
+    for (const folder of folders) {
+        const files = await readdir(folder).catch(() => []);
+        for (const file of files.filter((name) => /^[^.].*(?<!\.test|\.d)\.[jt]s$/.test(name))) {
+            const text = await readFile(join(folder, file), "utf8").catch(() => "");
+            for (const match of text.matchAll(/export\s+(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/g))
+                names.add(String(match[1]));
+        }
+    }
+    return names;
+}
+async function workflowFiles(folder) {
+    const entries = await readdir(folder, {
+        recursive: true,
+        withFileTypes: true,
+    });
+    return entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => join(entry.parentPath, entry.name)
+        .slice(folder.length + 1)
+        .split("\\")
+        .join("/"))
+        .filter((file) => !descriptionFiles.includes(file))
+        .sort();
+}

package/dist/tools/workflow-bundles.js

@@ -153,6 +153,7 @@ export async function retainWorkflowBundle(input) {
     }
     const temporary = await mkdtemp(join(input.directory, ".pending-"));
     try {
+        await mkdir(join(temporary, "workflows"), { mode: 0o700 });
         for (const { name, bytes } of files) {
             const path = join(temporary, name);
             await mkdir(dirname(path), { recursive: true, mode: 0o700 });

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

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { protectedCall, helperCall, } from "./workflow-candidate-syntax.js";
+import { protectedCall, commandWaitCall, 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 };
@@ -218,7 +218,7 @@ function nodeTotals(node, input) {
     if (local && ts.isFunctionLike(node))
         return local;
     let total = local ??
-        (protectedCall(node, input.symbols)
+        (protectedCall(node, input.symbols) && !commandWaitCall(node, input.symbols)
             ? { knownCallCount: 1, knownUnitTotal: units(node, input.symbols) }
             : zero);
     ts.forEachChild(node, (child) => {

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

@@ -5,9 +5,11 @@ export interface CandidatePackageOptions {
     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): {
+export interface CandidateProgram {
     readonly program: ts.Program;
     readonly source: ts.SourceFile;
     readonly sources: readonly ts.SourceFile[];
     readonly modules: ReadonlyMap<string, ts.SourceFile>;
-};
+}
+export declare function candidateProgram(text: string, installed?: CandidatePackageOptions): CandidateProgram;
+export declare function candidateCompiler(installed?: CandidatePackageOptions): (text: string) => CandidateProgram;

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

@@ -10,9 +10,12 @@ export function resolvedSymbol(checker, symbol) {
     return checker.getAliasedSymbol(symbol);
 }
 export function candidateProgram(text, installed = {}) {
+    return candidateCompiler(installed)(text);
+}
+export function candidateCompiler(installed = {}) {
     const packageRoot = resolve(installed.packageRoot ?? candidatePackageRoot);
     const candidate = join(packageRoot, "candidate.ts");
-    const sources = new Map([[candidate, text]]);
+    const sources = new Map([[candidate, ""]]);
     for (const [name, content] of Object.entries(installed.helpers ?? {})) {
         if (workflowHelperPath("candidate.ts", `./${name}`) !== name)
             throw new Error("invalid-workflow-helper");
@@ -32,12 +35,18 @@ export function candidateProgram(text, installed = {}) {
         noEmit: true,
     };
     const host = trustedHost({ sources, options, entries, packageRoot });
-    const program = ts.createProgram([...sources.keys(), ...entries.values()], options, host);
-    const source = program.getSourceFile(candidate);
+    return (text) => {
+        sources.set(candidate, text);
+        const program = ts.createProgram([...sources.keys(), ...entries.values()], options, host);
+        return compiledCandidate(program, { candidate, sources, entries });
+    };
+}
+function compiledCandidate(program, input) {
+    const source = program.getSourceFile(input.candidate);
     if (!source)
         throw new Error("candidate-analysis-unavailable");
     const modules = new Map();
-    for (const [name, file] of entries) {
+    for (const [name, file] of input.entries) {
         const declaration = program.getSourceFile(file);
         if (!declaration)
             throw new Error("candidate-surface-unavailable");
@@ -47,7 +56,7 @@ export function candidateProgram(text, installed = {}) {
         program,
         source,
         modules,
-        sources: [...sources.keys()].map((name) => {
+        sources: [...input.sources.keys()].map((name) => {
             const entry = program.getSourceFile(name);
             if (!entry)
                 throw new Error("candidate-analysis-unavailable");
@@ -55,6 +64,21 @@ export function candidateProgram(text, installed = {}) {
         }),
     };
 }
+function sourceReader(readFile) {
+    const declarations = new Map();
+    return (file, languageVersion) => {
+        const content = readFile(file);
+        if (content === undefined)
+            return undefined;
+        const cached = declarations.get(file);
+        if (cached?.text === content)
+            return cached;
+        const source = ts.createSourceFile(file, content, languageVersion, true);
+        if (file.endsWith(".d.ts"))
+            declarations.set(file, source);
+        return source;
+    };
+}
 function trustedHost(input) {
     const { sources, options, entries, packageRoot } = input;
     const libraries = dirname(ts.getDefaultLibFilePath(options)) + sep;
@@ -72,12 +96,7 @@ function trustedHost(input) {
     const host = ts.createCompilerHost(options);
     host.readFile = readFile;
     host.fileExists = (file) => readFile(file) !== undefined;
-    host.getSourceFile = (file, languageVersion) => {
-        const content = readFile(file);
-        return content === undefined
-            ? undefined
-            : ts.createSourceFile(file, content, languageVersion, true);
-    };
+    host.getSourceFile = sourceReader(readFile);
     host.resolveModuleNameLiterals = (names, containingFile) => names.map(({ text: name }) => {
         const installed = entries.get(name);
         if (installed)

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

@@ -0,0 +1,3 @@
+import ts from "typescript";
+export declare function workflowShape(source: ts.SourceFile): boolean;
+export declare function passiveCandidateModule(source: ts.SourceFile, kind?: "workflow" | "helper"): boolean;

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

@@ -0,0 +1,90 @@
+import ts from "typescript";
+export function workflowShape(source) {
+    const exported = source.statements.filter((node) => ts.isFunctionDeclaration(node) &&
+        (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
+    const candidate = exported[0];
+    if (exported.length !== 1 ||
+        !candidate ||
+        !ts.isFunctionDeclaration(candidate))
+        return false;
+    if (!workflowFunction(candidate))
+        return false;
+    const directives = [];
+    function visit(node) {
+        if (ts.isStringLiteral(node) && node.text === "use workflow")
+            directives.push(node);
+        ts.forEachChild(node, visit);
+    }
+    visit(source);
+    return directives.length === 1;
+}
+function workflowFunction(candidate) {
+    if (!candidate.name || !candidate.body || candidate.asteriskToken)
+        return false;
+    const modifiers = ts.getModifiers(candidate) ?? [];
+    if (!modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ||
+        modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword))
+        return false;
+    const first = candidate.body.statements[0];
+    return first !== undefined && workflowDirective(first);
+}
+function workflowDirective(node) {
+    return (ts.isExpressionStatement(node) &&
+        ts.isStringLiteral(node.expression) &&
+        node.expression.text === "use workflow");
+}
+function unwrappedInitializer(node) {
+    if (ts.isParenthesizedExpression(node) ||
+        ts.isAsExpression(node) ||
+        ts.isSatisfiesExpression(node) ||
+        ts.isTypeAssertionExpression(node))
+        return node.expression;
+    return undefined;
+}
+function passiveCompound(node) {
+    if (ts.isArrayLiteralExpression(node))
+        return node.elements.every((element) => ts.isOmittedExpression(element) || passiveInitializer(element));
+    if (ts.isObjectLiteralExpression(node))
+        return node.properties.every((property) => ts.isPropertyAssignment(property) &&
+            !ts.isComputedPropertyName(property.name) &&
+            passiveInitializer(property.initializer));
+    return false;
+}
+function passiveInitializer(node) {
+    if (!node)
+        return false;
+    if (ts.isLiteralExpression(node))
+        return true;
+    if ([
+        ts.SyntaxKind.TrueKeyword,
+        ts.SyntaxKind.FalseKeyword,
+        ts.SyntaxKind.NullKeyword,
+    ].includes(node.kind))
+        return true;
+    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node))
+        return true;
+    if (ts.isPrefixUnaryExpression(node))
+        return ([ts.SyntaxKind.PlusToken, ts.SyntaxKind.MinusToken].includes(node.operator) && ts.isNumericLiteral(node.operand));
+    const inner = unwrappedInitializer(node);
+    return inner ? passiveInitializer(inner) : passiveCompound(node);
+}
+function passiveStatement(node, kind) {
+    if (ts.isVariableStatement(node))
+        return ((node.declarationList.flags & ts.NodeFlags.Const) !== 0 &&
+            node.declarationList.declarations.every((declaration) => (kind === "helper" ||
+                (ts.getCombinedModifierFlags(declaration) &
+                    ts.ModifierFlags.Export) ===
+                    0) &&
+                ts.isIdentifier(declaration.name) &&
+                passiveInitializer(declaration.initializer)));
+    if (ts.isExpressionStatement(node))
+        return ts.isStringLiteral(node.expression);
+    return (ts.isImportDeclaration(node) ||
+        ts.isTypeAliasDeclaration(node) ||
+        ts.isInterfaceDeclaration(node) ||
+        ts.isFunctionDeclaration(node) ||
+        ts.isEmptyStatement(node));
+}
+export function passiveCandidateModule(source, kind = "workflow") {
+    return source.statements.every((node) => passiveStatement(node, kind));
+}

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

@@ -1,5 +1,6 @@
 import { type CandidatePackageOptions } from "./workflow-candidate-program.ts";
 import type { CandidateAnalysis, InstalledWorkflowExports } from "../src/workflow-candidate.ts";
+export declare function createWorkflowCandidateAnalyzer(installed?: CandidatePackageOptions): (text: string) => ReturnType<typeof analyzeWorkflowCandidate>;
 export declare function analyzeWorkflowCandidate(text: string, installed?: CandidatePackageOptions): {
     readonly analysis: CandidateAnalysis;
     readonly installedExports: InstalledWorkflowExports;