cloving 1.3.0 → 1.4.0

package/dist/tools/self-host.js

@@ -14,6 +14,7 @@ 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";
+import { checkSubmission } from "../src/submission.js";
 const product = resolve(import.meta.dirname, "..");
 const flags = process.argv.slice(2);
 function flag(name) {
@@ -89,7 +90,18 @@ function queueLanes() {
         throw new Error("The daemon did not start: queue-lanes-needs-queue");
     return Number(value);
 }
-function queueInterval(commands) {
+function queueSpendLimit() {
+    const value = environment["CLOVING_QUEUE_DAILY_SPEND_USD"];
+    if (value === undefined)
+        return undefined;
+    const limit = Number(value);
+    if (!Number.isFinite(limit) || limit <= 0)
+        throw new Error("The daemon did not start: invalid-queue-spend-limit");
+    if (environment["CLOVING_QUEUE_SECONDS"] === undefined)
+        throw new Error("The daemon did not start: queue-spend-limit-needs-queue");
+    return limit;
+}
+function queueInterval() {
     const value = environment["CLOVING_QUEUE_SECONDS"];
     if (value === undefined)
         return undefined;
@@ -99,10 +111,6 @@ function queueInterval(commands) {
         seconds < 10 ||
         seconds > 3600)
         throw new Error("The daemon did not start: invalid-queue-seconds");
-    if (!commands.nextCommand?.length)
-        throw new Error("The daemon did not start: queue-needs-next-command");
-    if (!commands.ticketCommand?.length)
-        throw new Error("The daemon did not start: queue-needs-ticket-command");
     return seconds * 1000;
 }
 function listed(name) {
@@ -118,6 +126,12 @@ function source(file) {
     return JSON.stringify(pathToFileURL(join(product, file.replace(/\.ts$/, extname(import.meta.filename)))).href);
 }
 async function launchers(commands, workflows) {
+    const queueEnabled = commands.queueMilliseconds !== undefined &&
+        workflows.declarations.some((declaration) => declaration.queue === true);
+    if (queueEnabled && !commands.nextCommand?.length)
+        throw new Error("The daemon did not start: queue-needs-next-command");
+    if (queueEnabled && !commands.ticketCommand?.length)
+        throw new Error("The daemon did not start: queue-needs-ticket-command");
     const settings = {
         ...commands,
         directory,
@@ -144,6 +158,22 @@ process.once("SIGINT", stop);
 process.once("SIGTERM", stop);
 `);
 }
+function runCommand(declaration) {
+    const { workflowId, input } = declaration;
+    for (const [field, value, argument] of [
+        ["ticket", "ticket-id", "--ticket <ticket-id>"],
+        ["prompt", "task text", '--prompt "<text>"'],
+    ]) {
+        const checked = checkSubmission(input, {
+            workflowId,
+            source: field,
+            submission: { [field]: value },
+        });
+        if (checked.kind === "valid")
+            return `  ${client} run ${workflowId} ${argument}`;
+    }
+    return `  ${client} run ${workflowId} --input <json-file>`;
+}
 function guide(workflows) {
     return [
         "Cloving runs. Stop it with Control-C.",
@@ -154,10 +184,9 @@ function guide(workflows) {
         ...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>`,
-        `  ${client} run develop-prompt --prompt "<the text of the task>"`,
-        `  ${client} run develop-prd --prompt "<the idea>"`,
+        ...(workflows.declarations.length === 0
+            ? ["No workflow. Run: cloving init"]
+            : workflows.declarations.map(runCommand)),
         `  ${client} status`,
         `  ${client} questions`,
         `  ${client} watch`,
@@ -187,8 +216,9 @@ const harness = configuration.harness ?? {};
 const command = turnHarness({ worker, workerCommands, harness }).command;
 const nextCommand = listed("CLOVING_NEXT_COMMAND");
 const ticketCommand = listed("CLOVING_TICKET_COMMAND");
+const queueDailySpendLimitUsd = queueSpendLimit();
 const lanes = queueLanes();
-const queueMilliseconds = queueInterval({ nextCommand, ticketCommand });
+const queueMilliseconds = queueInterval();
 const manifests = await preparedProject({
     product,
     project,
@@ -213,6 +243,7 @@ await launchers({
     nextCommand,
     queueMilliseconds,
     queueLanes: lanes,
+    queueDailySpendLimitUsd,
     resetQueue: flags.includes("--reset-queue"),
     notifyCommand: listed("CLOVING_NOTIFY_COMMAND"),
     githubCommand: listed("CLOVING_GH_COMMAND"),
@@ -221,6 +252,7 @@ await launchers({
     privateTexts: listed("CLOVING_PRIVATE_TEXTS"),
 }, manifests);
 process.exitCode = await hostedPrograms({
+    environment,
     project,
     product,
     runtime,

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

@@ -0,0 +1 @@
+export declare function templateCommand(argumentsList: readonly string[]): Promise<number>;

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-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));
+}