@kici-dev/compiler 0.4.0 → 0.5.0

package/dist/lockfile/purity-analyzer.d.ts

@@ -1,25 +0,0 @@
-/**
- * AST-based purity analysis for dynamic job functions.
- * Determines whether a function can be safely evaluated inline by the orchestrator
- * (via vm.runInNewContext) without requiring a full init job dispatch.
- *
- * A function is "pure" if it:
- * - Is synchronous (not async)
- * - Only references its parameters and safe globals
- * - Does not perform I/O, mutation, or use external scope
- * - Only uses const/let for local declarations (no var)
- */
-/** Result of purity analysis */
-interface PurityResult {
-    pure: boolean;
-    reason?: string;
-}
-/**
- * Analyze whether a function source string represents a pure function.
- *
- * @param fnSource - The function source code (e.g., "(event) => event.ref")
- * @returns PurityResult indicating whether the function is pure
- */
-export declare function analyzePurity(fnSource: string): PurityResult;
-export {};
-//# sourceMappingURL=purity-analyzer.d.ts.map

package/dist/lockfile/purity-analyzer.js

@@ -1,204 +0,0 @@
-import "../rolldown-runtime-ClRpJifh.js";
-import ts from "typescript";
-//#region src/lockfile/purity-analyzer.ts
-/**
-* AST-based purity analysis for dynamic job functions.
-* Determines whether a function can be safely evaluated inline by the orchestrator
-* (via vm.runInNewContext) without requiring a full init job dispatch.
-*
-* A function is "pure" if it:
-* - Is synchronous (not async)
-* - Only references its parameters and safe globals
-* - Does not perform I/O, mutation, or use external scope
-* - Only uses const/let for local declarations (no var)
-*/
-/**
-* Safe globals that pure functions are allowed to reference.
-* These are deterministic, side-effect-free built-ins.
-*/
-const SAFE_GLOBALS = /* @__PURE__ */ new Set([
-	"undefined",
-	"null",
-	"true",
-	"false",
-	"NaN",
-	"Infinity",
-	"String",
-	"Number",
-	"Boolean",
-	"Array",
-	"Object",
-	"JSON",
-	"Math",
-	"parseInt",
-	"parseFloat",
-	"isNaN",
-	"isFinite",
-	"encodeURIComponent",
-	"decodeURIComponent",
-	"encodeURI",
-	"decodeURI"
-]);
-/**
-* Assignment operators that indicate mutation.
-*/
-const ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set([
-	ts.SyntaxKind.EqualsToken,
-	ts.SyntaxKind.PlusEqualsToken,
-	ts.SyntaxKind.MinusEqualsToken,
-	ts.SyntaxKind.AsteriskEqualsToken,
-	ts.SyntaxKind.SlashEqualsToken,
-	ts.SyntaxKind.PercentEqualsToken,
-	ts.SyntaxKind.AmpersandEqualsToken,
-	ts.SyntaxKind.BarEqualsToken,
-	ts.SyntaxKind.CaretEqualsToken,
-	ts.SyntaxKind.LessThanLessThanEqualsToken,
-	ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
-	ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
-	ts.SyntaxKind.AsteriskAsteriskEqualsToken,
-	ts.SyntaxKind.BarBarEqualsToken,
-	ts.SyntaxKind.AmpersandAmpersandEqualsToken,
-	ts.SyntaxKind.QuestionQuestionEqualsToken
-]);
-/**
-* Analyze whether a function source string represents a pure function.
-*
-* @param fnSource - The function source code (e.g., "(event) => event.ref")
-* @returns PurityResult indicating whether the function is pure
-*/
-function analyzePurity(fnSource) {
-	const wrapped = "const __fn = " + fnSource;
-	const firstStatement = ts.createSourceFile("inline.js", wrapped, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS).statements[0];
-	if (!ts.isVariableStatement(firstStatement)) return {
-		pure: false,
-		reason: "failed to parse function source"
-	};
-	const declaration = firstStatement.declarationList.declarations[0];
-	if (!declaration.initializer) return {
-		pure: false,
-		reason: "failed to parse function source"
-	};
-	const fnNode = declaration.initializer;
-	if (!ts.isArrowFunction(fnNode) && !ts.isFunctionExpression(fnNode)) return {
-		pure: false,
-		reason: "not a function expression"
-	};
-	if (ts.getModifiers(fnNode)?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) return {
-		pure: false,
-		reason: "async functions cannot be inlined"
-	};
-	if (ts.isFunctionExpression(fnNode) && fnNode.asteriskToken) return {
-		pure: false,
-		reason: "generator functions cannot be inlined"
-	};
-	const paramNames = /* @__PURE__ */ new Set();
-	for (const param of fnNode.parameters) collectBindingNames(param.name, paramNames);
-	const localNames = /* @__PURE__ */ new Set();
-	return checkNode(fnNode.body, paramNames, localNames) ?? { pure: true };
-}
-/**
-* Recursively collect binding names from parameter declarations,
-* including destructured patterns.
-*/
-function collectBindingNames(node, names) {
-	if (ts.isIdentifier(node)) names.add(node.text);
-	else if (ts.isObjectBindingPattern(node)) for (const element of node.elements) collectBindingNames(element.name, names);
-	else if (ts.isArrayBindingPattern(node)) {
-		for (const element of node.elements) if (!ts.isOmittedExpression(element)) collectBindingNames(element.name, names);
-	}
-}
-/**
-* Check a node and its children for impurity.
-* Returns a PurityResult if impure, or undefined if pure so far.
-*/
-function checkNode(node, paramNames, localNames) {
-	switch (node.kind) {
-		case ts.SyntaxKind.AwaitExpression: return {
-			pure: false,
-			reason: "contains await expression"
-		};
-		case ts.SyntaxKind.ImportDeclaration: return {
-			pure: false,
-			reason: "contains import declaration"
-		};
-		case ts.SyntaxKind.YieldExpression: return {
-			pure: false,
-			reason: "contains yield expression"
-		};
-		case ts.SyntaxKind.ClassDeclaration:
-		case ts.SyntaxKind.ClassExpression: return {
-			pure: false,
-			reason: "contains class declaration"
-		};
-		case ts.SyntaxKind.ThisKeyword: return {
-			pure: false,
-			reason: "references 'this'"
-		};
-		case ts.SyntaxKind.DeleteExpression: return {
-			pure: false,
-			reason: "contains 'delete' expression"
-		};
-		case ts.SyntaxKind.ThrowStatement: return {
-			pure: false,
-			reason: "contains throw statement"
-		};
-		case ts.SyntaxKind.TryStatement: return {
-			pure: false,
-			reason: "contains try/catch"
-		};
-	}
-	if (ts.isNewExpression(node)) return {
-		pure: false,
-		reason: "contains 'new' expression"
-	};
-	if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) return {
-		pure: false,
-		reason: "contains dynamic import"
-	};
-	if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "require") return {
-		pure: false,
-		reason: "contains require() call"
-	};
-	if (ts.isPostfixUnaryExpression(node)) {
-		if (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) return {
-			pure: false,
-			reason: "contains mutation operator"
-		};
-	}
-	if (ts.isPrefixUnaryExpression(node)) {
-		if (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) return {
-			pure: false,
-			reason: "contains mutation operator"
-		};
-	}
-	if (ts.isBinaryExpression(node) && ASSIGNMENT_OPERATORS.has(node.operatorToken.kind)) return {
-		pure: false,
-		reason: "contains assignment"
-	};
-	if (ts.isVariableDeclarationList(node)) if (node.flags & ts.NodeFlags.Const || node.flags & ts.NodeFlags.Let) for (const decl of node.declarations) collectBindingNames(decl.name, localNames);
-	else return {
-		pure: false,
-		reason: "'var' declarations are not allowed (use const or let)"
-	};
-	if (ts.isIdentifier(node)) {
-		const parent = node.parent;
-		if (ts.isPropertyAccessExpression(parent) && parent.name === node) {} else if (ts.isPropertyAssignment(parent) && parent.name === node) {} else if (ts.isShorthandPropertyAssignment(parent) && parent.name === node) {
-			if (!paramNames.has(node.text) && !localNames.has(node.text) && !SAFE_GLOBALS.has(node.text)) return {
-				pure: false,
-				reason: `references unknown identifier '${node.text}'`
-			};
-		} else if (ts.isVariableDeclaration(parent) && parent.name === node) {} else if (ts.isBindingElement(parent) && parent.name === node) {} else if (ts.isParameter(parent) && parent.name === node) {} else if (!paramNames.has(node.text) && !localNames.has(node.text) && !SAFE_GLOBALS.has(node.text)) return {
-			pure: false,
-			reason: `references unknown identifier '${node.text}'`
-		};
-	}
-	const children = node.getChildren();
-	for (const child of children) {
-		const result = checkNode(child, paramNames, localNames);
-		if (result) return result;
-	}
-}
-//#endregion
-export { analyzePurity };
-
-//# sourceMappingURL=purity-analyzer.js.map

package/dist/lockfile/purity-diagnostics.d.ts

@@ -1,31 +0,0 @@
-import type { Job } from '@kici-dev/sdk';
-import type { WorkflowWithSource } from '../types.js';
-/** Which dynamic-value slot on a job carried the impure function. */
-export declare enum DynamicValueField {
-    Context = "context",
-    Env = "env",
-    ConcurrencyGroup = "concurrencyGroup"
-}
-/**
- * One impure dynamic-value function found on a static job. Each impurity forces
- * the orchestrator to dispatch an agent-side `__init__` job (~5-10s) instead of
- * inlining the value, so we surface it to the author at compile / preview time.
- */
-export interface JobPurityWarning {
-    workflowName: string;
-    sourceFile?: string;
-    jobName: string;
-    field: DynamicValueField;
-    reason: string;
-}
-/**
- * Analyze a single static job's dynamic-value functions (context(s), env,
- * concurrencyGroup) for impurity. Returns one warning per impure function.
- */
-export declare function analyzeJobPurity(job: Job, workflowName: string, sourceFile?: string): JobPurityWarning[];
-/**
- * Walk every workflow's static jobs and collect impurity warnings. Function-typed
- * jobs (dynamic job generators) are skipped — their purity is analyzed at dispatch.
- */
-export declare function collectWorkflowPurityWarnings(workflows: WorkflowWithSource[]): JobPurityWarning[];
-//# sourceMappingURL=purity-diagnostics.d.ts.map

package/dist/lockfile/purity-diagnostics.js

@@ -1,52 +0,0 @@
-import "../rolldown-runtime-ClRpJifh.js";
-import { analyzePurity } from "./purity-analyzer.js";
-//#region src/lockfile/purity-diagnostics.ts
-/** Which dynamic-value slot on a job carried the impure function. */
-let DynamicValueField = /* @__PURE__ */ function(DynamicValueField) {
-	DynamicValueField["Context"] = "context";
-	DynamicValueField["Env"] = "env";
-	DynamicValueField["ConcurrencyGroup"] = "concurrencyGroup";
-	return DynamicValueField;
-}({});
-function pushIfImpure(out, fn, field, base) {
-	if (typeof fn !== "function") return;
-	const result = analyzePurity(fn.toString());
-	if (!result.pure) out.push({
-		...base,
-		field,
-		reason: result.reason ?? "unknown"
-	});
-}
-/**
-* Analyze a single static job's dynamic-value functions (context(s), env,
-* concurrencyGroup) for impurity. Returns one warning per impure function.
-*/
-function analyzeJobPurity(job, workflowName, sourceFile) {
-	const out = [];
-	const base = {
-		workflowName,
-		sourceFile,
-		jobName: job.name
-	};
-	const contextRefs = job.contexts ?? (job.context !== void 0 ? [job.context] : void 0);
-	if (contextRefs) for (const ref of contextRefs) pushIfImpure(out, ref, "context", base);
-	pushIfImpure(out, job.env, "env", base);
-	pushIfImpure(out, job.concurrencyGroup, "concurrencyGroup", base);
-	return out;
-}
-/**
-* Walk every workflow's static jobs and collect impurity warnings. Function-typed
-* jobs (dynamic job generators) are skipped — their purity is analyzed at dispatch.
-*/
-function collectWorkflowPurityWarnings(workflows) {
-	const out = [];
-	for (const { workflow, source } of workflows) for (const job of workflow.jobs) {
-		if (typeof job === "function") continue;
-		out.push(...analyzeJobPurity(job, workflow.name, source.file));
-	}
-	return out;
-}
-//#endregion
-export { DynamicValueField, analyzeJobPurity, collectWorkflowPurityWarnings };
-
-//# sourceMappingURL=purity-diagnostics.js.map