cloving 1.1.0 → 1.2.0

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

@@ -0,0 +1,251 @@
+import ts from "typescript";
+import { protectedCall, handoffCall, propertyName, } from "./workflow-candidate-syntax.js";
+import { referenceSymbol } from "./workflow-source-effects.js";
+const zero = { knownCallCount: 0, knownUnitTotal: 0 };
+function add(first, second) {
+    return {
+        knownCallCount: Math.min(Number.MAX_SAFE_INTEGER, first.knownCallCount + second.knownCallCount),
+        knownUnitTotal: Math.min(Number.MAX_SAFE_INTEGER, first.knownUnitTotal + second.knownUnitTotal),
+    };
+}
+function maximum(first, second) {
+    return {
+        knownCallCount: Math.max(first.knownCallCount, second.knownCallCount),
+        knownUnitTotal: Math.max(first.knownUnitTotal, second.knownUnitTotal),
+    };
+}
+function multiply(total, repetitions) {
+    return {
+        knownCallCount: Math.min(Number.MAX_SAFE_INTEGER, total.knownCallCount * repetitions),
+        knownUnitTotal: Math.min(Number.MAX_SAFE_INTEGER, total.knownUnitTotal * repetitions),
+    };
+}
+function units(node, symbols) {
+    if (handoffCall(node, symbols))
+        return 1;
+    const argument = node.arguments[0];
+    if (!argument || !ts.isObjectLiteralExpression(argument))
+        return 0;
+    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;
+}
+function loopIncrement(node, variable) {
+    if ((ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node)) &&
+        ts.isIdentifier(node.operand) &&
+        node.operand.text === variable)
+        return unaryIncrement(node.operator);
+    return assignmentIncrement(node, variable);
+}
+function unaryIncrement(operator) {
+    if (operator === ts.SyntaxKind.PlusPlusToken)
+        return 1;
+    if (operator === ts.SyntaxKind.MinusMinusToken)
+        return -1;
+    return undefined;
+}
+function assignmentIncrement(node, variable) {
+    if (!ts.isBinaryExpression(node) ||
+        !ts.isIdentifier(node.left) ||
+        node.left.text !== variable)
+        return undefined;
+    const amount = constantNumber(node.right);
+    if (amount === undefined)
+        return undefined;
+    if (node.operatorToken.kind === ts.SyntaxKind.PlusEqualsToken)
+        return amount;
+    if (node.operatorToken.kind === ts.SyntaxKind.MinusEqualsToken)
+        return -amount;
+    return undefined;
+}
+function constantNumber(node) {
+    if (ts.isParenthesizedExpression(node))
+        return constantNumber(node.expression);
+    if (ts.isNumericLiteral(node)) {
+        const value = Number(node.text);
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (!ts.isPrefixUnaryExpression(node))
+        return undefined;
+    const value = constantNumber(node.operand);
+    if (value === undefined)
+        return undefined;
+    if (node.operator === ts.SyntaxKind.PlusToken)
+        return value;
+    if (node.operator === ts.SyntaxKind.MinusToken)
+        return -value;
+    return undefined;
+}
+function rangeIterations(input) {
+    const { start, end, increment, operator } = input;
+    if (![
+        ts.SyntaxKind.LessThanToken,
+        ts.SyntaxKind.LessThanEqualsToken,
+        ts.SyntaxKind.GreaterThanToken,
+        ts.SyntaxKind.GreaterThanEqualsToken,
+    ].includes(operator))
+        return undefined;
+    let iterations = 0;
+    let value = start;
+    while (iterations < 101 && loopContinues(value, { end, operator })) {
+        iterations += 1;
+        value += increment;
+    }
+    return iterations;
+}
+function loopContinues(value, condition) {
+    const { end, operator } = condition;
+    if (operator === ts.SyntaxKind.LessThanToken)
+        return value < end;
+    if (operator === ts.SyntaxKind.LessThanEqualsToken)
+        return value <= end;
+    if (operator === ts.SyntaxKind.GreaterThanToken)
+        return value > end;
+    return value >= end;
+}
+function referencesCounter(node, context) {
+    if (!context.counter)
+        return false;
+    if (ts.isIdentifier(node) &&
+        referenceSymbol(node, { parent: node.parent, checker: context.checker }) ===
+            context.counter)
+        return true;
+    return (ts.forEachChild(node, (child) => referencesCounter(child, context) ? true : undefined) ?? false);
+}
+function assignmentTarget(node) {
+    if (ts.isBinaryExpression(node) &&
+        node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+        node.operatorToken.kind <= ts.SyntaxKind.LastAssignment)
+        return node.left;
+    if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+        unaryIncrement(node.operator) !== undefined)
+        return node.operand;
+    return undefined;
+}
+function writesCounter(node, context) {
+    if (ts.isVariableDeclaration(node) && node.initializer !== undefined)
+        return referencesCounter(node.name, context);
+    if (ts.isForOfStatement(node) || ts.isForInStatement(node))
+        return referencesCounter(node.initializer, context);
+    const target = assignmentTarget(node);
+    return target !== undefined && referencesCounter(target, context);
+}
+function uncertainLoopBody(node, context) {
+    if (ts.isBreakStatement(node) ||
+        ts.isContinueStatement(node) ||
+        ts.isReturnStatement(node) ||
+        ts.isThrowStatement(node) ||
+        writesCounter(node, context))
+        return true;
+    return (ts.forEachChild(node, (child) => uncertainLoopBody(child, context) ? true : undefined) ?? false);
+}
+function loopIterations(node, symbols) {
+    const { initializer, condition, incrementor } = node;
+    const declaration = loopStart(initializer);
+    if (!declaration)
+        return undefined;
+    if (!condition || !ts.isBinaryExpression(condition))
+        return undefined;
+    if (!ts.isIdentifier(condition.left) ||
+        condition.left.text !== declaration.variable.text)
+        return undefined;
+    if (!incrementor)
+        return undefined;
+    const end = constantNumber(condition.right);
+    if (end === undefined)
+        return undefined;
+    const increment = loopIncrement(incrementor, declaration.variable.text);
+    if (increment === undefined)
+        return undefined;
+    if (uncertainLoopBody(node.statement, {
+        checker: symbols.checker,
+        counter: symbols.checker.getSymbolAtLocation(declaration.variable),
+    }))
+        return undefined;
+    return rangeIterations({
+        start: declaration.start,
+        end,
+        increment,
+        operator: condition.operatorToken.kind,
+    });
+}
+function loopStart(initializer) {
+    if (!initializer ||
+        !ts.isVariableDeclarationList(initializer) ||
+        initializer.declarations.length !== 1)
+        return undefined;
+    const declaration = initializer.declarations[0];
+    if (!declaration ||
+        !ts.isIdentifier(declaration.name) ||
+        !declaration.initializer)
+        return undefined;
+    const start = constantNumber(declaration.initializer);
+    if (start === undefined)
+        return undefined;
+    return {
+        variable: declaration.name,
+        start,
+    };
+}
+export function candidateEffectTotals(source, symbols) {
+    function count(node) {
+        if (!node)
+            return zero;
+        if (ts.isIfStatement(node))
+            return add(count(node.expression), maximum(count(node.thenStatement), count(node.elseStatement)));
+        if (ts.isConditionalExpression(node))
+            return add(count(node.condition), maximum(count(node.whenTrue), count(node.whenFalse)));
+        if (ts.isForStatement(node)) {
+            const iterations = loopIterations(node, symbols) ?? 1;
+            const body = count(node.statement);
+            const headers = add(count(node.initializer), add(count(node.condition), count(node.incrementor)));
+            return add(headers, multiply(body, iterations));
+        }
+        if (ts.isForOfStatement(node) &&
+            ts.isArrayLiteralExpression(node.expression))
+            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 count(source);
+}
+function arrayIterations(node, symbols) {
+    if (!ts.isArrayLiteralExpression(node.expression))
+        return 1;
+    return uncertainLoopBody(node.statement, {
+        checker: symbols.checker,
+        counter: undefined,
+    })
+        ? 1
+        : node.expression.elements.length;
+}
+function switchTotals(block, count) {
+    let suffix = zero;
+    let largest = zero;
+    let conditions = zero;
+    for (const clause of [...block.clauses].reverse()) {
+        if (ts.isCaseClause(clause))
+            conditions = add(conditions, count(clause.expression));
+        const ends = clause.statements.some((node) => ts.isBreakStatement(node) ||
+            ts.isReturnStatement(node) ||
+            ts.isThrowStatement(node));
+        const statements = clause.statements.reduce((total, statement) => add(total, count(statement)), zero);
+        suffix = add(statements, ends ? zero : suffix);
+        largest = maximum(largest, suffix);
+    }
+    return add(conditions, largest);
+}

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

@@ -0,0 +1,11 @@
+import ts from "typescript";
+export declare const candidatePackageRoot: string;
+export interface CandidatePackageOptions {
+    readonly packageRoot?: 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 modules: ReadonlyMap<string, ts.SourceFile>;
+};

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

@@ -0,0 +1,78 @@
+import { dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+import metadata from "#package" with { type: "json" };
+export const candidatePackageRoot = dirname(fileURLToPath(import.meta.resolve("#package")));
+export function resolvedSymbol(checker, symbol) {
+    if (!symbol || (symbol.flags & ts.SymbolFlags.Alias) === 0)
+        return symbol;
+    return checker.getAliasedSymbol(symbol);
+}
+export function candidateProgram(text, installed = {}) {
+    const packageRoot = resolve(installed.packageRoot ?? candidatePackageRoot);
+    const candidate = join(packageRoot, "candidate.ts");
+    const entries = new Map(Object.entries(metadata.exports).map(([name, entry]) => [
+        `cloving${name.slice(1)}`,
+        resolve(packageRoot, entry.types),
+    ]));
+    const options = {
+        target: ts.ScriptTarget.ES2024,
+        module: ts.ModuleKind.ESNext,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        lib: ["lib.es2024.d.ts", "lib.dom.d.ts"],
+        types: [],
+        strict: true,
+        noEmit: true,
+    };
+    const host = trustedHost({ candidate, text, options, entries, packageRoot });
+    const program = ts.createProgram([candidate, ...entries.values()], options, host);
+    const source = program.getSourceFile(candidate);
+    if (!source)
+        throw new Error("candidate-analysis-unavailable");
+    const modules = new Map();
+    for (const [name, file] of entries) {
+        const declaration = program.getSourceFile(file);
+        if (!declaration)
+            throw new Error("candidate-surface-unavailable");
+        modules.set(name, declaration);
+    }
+    return { program, source, modules };
+}
+function trustedHost(input) {
+    const { candidate, text, 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;
+        const absolute = resolve(file);
+        if (!absolute.endsWith(".d.ts"))
+            return undefined;
+        if (!absolute.startsWith(libraries) && !absolute.startsWith(declarations))
+            return undefined;
+        return ts.sys.readFile(absolute);
+    };
+    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.resolveModuleNameLiterals = (names, containingFile) => names.map(({ text: name }) => {
+        const installed = entries.get(name);
+        if (installed)
+            return {
+                resolvedModule: {
+                    resolvedFileName: installed,
+                    extension: ts.Extension.Dts,
+                },
+            };
+        if (containingFile === candidate)
+            return { resolvedModule: undefined };
+        return ts.resolveModuleName(name, containingFile, options, host);
+    });
+    return host;
+}

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

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

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

@@ -0,0 +1,107 @@
+import ts from "typescript";
+import { candidateProgram, resolvedSymbol, } from "./workflow-candidate-program.js";
+import { protectedEffectFact, passiveCandidateModule, unsupportedCandidateNode, workflowShape, } from "./workflow-candidate-syntax.js";
+import { sourceEffectNodes } from "./workflow-source-effects.js";
+import { candidateEffectTotals } from "./workflow-candidate-counts.js";
+function exportSnapshot(modules, checker) {
+    return Object.fromEntries([...modules].map(([name, declaration]) => {
+        const symbol = checker.getSymbolAtLocation(declaration);
+        return [
+            name,
+            symbol
+                ? checker
+                    .getExportsOfModule(symbol)
+                    .map((entry) => entry.name)
+                    .sort()
+                : [],
+        ];
+    }));
+}
+function protectedHelper(modules, options) {
+    const { checker } = options;
+    const protectedModule = modules.get(options.subpath);
+    const moduleSymbol = protectedModule && checker.getSymbolAtLocation(protectedModule);
+    return (moduleSymbol &&
+        resolvedSymbol(checker, checker
+            .getExportsOfModule(moduleSymbol)
+            .find((entry) => entry.name === options.name)));
+}
+function sourceFacts(symbols) {
+    const { source } = symbols;
+    const imports = [];
+    const effects = [];
+    const unsupportedForms = [];
+    function visit(node) {
+        const imported = sourceImport(node);
+        if (imported)
+            imports.push(imported);
+        const effect = protectedEffectFact(node, symbols);
+        if (effect)
+            effects.push(effect);
+        if (unsupportedCandidateNode(node, symbols))
+            unsupportedForms.push("unsupported-syntax");
+        ts.forEachChild(node, visit);
+    }
+    visit(source);
+    return {
+        imports,
+        effects,
+        directEffects: sourceEffectNodes(source, {
+            checker: symbols.checker,
+            profile: "candidate",
+        })
+            .filter((node) => !ts.isIdentifier(node) || node.text !== "require")
+            .map(() => "restricted-effect"),
+        unsupportedForms,
+        ...candidateEffectTotals(source, symbols),
+    };
+}
+function sourceImport(node) {
+    if (!ts.isImportDeclaration(node) ||
+        !ts.isStringLiteral(node.moduleSpecifier))
+        return undefined;
+    const bindings = node.importClause?.namedBindings;
+    return {
+        module: node.moduleSpecifier.text,
+        names: bindings && ts.isNamedImports(bindings)
+            ? bindings.elements.map((entry) => entry.propertyName?.text ?? entry.name.text)
+            : [],
+    };
+}
+export function analyzeWorkflowCandidate(text, installed = {}) {
+    const { program, source, modules } = candidateProgram(text, installed);
+    const checker = program.getTypeChecker();
+    const symbols = {
+        checker,
+        source,
+        protectedSymbol: protectedHelper(modules, {
+            checker,
+            subpath: "cloving/workflows/steps/protected-effect",
+            name: "protectedEffect",
+        }),
+        handoffSymbol: protectedHelper(modules, {
+            checker,
+            subpath: "cloving/workflows/steps/handoff",
+            name: "handoff",
+        }),
+    };
+    const facts = sourceFacts(symbols);
+    const invalid = !workflowShape(source) ||
+        source.referencedFiles.length > 0 ||
+        source.typeReferenceDirectives.length > 0 ||
+        source.libReferenceDirectives.length > 0 ||
+        program.getSyntacticDiagnostics(source).length > 0;
+    return {
+        analysis: {
+            ...facts,
+            unsupportedForms: [
+                ...facts.unsupportedForms,
+                ...(invalid ? ["workflow-shape"] : []),
+                ...(facts.directEffects.length === 0 && !passiveCandidateModule(source)
+                    ? ["module-initialization"]
+                    : []),
+            ],
+        },
+        installedExports: exportSnapshot(modules, checker),
+    };
+}

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

@@ -0,0 +1,15 @@
+import ts from "typescript";
+import type { CandidateEffect } from "../src/workflow-candidate.ts";
+export interface CandidateSymbols {
+    readonly checker: ts.TypeChecker;
+    readonly source: ts.SourceFile;
+    readonly protectedSymbol: ts.Symbol | undefined;
+    readonly handoffSymbol: ts.Symbol | undefined;
+}
+export declare function propertyName(name: ts.PropertyName): string | undefined;
+export declare function protectedCall(node: ts.Node, symbols: CandidateSymbols): node is ts.CallExpression;
+export declare function handoffCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
+export declare function protectedEffectFact(node: ts.Node, symbols: CandidateSymbols): CandidateEffect | undefined;
+export declare function unsupportedCandidateNode(node: ts.Node, symbols: CandidateSymbols): boolean;
+export declare function workflowShape(source: ts.SourceFile): boolean;
+export declare function passiveCandidateModule(source: ts.SourceFile): boolean;

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

@@ -0,0 +1,219 @@
+import ts from "typescript";
+import { resolvedSymbol } from "./workflow-candidate-program.js";
+import { referenceSymbol } from "./workflow-source-effects.js";
+export function propertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name))
+        return name.text;
+    return undefined;
+}
+export function protectedCall(node, symbols) {
+    if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression))
+        return false;
+    const symbol = resolvedSymbol(symbols.checker, symbols.checker.getSymbolAtLocation(node.expression));
+    return (symbol !== undefined &&
+        [symbols.protectedSymbol, symbols.handoffSymbol].includes(symbol));
+}
+export function handoffCall(node, symbols) {
+    return (symbols.handoffSymbol !== undefined &&
+        resolvedSymbol(symbols.checker, symbols.checker.getSymbolAtLocation(node.expression)) === symbols.handoffSymbol);
+}
+function literalField(node, field) {
+    const property = node.properties.find((entry) => entry.name && propertyName(entry.name) === field);
+    if (!property || !ts.isPropertyAssignment(property))
+        return null;
+    return ts.isStringLiteral(property.initializer)
+        ? property.initializer.text
+        : null;
+}
+export function protectedEffectFact(node, symbols) {
+    if (!protectedCall(node, symbols))
+        return undefined;
+    if (handoffCall(node, symbols))
+        return undefined;
+    const argument = node.arguments[0];
+    if (!argument || !ts.isObjectLiteralExpression(argument))
+        return undefined;
+    return {
+        capability: literalField(argument, "capability"),
+        method: literalField(argument, "method"),
+    };
+}
+function escapedHelper(node, symbols) {
+    if (!ts.isIdentifier(node))
+        return false;
+    const symbol = resolvedSymbol(symbols.checker, referenceSymbol(node, { parent: node.parent, checker: symbols.checker }));
+    if (symbol === undefined ||
+        ![symbols.protectedSymbol, symbols.handoffSymbol].includes(symbol))
+        return false;
+    if (ts.isImportSpecifier(node.parent))
+        return false;
+    return (!ts.isCallExpression(node.parent) ||
+        node.parent.expression !== node ||
+        node.parent.questionDotToken !== undefined);
+}
+function invalidImport(node) {
+    if (!ts.isImportDeclaration(node))
+        return false;
+    const clause = node.importClause;
+    return (!clause ||
+        clause.name !== undefined ||
+        !clause.namedBindings ||
+        !ts.isNamedImports(clause.namedBindings) ||
+        node.attributes !== undefined);
+}
+function invalidRequest(node, symbols) {
+    if (!protectedCall(node, symbols))
+        return false;
+    if (!workflowBodyCall(node))
+        return true;
+    const argument = node.arguments[0];
+    if (node.arguments.length !== 1 ||
+        !argument ||
+        !ts.isObjectLiteralExpression(argument))
+        return true;
+    const names = argument.properties.map((entry) => entry.name && propertyName(entry.name));
+    return (names.includes(undefined) ||
+        new Set(names).size !== names.length ||
+        argument.properties.some((entry) => !ts.isPropertyAssignment(entry)));
+}
+function workflowBodyCall(node) {
+    let child = node;
+    let parent = node.parent;
+    while (!ts.isFunctionLike(parent)) {
+        if (ts.isSourceFile(parent) || ts.isClassLike(parent))
+            return false;
+        child = parent;
+        parent = parent.parent;
+    }
+    if (!ts.isFunctionDeclaration(parent) || !ts.isSourceFile(parent.parent))
+        return false;
+    return (parent.body === child &&
+        (ts.getCombinedModifierFlags(parent) & ts.ModifierFlags.Export) !== 0);
+}
+function dynamicLoading(node, symbols) {
+    if (node.kind === ts.SyntaxKind.ImportKeyword ||
+        ts.isImportEqualsDeclaration(node) ||
+        ts.isImportTypeNode(node) ||
+        ts.isMetaProperty(node))
+        return true;
+    if (!ts.isIdentifier(node) || node.text !== "require")
+        return false;
+    const symbol = symbols.checker.getSymbolAtLocation(node);
+    return !symbol?.declarations?.some((entry) => entry.getSourceFile() === symbols.source);
+}
+function ambientDeclaration(node) {
+    if (ts.isModuleDeclaration(node))
+        return true;
+    return (ts.canHaveModifiers(node) &&
+        (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.DeclareKeyword));
+}
+function computedAccess(node) {
+    if (ts.isComputedPropertyName(node))
+        return true;
+    return (ts.isElementAccessExpression(node) &&
+        !ts.isStringLiteral(node.argumentExpression) &&
+        !ts.isNumericLiteral(node.argumentExpression));
+}
+export function unsupportedCandidateNode(node, symbols) {
+    const checks = [
+        escapedHelper(node, symbols),
+        invalidImport(node),
+        invalidRequest(node, symbols),
+        dynamicLoading(node, symbols),
+        ambientDeclaration(node),
+        computedAccess(node),
+        ts.isExportDeclaration(node) || ts.isExportAssignment(node),
+        ts.isSpreadAssignment(node) || ts.isSpreadElement(node),
+        node.kind === ts.SyntaxKind.ThisKeyword || ts.isWithStatement(node),
+        ts.isStringLiteral(node) && node.text === "use step",
+    ];
+    return checks.some(Boolean);
+}
+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) {
+    if (ts.isVariableStatement(node))
+        return ((node.declarationList.flags & ts.NodeFlags.Const) !== 0 &&
+            node.declarationList.declarations.every((declaration) => (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) {
+    return source.statements.every(passiveStatement);
+}