@kici-dev/compiler 0.1.26 → 0.2.0

package/dist/local-executor/output-streamer.js

@@ -1,168 +0,0 @@
-import "../rolldown-runtime-ClRpJifh.js";
-import pc from "picocolors";
-import { logger } from "@kici-dev/core";
-//#region src/local-executor/output-streamer.ts
-/**
-* Output formatting for local execution: tree summary, JSON, JUnit XML.
-*
-* - displayLocalSummary: tree-format summary with per-step timing
-* - formatLocalJsonResult: structured JSON output
-* - formatLocalJunitResult: JUnit XML for CI integration
-*/
-/**
-* Display tree-format execution summary to the console.
-*
-* Shows per-workflow, per-job, per-step timing and status.
-* Matrix values appear in the job name.
-*/
-function displayLocalSummary(results) {
-	const hasFailure = results.some((r) => r.status === "failure");
-	const allSkipped = results.every((r) => r.status === "skipped");
-	logger.info("");
-	logger.info(pc.bold("=== EXECUTION SUMMARY ==="));
-	logger.info("");
-	const overallStatus = hasFailure ? pc.red("FAILED") : allSkipped ? pc.yellow("SKIPPED") : pc.green("SUCCESS");
-	logger.info(`Status: ${overallStatus}`);
-	logger.info("");
-	for (const workflow of results) {
-		logger.info(`Workflow: ${pc.bold(workflow.name)} (${workflow.durationMs}ms)`);
-		for (const job of workflow.jobs) {
-			const jobLabel = formatJobLabel(job);
-			const jobIcon = statusIcon(job.status);
-			logger.info(`  ${jobIcon} ${jobLabel} (${job.durationMs}ms)`);
-			if (job.ruleResults && job.ruleResults.length > 0) for (const rule of job.ruleResults) {
-				const rIcon = rule.passed ? pc.green("[ok]") : pc.red("[fail]");
-				logger.info(pc.gray(`    ${rIcon} rule: ${rule.label}`));
-			}
-			for (const step of job.steps) {
-				const sIcon = step.status === "success" ? pc.green("[ok]") : pc.red("[fail]");
-				logger.info(`    ${sIcon} ${step.name} (${step.durationMs}ms)`);
-				if (step.error) logger.info(pc.red(`      Error: ${step.error.message}`));
-			}
-			if (job.status === "cancelled") logger.info(pc.yellow("    (cancelled)"));
-			else if (job.status === "skipped") logger.info(pc.yellow("    (skipped: dependency failed)"));
-		}
-		logger.info("");
-	}
-	const totalDuration = results.reduce((sum, r) => sum + r.durationMs, 0);
-	logger.info(pc.gray(`Total duration: ${totalDuration}ms`));
-}
-/**
-* Format job label including matrix values if present.
-* e.g., "test (node18, ubuntu)" or just "lint"
-*/
-function formatJobLabel(job) {
-	if (job.matrixValues && Object.keys(job.matrixValues).length > 0) {
-		const vals = Object.values(job.matrixValues).join(", ");
-		if (job.name.includes("(")) return job.name;
-		return `${job.name} (${vals})`;
-	}
-	return job.name;
-}
-/**
-* Get colored status icon for a job status.
-*/
-function statusIcon(status) {
-	switch (status) {
-		case "success": return pc.green("[ok]");
-		case "failure": return pc.red("[fail]");
-		case "skipped": return pc.yellow("[skip]");
-		case "cancelled": return pc.yellow("[cancel]");
-		default: return pc.gray("[?]");
-	}
-}
-/**
-* Format workflow execution results as structured JSON.
-*
-* @returns JSON string with 2-space indentation.
-*/
-function formatLocalJsonResult(results) {
-	const passed = results.filter((r) => r.status === "success").length;
-	const failed = results.filter((r) => r.status === "failure").length;
-	const skipped = results.filter((r) => r.status === "skipped").length;
-	const totalDurationMs = results.reduce((sum, r) => sum + r.durationMs, 0);
-	const output = {
-		workflows: results.map((wf) => ({
-			name: wf.name,
-			status: wf.status,
-			durationMs: wf.durationMs,
-			jobs: wf.jobs.map((job) => ({
-				name: job.name,
-				status: job.status,
-				durationMs: job.durationMs,
-				...job.matrixValues && Object.keys(job.matrixValues).length > 0 && { matrixValues: job.matrixValues },
-				steps: job.steps.map((step) => ({
-					name: step.name,
-					status: step.status,
-					durationMs: step.durationMs,
-					...step.error && { error: step.error.message },
-					...step.checkOutcome && { checkOutcome: step.checkOutcome },
-					...step.driftSummary && { driftSummary: step.driftSummary }
-				})),
-				...job.ruleResults && job.ruleResults.length > 0 && { ruleResults: job.ruleResults.map((r) => ({
-					label: r.label,
-					passed: r.passed,
-					durationMs: r.durationMs
-				})) },
-				...job.error && { error: job.error.message }
-			}))
-		})),
-		summary: {
-			totalWorkflows: results.length,
-			passed,
-			failed,
-			skipped,
-			totalDurationMs
-		}
-	};
-	return JSON.stringify(output, null, 2);
-}
-/**
-* Format workflow execution results as JUnit XML.
-*
-* Each workflow maps to a <testsuite>, each job maps to a <testcase>.
-* Failed jobs include failure message. Skipped/cancelled jobs use <skipped />.
-*
-* @returns Valid JUnit XML string.
-*/
-function formatLocalJunitResult(results) {
-	const totalTests = results.reduce((sum, r) => sum + r.jobs.length, 0);
-	const totalFailures = results.reduce((sum, r) => sum + r.jobs.filter((j) => j.status === "failure").length, 0);
-	const totalTimeSeconds = results.reduce((sum, r) => sum + r.durationMs / 1e3, 0);
-	const lines = [];
-	lines.push("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
-	lines.push(`<testsuites name="kici-local" tests="${totalTests}" failures="${totalFailures}" time="${totalTimeSeconds.toFixed(3)}">`);
-	for (const workflow of results) {
-		const suiteTests = workflow.jobs.length;
-		const suiteFailures = workflow.jobs.filter((j) => j.status === "failure").length;
-		const suiteTimeSeconds = workflow.durationMs / 1e3;
-		lines.push(`  <testsuite name="${escapeXml(workflow.name)}" tests="${suiteTests}" failures="${suiteFailures}" time="${suiteTimeSeconds.toFixed(3)}">`);
-		for (const job of workflow.jobs) {
-			const jobTimeSeconds = job.durationMs / 1e3;
-			const jobName = formatJobLabel(job);
-			if (job.status === "failure") {
-				const errorMsg = job.error?.message ?? "Job failed";
-				lines.push(`    <testcase name="${escapeXml(jobName)}" classname="${escapeXml(workflow.name)}" time="${jobTimeSeconds.toFixed(3)}">`);
-				lines.push(`      <failure message="${escapeXml(errorMsg)}">${escapeXml(errorMsg)}</failure>`);
-				lines.push("    </testcase>");
-			} else if (job.status === "skipped" || job.status === "cancelled") {
-				lines.push(`    <testcase name="${escapeXml(jobName)}" classname="${escapeXml(workflow.name)}" time="${jobTimeSeconds.toFixed(3)}">`);
-				lines.push("      <skipped />");
-				lines.push("    </testcase>");
-			} else lines.push(`    <testcase name="${escapeXml(jobName)}" classname="${escapeXml(workflow.name)}" time="${jobTimeSeconds.toFixed(3)}" />`);
-		}
-		lines.push("  </testsuite>");
-	}
-	lines.push("</testsuites>");
-	return lines.join("\n");
-}
-/**
-* Escape special XML characters in a string.
-*/
-function escapeXml(text) {
-	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-//#endregion
-export { displayLocalSummary, formatLocalJsonResult, formatLocalJunitResult };
-
-//# sourceMappingURL=output-streamer.js.map

package/dist/local-executor/payload-generator.d.ts

@@ -1,16 +0,0 @@
-import type { SimulatedEvent } from '@kici-dev/engine';
-import type { RunLocalOptions } from './types.js';
-/**
- * Generate a SimulatedEvent from git state and CLI overrides.
- *
- * For push events: detects branch, SHA, and changed files from git.
- * For PR events: uses current branch as source, 'main' (or --branch) as target.
- * If --payload flag is provided, delegates to existing buildEventPayload.
- * Falls back gracefully when not in a git repository.
- *
- * @param event - Event argument string (e.g. 'push', 'pr:open')
- * @param options - CLI options with override fields
- * @returns Generated SimulatedEvent
- */
-export declare function generateEventPayload(event: string, options: RunLocalOptions): Promise<SimulatedEvent>;
-//# sourceMappingURL=payload-generator.d.ts.map

package/dist/local-executor/payload-generator.js

@@ -1,138 +0,0 @@
-import "../rolldown-runtime-ClRpJifh.js";
-import { parseEventArg } from "../test-runner/event-types.js";
-import { buildEventPayload } from "../test-runner/payload-builder.js";
-import { execSync } from "node:child_process";
-//#region src/local-executor/payload-generator.ts
-const ZERO_SHA = "0000000000000000000000000000000000000000";
-/**
-* Run a git command and return trimmed output, or null on failure.
-*/
-function git(cmd) {
-	try {
-		return execSync(cmd, {
-			encoding: "utf-8",
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			]
-		}).trim();
-	} catch {
-		return null;
-	}
-}
-/**
-* Detect current git branch name.
-*/
-function detectBranch() {
-	return git("git rev-parse --abbrev-ref HEAD");
-}
-/**
-* Detect current git HEAD SHA.
-*/
-function detectSha() {
-	return git("git rev-parse HEAD");
-}
-/**
-* Detect changed files from git diff (unstaged + staged, deduplicated).
-*/
-function detectChangedFiles() {
-	const unstaged = git("git diff --name-only HEAD");
-	const staged = git("git diff --name-only --cached");
-	const files = /* @__PURE__ */ new Set();
-	if (unstaged) for (const f of unstaged.split("\n").filter(Boolean)) files.add(f);
-	if (staged) for (const f of staged.split("\n").filter(Boolean)) files.add(f);
-	return [...files];
-}
-/**
-* Generate a SimulatedEvent from git state and CLI overrides.
-*
-* For push events: detects branch, SHA, and changed files from git.
-* For PR events: uses current branch as source, 'main' (or --branch) as target.
-* If --payload flag is provided, delegates to existing buildEventPayload.
-* Falls back gracefully when not in a git repository.
-*
-* @param event - Event argument string (e.g. 'push', 'pr:open')
-* @param options - CLI options with override fields
-* @returns Generated SimulatedEvent
-*/
-async function generateEventPayload(event, options) {
-	if (options.payload) return buildEventPayload(event, {
-		payload: options.payload,
-		branch: options.branch,
-		sha: options.sha,
-		files: options.files
-	});
-	const eventType = parseEventArg(event);
-	const detectedBranch = detectBranch() ?? "main";
-	const detectedSha = detectSha() ?? ZERO_SHA;
-	const changedFiles = options.files && options.files.length > 0 ? options.files : detectChangedFiles();
-	const branch = options.branch ?? detectedBranch;
-	const sha = options.sha ?? detectedSha;
-	switch (eventType.type) {
-		case "push": return {
-			type: "push",
-			payload: {
-				ref: `refs/heads/${branch}`,
-				after: sha,
-				before: ZERO_SHA,
-				head_commit: {
-					id: sha,
-					message: "local execution"
-				},
-				repository: { default_branch: "main" }
-			},
-			targetBranch: branch,
-			changedFiles
-		};
-		case "pull_request": {
-			const action = "action" in eventType ? eventType.action : "opened";
-			const targetBranch = options.branch ?? "main";
-			const sourceBranch = detectedBranch;
-			return {
-				type: "pull_request",
-				action,
-				payload: {
-					action,
-					number: 1,
-					pull_request: {
-						number: 1,
-						head: {
-							ref: sourceBranch,
-							sha
-						},
-						base: { ref: targetBranch }
-					},
-					repository: { default_branch: "main" }
-				},
-				targetBranch,
-				sourceBranch,
-				changedFiles
-			};
-		}
-		case "tag": return {
-			type: "tag",
-			payload: {
-				ref: `refs/tags/${branch}`,
-				after: sha,
-				repository: { default_branch: "main" }
-			},
-			targetBranch: branch,
-			changedFiles
-		};
-		default: {
-			const action = "action" in eventType ? eventType.action : void 0;
-			return {
-				type: eventType.type,
-				action,
-				payload: { repository: { default_branch: "main" } },
-				targetBranch: branch,
-				changedFiles
-			};
-		}
-	}
-}
-//#endregion
-export { generateEventPayload };
-
-//# sourceMappingURL=payload-generator.js.map

package/dist/local-executor/picker.d.ts

@@ -1,33 +0,0 @@
-/**
- * Interactive workflow picker for `kici run local --pick`.
- *
- * Lists every workflow with a summary of its triggers, lets the user pick one
- * (and a specific trigger when there are multiple), and returns the derived
- * event arg plus workflow name. The caller feeds these back into the standard
- * executeLocal pipeline so the run remains consistent with normal trigger
- * matching.
- */
-import type { Workflow } from '@kici-dev/sdk';
-export declare class PickerCancelledError extends Error {
-    constructor(message: string);
-}
-export interface PickerOptions {
-    /**
-     * Optional event-arg filter. When set, restrict the workflow list to those
-     * with at least one trigger whose derived event arg shares the same family
-     * (e.g. `filterEvent: 'pr'` keeps any workflow with a `pr:*` trigger).
-     */
-    filterEvent?: string;
-}
-export interface PickerResult {
-    event: string;
-    workflow: string;
-}
-/**
- * Run the interactive picker.
- *
- * @throws PickerCancelledError when stdin is not a TTY, when no eligible
- *   workflows exist, or when the user aborts one of the prompts.
- */
-export declare function runPicker(workflows: Workflow[], opts?: PickerOptions): Promise<PickerResult>;
-//# sourceMappingURL=picker.d.ts.map

package/dist/local-executor/picker.js

@@ -1,109 +0,0 @@
-import "../rolldown-runtime-ClRpJifh.js";
-import { transformTriggers } from "../lockfile/generator.js";
-import { parseEventArg, triggerSummary, triggerToEventArg } from "../test-runner/event-types.js";
-import pc from "picocolors";
-import { logger } from "@kici-dev/core";
-import { select } from "@inquirer/prompts";
-//#region src/local-executor/picker.ts
-/**
-* Interactive workflow picker for `kici run local --pick`.
-*
-* Lists every workflow with a summary of its triggers, lets the user pick one
-* (and a specific trigger when there are multiple), and returns the derived
-* event arg plus workflow name. The caller feeds these back into the standard
-* executeLocal pipeline so the run remains consistent with normal trigger
-* matching.
-*/
-var PickerCancelledError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "PickerCancelledError";
-	}
-};
-function workflowEntries(workflows) {
-	return workflows.map((w) => ({
-		name: w.name,
-		triggers: transformTriggers(w.on)
-	}));
-}
-function eventFamily(arg) {
-	return arg.toLowerCase().split(":")[0] ?? "";
-}
-function filterFamily(arg) {
-	try {
-		const parsed = parseEventArg(arg);
-		if (parsed.type === "pull_request") return "pr";
-		return parsed.type;
-	} catch {
-		return eventFamily(arg);
-	}
-}
-function triggerFamilies(trigger) {
-	const head = eventFamily(triggerToEventArg(trigger));
-	if (trigger._type === "generic_webhook") return ["webhook", "generic_webhook"];
-	if (trigger._type === "workflow_complete") return [head, "lifecycle"];
-	if (trigger._type === "job_complete") return [head, "lifecycle"];
-	return [head];
-}
-function isStdinTty() {
-	return Boolean(process.stdin.isTTY);
-}
-function printWorkflowList(entries) {
-	logger.info(pc.bold("Available workflows:"));
-	for (const entry of entries) {
-		const summaries = entry.triggers.map(triggerSummary).join(", ") || "(no triggers)";
-		logger.info(`  ${pc.cyan(entry.name)} — ${summaries}`);
-	}
-}
-/**
-* Run the interactive picker.
-*
-* @throws PickerCancelledError when stdin is not a TTY, when no eligible
-*   workflows exist, or when the user aborts one of the prompts.
-*/
-async function runPicker(workflows, opts = {}) {
-	let entries = workflowEntries(workflows).filter((e) => e.triggers.length > 0);
-	if (opts.filterEvent) {
-		const family = filterFamily(opts.filterEvent);
-		entries = entries.filter((e) => e.triggers.some((t) => triggerFamilies(t).includes(family)));
-	}
-	if (entries.length === 0) throw new PickerCancelledError(opts.filterEvent ? `No workflows with triggers matching "${opts.filterEvent}". Remove the event arg or pass a different one.` : "No workflows with triggers available to pick.");
-	if (!isStdinTty()) {
-		printWorkflowList(entries);
-		throw new PickerCancelledError("Non-interactive environment: --pick requires a TTY. Pass --workflow <name> plus an event arg instead.");
-	}
-	let chosenWorkflow;
-	try {
-		const name = await select({
-			message: "Select a workflow to run",
-			choices: entries.map((e) => ({
-				name: `${e.name} — ${e.triggers.map(triggerSummary).join(", ")}`,
-				value: e.name
-			}))
-		});
-		chosenWorkflow = entries.find((e) => e.name === name);
-	} catch (err) {
-		throw new PickerCancelledError(`Picker cancelled: ${err instanceof Error ? err.message : String(err)}`);
-	}
-	let trigger;
-	if (chosenWorkflow.triggers.length === 1) trigger = chosenWorkflow.triggers[0];
-	else try {
-		trigger = await select({
-			message: `Select a trigger for "${chosenWorkflow.name}"`,
-			choices: chosenWorkflow.triggers.map((t) => ({
-				name: triggerSummary(t),
-				value: t
-			}))
-		});
-	} catch (err) {
-		throw new PickerCancelledError(`Picker cancelled: ${err instanceof Error ? err.message : String(err)}`);
-	}
-	return {
-		event: triggerToEventArg(trigger),
-		workflow: chosenWorkflow.name
-	};
-}
-//#endregion
-export { PickerCancelledError, runPicker };
-
-//# sourceMappingURL=picker.js.map

package/dist/local-executor/to-event-payload.d.ts

@@ -1,16 +0,0 @@
-import type { SimulatedEvent } from '@kici-dev/engine';
-import type { EventPayload } from '@kici-dev/sdk';
-/**
- * Map a {@link SimulatedEvent} into the normalized SDK {@link EventPayload}
- * envelope that every user-authored dynamic function (dynamic job generators,
- * `concurrency.group()`) receives as its `event` argument.
- *
- * `SimulatedEvent` already carries the normalized fields (`type`, `action`,
- * `targetBranch`, …) alongside the raw provider body under `payload`, so the
- * single cast at this boundary is a deliberate type assertion over a
- * structurally-identical value: it asserts the discriminated-union view
- * without reshaping anything. Raw provider fields stay nested under
- * `payload.<field>`; normalized fields live at the top level.
- */
-export declare function toEventPayload(event: SimulatedEvent): EventPayload;
-//# sourceMappingURL=to-event-payload.d.ts.map

package/dist/local-executor/to-event-payload.js

@@ -1,21 +0,0 @@
-import "../rolldown-runtime-ClRpJifh.js";
-//#region src/local-executor/to-event-payload.ts
-/**
-* Map a {@link SimulatedEvent} into the normalized SDK {@link EventPayload}
-* envelope that every user-authored dynamic function (dynamic job generators,
-* `concurrency.group()`) receives as its `event` argument.
-*
-* `SimulatedEvent` already carries the normalized fields (`type`, `action`,
-* `targetBranch`, …) alongside the raw provider body under `payload`, so the
-* single cast at this boundary is a deliberate type assertion over a
-* structurally-identical value: it asserts the discriminated-union view
-* without reshaping anything. Raw provider fields stay nested under
-* `payload.<field>`; normalized fields live at the top level.
-*/
-function toEventPayload(event) {
-	return event;
-}
-//#endregion
-export { toEventPayload };
-
-//# sourceMappingURL=to-event-payload.js.map

package/dist/local-executor/types.d.ts

@@ -1,93 +0,0 @@
-import type { MatrixValues, Job } from '@kici-dev/sdk';
-import type { CheckMode } from '@kici-dev/engine';
-import type { JobResult } from '../test-runner/job-executor.js';
-/**
- * All CLI flags for `kici run local`.
- */
-export interface RunLocalOptions {
-    /** Positional arg: event type (e.g. 'push', 'pr:open'). Optional when `pick` is true. */
-    event?: string;
-    /** --pick / -p: interactive workflow picker (derives event arg from the selected trigger) */
-    pick?: boolean;
-    /** --workflow filter: run only matching workflow */
-    workflow?: string;
-    /** --job filter: run only matching job (includes transitive deps) */
-    job?: string;
-    /** --branch override: override detected git branch */
-    branch?: string;
-    /** --sha override: override detected git SHA */
-    sha?: string;
-    /** --payload path: explicit event payload JSON file */
-    payload?: string;
-    /** --concurrency: max parallel jobs (default: os.availableParallelism()) */
-    concurrency?: number;
-    /** --keep-going: continue after job failure (default: false) */
-    keepGoing?: boolean;
-    /** --container: use Podman isolation (default: false) */
-    container?: boolean;
-    /** --env KEY=VALUE overrides (repeatable) */
-    env?: string[];
-    /** --input KEY=VALUE typed workflow-dispatch inputs (repeatable) */
-    inputs?: string[];
-    /** --quiet: minimal output */
-    quiet?: boolean;
-    /** --json: JSON output format */
-    json?: boolean;
-    /** --junit: path for JUnit XML report */
-    junit?: string;
-    /** --files: override changed file paths (repeatable) */
-    files?: string[];
-    /** --debug: verbose debug output */
-    debug?: boolean;
-    /** --kici-dir: path to .kici directory */
-    kiciDir?: string;
-    /** --in-place: run against the real working directory instead of an isolated tmp checkout */
-    inPlace?: boolean;
-    /** --keep: always retain the isolated tmp checkout (default: keep only on failure) */
-    keep?: boolean;
-    /**
-     * Run mode resolved from --check / --fail-on-drift. Threads to the agent step
-     * loop: `apply` (default) converges, `check` previews drift, `check-fail-on-drift`
-     * previews drift and fails the run if any step reports drift. Defaults to `apply`.
-     */
-    checkMode?: CheckMode;
-}
-/**
- * A job after matrix expansion with resolved values.
- */
-export interface ResolvedJob {
-    /** Original job definition */
-    job: Job;
-    /** Expanded name (e.g. 'test (node-18, linux)') */
-    expandedName: string;
-    /** Matrix values for this expansion (empty object if no matrix) */
-    matrixValues: MatrixValues;
-    /** Resolved dependency names (expanded names of upstream jobs) */
-    resolvedNeeds: string[];
-}
-/**
- * Result for a single job execution in local mode.
- * Extends JobResult with matrix context and cancellation.
- */
-export interface LocalJobResult extends Omit<JobResult, 'status'> {
-    /** Job completion status (adds 'cancelled' to base JobResult statuses) */
-    status: 'success' | 'failure' | 'skipped' | 'cancelled';
-    /** Matrix values if this job was part of a matrix expansion */
-    matrixValues?: MatrixValues;
-    /** Whether this job was cancelled (e.g. by AbortSignal) */
-    cancelled?: boolean;
-}
-/**
- * Result of executing a workflow locally.
- */
-export interface WorkflowExecutionResult {
-    /** Workflow name */
-    name: string;
-    /** Overall status */
-    status: 'success' | 'failure' | 'skipped';
-    /** Individual job results */
-    jobs: LocalJobResult[];
-    /** Total execution duration in milliseconds */
-    durationMs: number;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/local-executor/types.js

@@ -1,2 +0,0 @@
-import "../rolldown-runtime-ClRpJifh.js";
-export {};

package/dist/local-executor/workflow-lock.d.ts

@@ -1,82 +0,0 @@
-/**
- * Workflow-level concurrency lock for `kici run local`.
- *
- * Enforces the SDK-declared `workflow.concurrency` block across concurrent
- * `kici run local` invocations on the same machine and user. Mirrors the
- * orchestrator semantics:
- *
- * - `group` callback evaluated against the simulated event, fails closed
- *   on throw via {@link ConcurrencyKeyEvaluationError} (the caller aborts the
- *   run rather than fall back to the workflow name).
- * - `cancelInProgress: true` interrupts the holder via SIGTERM, escalates
- *   to SIGKILL after `KICI_LOCAL_LOCK_KILL_GRACE_MS` (default 30000ms).
- * - Otherwise contention waits in FIFO order on the underlying file lock.
- * - Stale locks (holder PID gone per `process.kill(pid, 0)`) are reclaimed.
- *
- * The lock primitive is `proper-lockfile` (atomic `mkdir` of a `.lock`
- * directory next to the metadata sidecar). The lock identity is
- * `sha256(workflowName + '\0' + groupKey)`, scoped to a per-user lock dir
- * (`$XDG_RUNTIME_DIR/kici-local-locks/` on Linux, else
- * `os.tmpdir()/kici-local-locks-<uid>/`).
- */
-import type { Workflow } from '@kici-dev/sdk';
-import type { SimulatedEvent } from '@kici-dev/engine';
-/** Sidecar metadata persisted next to the lock dir for diagnostics + reclamation. */
-export interface LockHolderMetadata {
-    pid: number;
-    startedAt: string;
-    workflowName: string;
-    groupKey: string;
-    hostname: string;
-}
-/** Handle returned by {@link acquireWorkflowLock}. Caller MUST invoke `release()` in a `finally`. */
-export interface WorkflowLockHandle {
-    release(): Promise<void>;
-}
-export interface AcquireWorkflowLockOptions {
-    workflowName: string;
-    workflow: Workflow;
-    /** The simulated event mapped to the normalized envelope passed as `groupCtx.event`. */
-    event: SimulatedEvent;
-    /** Branch derived from the simulated event for `groupCtx.branch`. */
-    branch: string;
-    debug?: boolean;
-}
-/**
- * Thrown when the workflow's `concurrency.group()` function throws or rejects.
- * The caller surfaces this as a workflow failure (it does NOT fall back to the
- * workflow name as a key — fail-closed is the documented contract).
- */
-export declare class ConcurrencyKeyEvaluationError extends Error {
-    readonly cause?: Error;
-    readonly workflowName: string;
-    constructor(workflowName: string, cause: unknown);
-}
-/** Module-level stub for `process.kill`, swappable by tests via {@link __setKillFnForTesting}. */
-type KillFn = (pid: number, signal?: string | number) => boolean;
-/** Test-only: swap the kill function so unit tests don't actually signal real PIDs. */
-export declare function __setKillFnForTesting(fn?: KillFn): void;
-/**
- * Resolve the per-user lock directory. Prefers `$XDG_RUNTIME_DIR/kici-local-locks/`
- * (Linux per-user runtime dir, mode 0700), else `os.tmpdir()/kici-local-locks-<uid>/`.
- *
- * Created with `mode: 0o700`. Falls through silently to the tmpdir form on EACCES/EROFS.
- */
-export declare function resolveLockDir(): Promise<string>;
-/**
- * Evaluate the workflow's concurrency `group` function against the simulated event.
- *
- * Returns `null` when the workflow has no `concurrency` block. Throws
- * {@link ConcurrencyKeyEvaluationError} when the group function throws or rejects.
- */
-export declare function resolveConcurrencyKey(workflow: Workflow, event: SimulatedEvent, branch: string): Promise<string | null>;
-/**
- * Acquire the workflow-level concurrency lock for a `kici run local` invocation.
- *
- * Returns `null` immediately when the workflow has no `concurrency` block (no
- * locking is performed). Otherwise blocks until the lock is held, then returns
- * a handle whose `release()` MUST be invoked in a `finally`.
- */
-export declare function acquireWorkflowLock(opts: AcquireWorkflowLockOptions): Promise<WorkflowLockHandle | null>;
-export {};
-//# sourceMappingURL=workflow-lock.d.ts.map