cloving 1.0.1 → 1.2.0

package/dist/tools/self-update.js

@@ -1,3 +1,22 @@
+export function lockRequiresInstall(before, after) {
+    try {
+        return !isDeepStrictEqual(lockPackages(before), lockPackages(after));
+    }
+    catch {
+        return true;
+    }
+}
+function lockPackages(text) {
+    const lock = JSON.parse(text);
+    if (typeof lock !== "object" || lock === null || !("packages" in lock))
+        throw new Error("invalid package lock");
+    const packages = lock.packages;
+    if (typeof packages !== "object" ||
+        packages === null ||
+        Array.isArray(packages))
+        throw new Error("invalid package lock packages");
+    return Object.fromEntries(Object.entries(packages).filter(([path]) => path !== ""));
+}
 async function clean(git) {
     const status = await git([
         "status",
@@ -9,6 +28,24 @@ async function clean(git) {
         return false;
     return !/^[a-zS] /m.test(await git(["ls-files", "-v"]));
 }
+async function installRequired(git, update) {
+    try {
+        await git([
+            "diff",
+            "--exit-code",
+            update.head,
+            update.target,
+            "--",
+            "package-lock.json",
+        ]);
+        return false;
+    }
+    catch {
+        const before = await git(["show", `${update.head}:package-lock.json`]);
+        const after = await git(["show", `${update.target}:package-lock.json`]);
+        return lockRequiresInstall(before, after);
+    }
+}
 async function candidate(settings) {
     const git = settings.git;
     await git(["fetch", "origin"]);
@@ -26,10 +63,40 @@ async function candidate(settings) {
     await git(["merge-base", "--is-ancestor", head, target]);
     if (!(await clean(git)))
         return;
+    await markPending(settings.directory);
     if (await settings.active())
-        return;
+        return "waiting";
     return { branch, head, target };
 }
+async function markPending(directory, publication = "initial") {
+    if (publication === "renew") {
+        const timestamp = Number(await readFile(join(directory, "pending-self-update"), "utf8"));
+        if (timestamp > 0 && Date.now() - timestamp < 30 * 60 * 1000)
+            return;
+    }
+    await mkdir(directory, { recursive: true });
+    const temporary = join(directory, `pending-self-update-${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporary, `${String(Date.now())}\n`, {
+            flag: "wx",
+            mode: 0o600,
+            flush: true,
+        });
+        if (publication === "renew") {
+            await rename(temporary, join(directory, "pending-self-update"));
+            return;
+        }
+        await link(temporary, join(directory, "pending-self-update")).catch((error) => {
+            if (!(error instanceof Error) ||
+                !("code" in error) ||
+                error.code !== "EEXIST")
+                throw error;
+        });
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
 async function failedTargets(directory) {
     try {
         return (await readFile(join(directory, "failed-self-updates"), "utf8")).split("\n");
@@ -70,21 +137,16 @@ export function selfUpdater(settings) {
             if (disabled || checking)
                 return;
             checking = true;
+            let waiting = false;
             try {
                 const update = await candidate(settings).catch(() => undefined);
-                if (!update)
+                if (update === "waiting") {
+                    waiting = true;
                     return;
-                try {
-                    await settings.git([
-                        "diff",
-                        "--exit-code",
-                        update.head,
-                        update.target,
-                        "--",
-                        "package-lock.json",
-                    ]);
                 }
-                catch {
+                if (!update)
+                    return;
+                if (await installRequired(settings.git, update).catch(() => true)) {
                     disabled = true;
                     settings.error("Self-update disabled: package-lock.json changed; update and install by hand.\n");
                     return;
@@ -92,14 +154,24 @@ export function selfUpdater(settings) {
                 const failed = await failedTargets(settings.directory).catch(() => undefined);
                 if (!failed || failed.includes(update.target))
                     return;
+                await markPending(settings.directory, "renew");
+                waiting = await settings.active().catch(() => true);
+                if (waiting)
+                    return;
                 disabled = true;
                 return await updated(settings, update);
             }
             finally {
                 checking = false;
+                if (!waiting)
+                    await rm(join(settings.directory, "pending-self-update"), {
+                        force: true,
+                    });
             }
         },
     };
 }
-import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { appendFile, link, mkdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
 import { join } from "node:path";
+import { isDeepStrictEqual } from "node:util";

package/dist/tools/workflow-bundle-dependencies.d.ts

@@ -0,0 +1,5 @@
+export declare function workflowPackageRoot(directory: string): Promise<string>;
+export declare function workflowBundleDependencies(input: {
+    readonly product: string;
+    readonly packages: readonly string[];
+}): Promise<string>;

package/dist/tools/workflow-bundle-dependencies.js

@@ -0,0 +1,93 @@
+import { createHash } from "node:crypto";
+import { access, readFile, realpath } from "node:fs/promises";
+import { findPackageJSON } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { record } from "../src/protocol.js";
+export async function workflowPackageRoot(directory) {
+    const root = resolve(directory);
+    try {
+        await access(join(root, "package.json"));
+        return root;
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+            throw error;
+    }
+    const parent = dirname(root);
+    if (parent === root)
+        throw new Error("workflow-package-unavailable");
+    return workflowPackageRoot(parent);
+}
+function references(manifest) {
+    const dependencies = record(manifest["dependencies"]) ?? {};
+    const optional = record(manifest["optionalDependencies"]) ?? {};
+    const peers = record(manifest["peerDependencies"]) ?? {};
+    const peerMetadata = record(manifest["peerDependenciesMeta"]) ?? {};
+    return Object.keys({ ...dependencies, ...optional, ...peers })
+        .sort()
+        .map((name) => ({
+        name,
+        optional: Object.hasOwn(optional, name) ||
+            (!Object.hasOwn(dependencies, name) &&
+                record(peerMetadata[name])?.["optional"] === true),
+    }));
+}
+async function manifestFile(from, reference) {
+    try {
+        const file = findPackageJSON(reference.name, from);
+        if (file !== undefined)
+            return await realpath(file);
+    }
+    catch (error) {
+        if (!(error instanceof Error &&
+            "code" in error &&
+            error.code === "ERR_MODULE_NOT_FOUND"))
+            throw error;
+    }
+    if (reference.optional)
+        return undefined;
+    throw new Error("workflow-dependency-unavailable");
+}
+async function capturePackage(capture, input) {
+    const file = await manifestFile(input.from, input);
+    if (file === undefined)
+        return null;
+    const previous = capture.seen.get(file);
+    if (previous !== undefined)
+        return previous;
+    const manifest = await readFile(file, "utf8");
+    const parsed = JSON.parse(manifest);
+    const fields = record(parsed);
+    if (typeof fields?.["name"] !== "string" ||
+        typeof fields["version"] !== "string")
+        throw new Error("invalid-workflow-dependency");
+    const captured = { manifest, dependencies: {} };
+    const index = capture.packages.length;
+    capture.seen.set(file, index);
+    capture.packages.push(captured);
+    for (const reference of references(fields))
+        captured.dependencies[reference.name] = await capturePackage(capture, {
+            ...reference,
+            from: file,
+        });
+    return index;
+}
+export async function workflowBundleDependencies(input) {
+    const capture = { seen: new Map(), packages: [] };
+    const roots = {};
+    const manifest = join(await workflowPackageRoot(input.product), "package.json");
+    for (const name of [...input.packages].sort())
+        roots[name] = await capturePackage(capture, {
+            name,
+            from: manifest,
+            optional: false,
+        });
+    return JSON.stringify({
+        node: process.version,
+        product: createHash("sha256")
+            .update(await readFile(manifest))
+            .digest("hex"),
+        roots,
+        packages: capture.packages,
+    });
+}

package/dist/tools/workflow-bundles.d.ts

@@ -0,0 +1,20 @@
+interface BundleInput {
+    readonly directory: string;
+    readonly repository: string;
+    readonly project: string;
+}
+interface BundleLookup {
+    readonly directory: string;
+    readonly repository: string;
+    readonly id: string;
+}
+type BundleResult = {
+    readonly kind: "available";
+    readonly directory: string;
+} | {
+    readonly kind: "unavailable";
+    readonly code: "pinned-workflow-unavailable";
+};
+export declare function readRetainedWorkflowBundle(input: BundleLookup): Promise<BundleResult>;
+export declare function retainWorkflowBundle(input: BundleInput): Promise<string>;
+export {};

package/dist/tools/workflow-bundles.js

@@ -0,0 +1,173 @@
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, mkdir, mkdtemp, open, readdir, realpath, rename, rm, writeFile, } from "node:fs/promises";
+import { dirname, join } from "node:path";
+const unavailable = {
+    kind: "unavailable",
+    code: "pinned-workflow-unavailable",
+};
+export async function readRetainedWorkflowBundle(input) {
+    if (!/^[a-f0-9]{64}$/.test(input.id))
+        return unavailable;
+    try {
+        const directory = join(input.directory, input.id);
+        if (!(await lstat(directory)).isDirectory())
+            return unavailable;
+        const repository = await realpath(input.repository);
+        const contents = bundleContents(repository, await projectFiles(directory));
+        const stored = await regularFile(join(directory, "bundle.json"));
+        if (digest(contents) !== input.id || stored.toString("utf8") !== contents)
+            return unavailable;
+        return { kind: "available", directory };
+    }
+    catch {
+        return unavailable;
+    }
+}
+function digest(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+async function regularFile(path) {
+    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        if (!(await file.stat()).isFile())
+            throw new Error("invalid-bundle-file");
+        return await file.readFile();
+    }
+    finally {
+        await file.close();
+    }
+}
+async function treeFiles(root, name) {
+    const path = join(root, name);
+    const entry = await lstat(path);
+    if (entry.isFile())
+        return [{ name, bytes: await regularFile(path) }];
+    if (!entry.isDirectory())
+        throw new Error("invalid-bundle-file");
+    const files = [];
+    for (const child of (await readdir(path)).sort())
+        files.push(...(await treeFiles(root, `${name}/${child}`)));
+    return files;
+}
+async function projectFiles(project) {
+    const files = [];
+    const names = (await readdir(project)).filter((name) => name.endsWith(".json") && name !== "bundle.json");
+    for (const name of [...names, "artifacts", "workflows"].sort())
+        files.push(...(await treeFiles(project, name)));
+    const required = [
+        "package.json",
+        "declarations.json",
+        "dependencies.json",
+        ...[
+            "client.mjs",
+            "flow.mjs",
+            "steps.mjs",
+            "manifest.json",
+            "flow.mjs.__wf_tmp.js.debug.json",
+            "steps.mjs.debug.json",
+        ].map((name) => `artifacts/${name}`),
+    ];
+    if (required.some((name) => !files.some((file) => file.name === name)))
+        throw new Error("incomplete-workflow-bundle");
+    return files;
+}
+function bundleContents(repository, files) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        repository,
+        files: Object.fromEntries(files.map(({ name, bytes }) => [name, digest(bytes)])),
+    });
+}
+async function validatedId(input) {
+    if ((await readRetainedWorkflowBundle(input)).kind !== "available")
+        throw new Error("pinned-workflow-unavailable");
+    return input.id;
+}
+async function existingEntry(path) {
+    return lstat(path).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+}
+async function retainedBefore(input, contents) {
+    try {
+        const history = join(input.directory, ".history");
+        await mkdir(history, { recursive: true, mode: 0o700 });
+        if (!(await lstat(history)).isDirectory())
+            throw new Error("pinned-workflow-unavailable");
+        const directory = join(history, input.id);
+        const entry = await existingEntry(directory);
+        if (entry === undefined)
+            return false;
+        if (!entry.isDirectory())
+            throw new Error("pinned-workflow-unavailable");
+        const receipt = await regularFile(join(directory, "bundle.json"));
+        if (receipt.toString("utf8") !== contents)
+            throw new Error("pinned-workflow-unavailable");
+        return true;
+    }
+    catch {
+        throw new Error("pinned-workflow-unavailable");
+    }
+}
+async function rememberBundle(input, contents) {
+    const history = join(input.directory, ".history");
+    const temporary = await mkdtemp(join(history, ".pending-"));
+    try {
+        await writeFile(join(temporary, "bundle.json"), contents, {
+            flag: "wx",
+            mode: 0o600,
+        });
+        await publishDirectory(temporary, join(history, input.id));
+        await retainedBefore(input, contents);
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}
+async function publishDirectory(from, to) {
+    await rename(from, to).catch((error) => {
+        if (error instanceof Error &&
+            "code" in error &&
+            ["ENOTEMPTY", "EEXIST"].includes(String(error.code)))
+            return;
+        throw error;
+    });
+}
+export async function retainWorkflowBundle(input) {
+    const repository = await realpath(input.repository);
+    const files = await projectFiles(input.project);
+    const contents = bundleContents(repository, files);
+    const id = digest(contents);
+    await mkdir(input.directory, { recursive: true, mode: 0o700 });
+    const destination = join(input.directory, id);
+    const lookup = { ...input, id };
+    if (await retainedBefore(lookup, contents))
+        return validatedId(lookup);
+    if (await existingEntry(destination)) {
+        await validatedId(lookup);
+        await rememberBundle(lookup, contents);
+        return id;
+    }
+    const temporary = await mkdtemp(join(input.directory, ".pending-"));
+    try {
+        for (const { name, bytes } of files) {
+            const path = join(temporary, name);
+            await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+            await writeFile(path, bytes, { flag: "wx", mode: 0o600 });
+        }
+        await writeFile(join(temporary, "bundle.json"), contents, {
+            flag: "wx",
+            mode: 0o600,
+        });
+        await publishDirectory(temporary, destination);
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+    await validatedId(lookup);
+    await rememberBundle(lookup, contents);
+    return id;
+}

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

@@ -0,0 +1,8 @@
+import ts from "typescript";
+import { type CandidateSymbols } from "./workflow-candidate-syntax.ts";
+interface Totals {
+    readonly knownCallCount: number;
+    readonly knownUnitTotal: number;
+}
+export declare function candidateEffectTotals(source: ts.SourceFile, symbols: CandidateSymbols): Totals;
+export {};

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