@keystrokehq/cli 0.0.1

package/dist/schema-17qMfNyI.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+import { z } from "zod";
+//#region ../../packages/shared-types/src/credentials/models/schema.ts
+const CredentialScopeValues = [
+	"organization",
+	"user",
+	"project"
+];
+const CredentialScopeSchema = z.enum(CredentialScopeValues);
+const ConnectionStatusSchema = z.enum([
+	"connected",
+	"broken",
+	"needs_reconnect",
+	"disconnected"
+]);
+//#endregion
+export { CredentialScopeSchema as n, CredentialScopeValues as r, ConnectionStatusSchema as t };

package/dist/schema-display-CgmeKigW.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+//#region src/lib/schema-display.ts
+/**
+* Returns true when the schema is the fallback "unknown" sentinel emitted
+* by zodSchemaToJsonSchema when a schema cannot be converted.
+*/
+function isUnknownSchema(schema) {
+	return schema != null && schema.type === "unknown";
+}
+/**
+* Generates a minimal placeholder JSON object for a given JSON Schema.
+* Walks `properties` recursively to produce sensible default values so the
+* user has a copy-pasteable `--input` example.
+*
+* Examples:
+*   { type: "number" }           => 0
+*   { type: "string" }           => ""
+*   { type: "boolean" }          => false
+*   { type: "array" }            => []
+*   { type: "object", properties: { x: { type: "number" } } } => { x: 0 }
+*   { enum: ["a", "b"] }         => "a"
+*/
+function generateExampleJson(schema) {
+	if (schema == null || typeof schema !== "object") return null;
+	return generateValue(schema);
+}
+function generateValue(schema) {
+	if (Array.isArray(schema.enum) && schema.enum.length > 0) return schema.enum[0];
+	switch (Array.isArray(schema.type) ? schema.type[0] : schema.type) {
+		case "object": {
+			if (!schema.properties) return {};
+			const result = {};
+			for (const [key, propSchema] of Object.entries(schema.properties)) result[key] = generateValue(propSchema);
+			return result;
+		}
+		case "array": return [];
+		case "string": return "";
+		case "number":
+		case "integer": return 0;
+		case "boolean": return false;
+		case "null": return null;
+		default: return null;
+	}
+}
+/**
+* Validates input against a JSON Schema by checking required fields.
+* This is a lightweight structural check that works without `z.fromJSONSchema`.
+* Only checks top-level required fields — sufficient for the "did you forget
+* to provide input?" use case.
+*/
+function validateRequiredFields(input, schema) {
+	if (schema == null || typeof schema !== "object") return {
+		valid: true,
+		missingRequired: []
+	};
+	const missingRequired = (Array.isArray(schema.required) ? schema.required : []).filter((field) => !(field in input));
+	return {
+		valid: missingRequired.length === 0,
+		missingRequired
+	};
+}
+/**
+* Returns a short human-readable type hint from a JSON Schema field definition.
+* e.g. { type: "number" } → "number"
+*      { type: "string", enum: ["a","b"] } → "string: a | b"
+*      { type: ["string", "null"] } → "string | null"
+*      { $ref: "..." } → "object"
+*/
+function resolveTypeHint(fieldSchema) {
+	if (!fieldSchema) return "any";
+	if (Array.isArray(fieldSchema.enum) && fieldSchema.enum.length > 0) return `${typeof fieldSchema.type === "string" ? `${fieldSchema.type}: ` : ""}${fieldSchema.enum.map(String).join(" | ")}`;
+	if (Array.isArray(fieldSchema.type)) return fieldSchema.type.join(" | ");
+	if (typeof fieldSchema.type === "string" && fieldSchema.type !== "unknown") return fieldSchema.type;
+	if (fieldSchema.$ref) return "object";
+	return "any";
+}
+/**
+* Formats a missing-required-fields error into a descriptive CLI message.
+*/
+function formatMissingInputError(workflowName, missingFields, inputSchema) {
+	const lines = [];
+	lines.push(`Missing required input for workflow "${workflowName}"\n`);
+	if (inputSchema == null || typeof inputSchema !== "object") {
+		lines.push("  (input schema unavailable)\n");
+		lines.push(`  $ keystroke workflows try-deploy "${workflowName}" --input '{}'`);
+		return lines.join("\n");
+	}
+	const properties = inputSchema.properties && typeof inputSchema.properties === "object" ? inputSchema.properties : {};
+	for (const field of missingFields) {
+		const fieldSchema = properties[field];
+		const typeHint = resolveTypeHint(fieldSchema);
+		lines.push(`  ${field} (${typeHint}): Required`);
+	}
+	lines.push("");
+	const exampleValue = generateExampleJson(inputSchema);
+	const exampleJson = JSON.stringify(exampleValue);
+	lines.push("Expected input:");
+	lines.push(`  $ keystroke workflows try-deploy "${workflowName}" --input '${exampleJson}'`);
+	return lines.join("\n");
+}
+/**
+* Formats validation issues into a descriptive CLI message.
+*
+* Example output:
+*
+*   Invalid input for workflow "Addition"
+*
+*     num: Required
+*     num2: Required
+*
+*   Expected input:
+*     $ keystroke workflows try-deploy "Addition" --input '{"num":0,"num2":0}'
+*/
+function formatValidationError(workflowName, issues, inputSchema) {
+	const lines = [];
+	lines.push(`Invalid input for workflow "${workflowName}"\n`);
+	for (const issue of issues) {
+		const fieldPath = issue.path.length === 0 || issue.path.length === 1 && issue.path[0] === "" ? "(root)" : issue.path.join(".");
+		lines.push(`  ${fieldPath}: ${issue.message}`);
+	}
+	lines.push("");
+	const exampleValue = inputSchema != null && typeof inputSchema === "object" ? generateExampleJson(inputSchema) : null;
+	const exampleJson = JSON.stringify(exampleValue);
+	lines.push(`Expected input:`);
+	lines.push(`  $ keystroke workflows try-deploy "${workflowName}" --input '${exampleJson}'`);
+	return lines.join("\n");
+}
+//#endregion
+export { validateRequiredFields as a, resolveTypeHint as i, formatValidationError as n, isUnknownSchema as r, formatMissingInputError as t };

package/dist/schemas-CDib1RhE.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+import { A as idNoSpacesString, C as CredentialSetManifestSchema, I as trimmedNonEmptyString, L as trimmedNonEmptyStringUnbounded, N as optionalDescriptionString, O as createStructuralSchema, V as SHA256HashSchema, f as TriggerTypeSchema, j as jsonSchemaObject, k as descriptionString, s as ExecutionIdentityPolicySchema, t as DurationSchema } from "./schedule-BXx3uXwr.mjs";
+import { z } from "zod";
+//#region ../../packages/workflow-core/src/trigger/schemas.ts
+const credentialSetInstanceSchema = createStructuralSchema([
+	"id",
+	"auth",
+	"needsResolve"
+], "a CredentialSet instance");
+const TriggerModeDefaultSchema = z.enum(["managed", "subscribable"]);
+const TriggerCallbackPresenceSchema = z.object({
+	filter: z.boolean(),
+	idempotencyKey: z.boolean(),
+	poll: z.boolean().optional(),
+	transformAllowed: z.boolean(),
+	verify: z.boolean().optional()
+});
+const TriggerRuntimeDescriptorSchema = z.object({ callbacks: TriggerCallbackPresenceSchema });
+const TriggerManifestSchema = z.object({
+	manifestVersion: z.literal(1),
+	type: z.literal("trigger"),
+	triggerType: TriggerTypeSchema,
+	name: trimmedNonEmptyString("Trigger name"),
+	description: descriptionString("Trigger description"),
+	enabled: z.boolean(),
+	modeDefault: TriggerModeDefaultSchema,
+	executionIdentityPolicy: ExecutionIdentityPolicySchema.optional(),
+	credentialSets: z.array(CredentialSetManifestSchema).optional(),
+	runtime: TriggerRuntimeDescriptorSchema
+});
+const triggerBaseConfigSchema = z.object({
+	credentialSets: z.array(credentialSetInstanceSchema).optional(),
+	description: descriptionString("Trigger description"),
+	enabled: z.boolean().default(true),
+	executionIdentityPolicy: ExecutionIdentityPolicySchema.optional(),
+	modeDefault: TriggerModeDefaultSchema.default("managed"),
+	name: trimmedNonEmptyString("Trigger name")
+});
+//#endregion
+//#region ../../packages/workflow-core/src/task/schemas.ts
+const agentInstanceSchema = createStructuralSchema([
+	"id",
+	"name",
+	"systemPrompt",
+	"model",
+	"input",
+	"output",
+	"workflowSafeReference"
+], "an Agent instance");
+const triggerInstanceSchema = createStructuralSchema([
+	"isTrigger",
+	"name",
+	"description",
+	"enabled"
+], "a trigger instance (use cronTrigger(), pollingTrigger(), or webhookTrigger())");
+const taskLifecycleSchema = z.object({
+	maxExecutions: z.number().int().positive().optional(),
+	expiresAt: z.union([z.date(), z.string().datetime()]).optional(),
+	expiresAfter: DurationSchema.optional()
+}).strict();
+z.object({
+	id: idNoSpacesString("Task ID"),
+	name: trimmedNonEmptyString("Task name"),
+	description: optionalDescriptionString("Task description"),
+	agent: agentInstanceSchema,
+	prompt: trimmedNonEmptyStringUnbounded("Task prompt"),
+	triggers: z.array(triggerInstanceSchema).min(1, { message: "At least one trigger is required" }),
+	lifecycle: taskLifecycleSchema.optional(),
+	tags: z.array(z.string()).optional()
+}).strict();
+const WorkflowSafeAgentReferenceSchema = z.object({
+	kind: z.literal("agent"),
+	authoredAgentId: z.string(),
+	displayName: z.string(),
+	runtimeKind: z.enum(["declarative", "runnable"]),
+	inputSchema: jsonSchemaObject.optional(),
+	outputSchema: jsonSchemaObject.optional(),
+	authoredExport: z.object({
+		exportName: z.string().optional(),
+		filePath: z.string().optional()
+	}).optional(),
+	metadata: jsonSchemaObject.optional()
+}).strict();
+const TaskBuildInfoStubSchema = z.object({
+	hash: SHA256HashSchema.optional(),
+	size: z.number().optional(),
+	metadata: jsonSchemaObject.optional()
+}).strict();
+/**
+* Extended trigger manifest schema for tasks.
+* Preserves runtime fields (schedule, timezone, path, method) that the base
+* TriggerManifestSchema strips. Tasks need these for trigger evaluation at runtime.
+*/
+const TaskTriggerManifestSchema = TriggerManifestSchema.extend({
+	runtime: TriggerRuntimeDescriptorSchema.extend({
+		schedule: z.string().optional(),
+		timezone: z.string().optional(),
+		path: z.string().optional(),
+		method: z.string().optional(),
+		input: z.unknown().optional(),
+		payloadMode: z.string().optional()
+	}),
+	/** Static payload for cron triggers */
+	payload: z.unknown().optional()
+});
+const TaskBuildManifestSchema = z.object({
+	manifestVersion: z.literal(1),
+	type: z.literal("task"),
+	id: z.string().min(1),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	agentRef: WorkflowSafeAgentReferenceSchema,
+	prompt: z.string().min(1),
+	triggers: z.array(TaskTriggerManifestSchema),
+	lifecycle: z.object({
+		maxExecutions: z.number().int().positive().optional(),
+		expiresAt: z.string().optional(),
+		expiresAfter: z.string().optional()
+	}).strict().optional(),
+	tags: z.array(z.string()).optional(),
+	buildInfo: TaskBuildInfoStubSchema
+}).strict();
+//#endregion
+export { TriggerRuntimeDescriptorSchema as n, triggerBaseConfigSchema as r, TaskBuildManifestSchema as t };

package/dist/skills-sync.handler-DIy8GR16.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+import { C as CliExitError, t as ui } from "./keystroke.mjs";
+import { i as writeJson, r as isJsonMode } from "./output-DM4b7KgY.mjs";
+import { t as syncKeystrokeAgentSkills } from "./sync-keystroke-agent-skills-Kx_H7UTd.mjs";
+import path from "node:path";
+//#region src/commands/skills/skills-sync.handler.ts
+async function handleSkillsSync(options, _ctx) {
+	const result = await syncKeystrokeAgentSkills(path.resolve(options.path ?? process.cwd()));
+	if (isJsonMode(options)) {
+		if (result.ok) writeJson({
+			ok: true,
+			copied: result.copied
+		});
+		else if (result.reason === "not_installed") writeJson({
+			ok: false,
+			reason: "not_installed"
+		});
+		else writeJson({
+			ok: false,
+			reason: "no_skills_found",
+			packageRoot: result.packageRoot
+		});
+		return;
+	}
+	if (result.ok) {
+		ui.success(`Synced ${result.copied.length} skill(s) to .cursor/skills and .claude/skills: ${result.copied.join(", ")}`);
+		return;
+	}
+	if (result.reason === "not_installed") throw new CliExitError("Could not resolve @keystroke/skills. Add it to devDependencies, run install, then run `keystroke skills sync`.", { exitCode: 1 });
+	ui.warn(`@keystroke/skills is installed at ${result.packageRoot} but no skill directories with SKILL.md were found.`);
+}
+//#endregion
+export { handleSkillsSync };

package/dist/skills.command-CrjI2dN9.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { n as JsonOptionSchema, t as JSON_OPTION_CONFIG } from "./output-DM4b7KgY.mjs";
+import { t as createTypedCommand } from "./commander-DfTVqQ-3.mjs";
+import { z } from "zod";
+//#region src/commands/skills/skills.command.ts
+const SkillsCommandOptionsSchema = JsonOptionSchema.extend({ path: z.string().optional().describe("Project root (default: current directory)") });
+const SKILLS_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	path: {
+		flag: "--path <dir>",
+		description: "Project root (directory containing package.json; default: cwd)"
+	}
+};
+function createSkillsCommand() {
+	const cmd = createTypedCommand({
+		name: "skills",
+		description: "Sync Keystroke agent skills (SKILL.md) from @keystroke/skills",
+		schema: SkillsCommandOptionsSchema,
+		optionsConfig: SKILLS_OPTIONS_CONFIG,
+		loadHandler: async () => (await import("./skills.handler-Bz8bJKql.mjs")).handleSkillsParent,
+		subcommands: [createTypedCommand({
+			name: "sync",
+			description: "Copy installed @keystroke/skills into .cursor/skills and .claude/skills",
+			schema: SkillsCommandOptionsSchema,
+			optionsConfig: SKILLS_OPTIONS_CONFIG,
+			loadHandler: async () => (await import("./skills-sync.handler-DIy8GR16.mjs")).handleSkillsSync
+		})]
+	});
+	cmd.enablePositionalOptions();
+	cmd.passThroughOptions();
+	return cmd;
+}
+//#endregion
+export { createSkillsCommand };

package/dist/skills.handler-Bz8bJKql.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { t as ui } from "./keystroke.mjs";
+//#region src/commands/skills/skills.handler.ts
+async function handleSkillsParent(_options, _ctx) {
+	ui.hint("Run `keystroke skills sync` to copy @keystroke/skills into .cursor/skills and .claude/skills.");
+}
+//#endregion
+export { handleSkillsParent };

package/dist/source-analysis-Cj-ADyu--BJQcFPCG.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+import { d as getMetadataRoot } from "./layout-CbMtQ2tm.mjs";
+import { t as BASE_IGNORE_PATTERNS } from "./metadata-layout-GUYIUo0i-_aG2zjue.mjs";
+import { a as literalString, l as unwrapExpression, n as identifierName, r as isNode } from "./oxc-B3KI3rf_-n9d1hKNq.mjs";
+import { readFile, readdir, rm } from "node:fs/promises";
+import path from "node:path";
+//#region ../../packages/workflow-builder/dist/source-analysis-Cj-ADyu-.mjs
+async function removeAllMetadataArtifacts(outputDir) {
+	await rm(getMetadataRoot(outputDir), {
+		recursive: true,
+		force: true
+	});
+}
+async function removeMetadataArtifacts(outputDir, outputFiles) {
+	for (const outputFile of new Set(outputFiles)) await rm(path.join(outputDir, outputFile), { force: true });
+	await removeEmptyMetadataDirectories(getMetadataRoot(outputDir));
+}
+async function removeEmptyMetadataDirectories(directoryPath) {
+	try {
+		const entries = await readdir(directoryPath, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			await removeEmptyMetadataDirectories(path.join(directoryPath, entry.name));
+		}
+		if ((await readdir(directoryPath, { withFileTypes: true })).length === 0) {
+			await rm(directoryPath, {
+				recursive: true,
+				force: true
+			});
+			return true;
+		}
+	} catch {
+		return false;
+	}
+	return false;
+}
+const DISCOVERY_GLOB = [
+	"**/*.ts",
+	"**/*.tsx",
+	"**/*.mts"
+];
+const DISCOVERY_IGNORE = [...BASE_IGNORE_PATTERNS, "**/dist/**"];
+const WORKFLOW_IMPORT_SOURCES = ["@keystroke/workflow-core"];
+const AGENT_FACTORY_IMPORT_SOURCES = ["@keystroke/integration-ai"];
+const AGENT_FACTORY_NAMES = ["agent"];
+function getLocalModuleSpecifier(moduleSpecifier) {
+	if (!moduleSpecifier) return null;
+	return moduleSpecifier.startsWith(".") ? moduleSpecifier : null;
+}
+async function resolveLocalModulePath(fromFilePath, specifier) {
+	const basePath = path.resolve(path.dirname(fromFilePath), specifier);
+	const candidates = [
+		basePath,
+		`${basePath}.ts`,
+		`${basePath}.tsx`,
+		`${basePath}.mts`,
+		path.join(basePath, "index.ts"),
+		path.join(basePath, "index.tsx"),
+		path.join(basePath, "index.mts")
+	];
+	for (const candidate of candidates) try {
+		await readFile(candidate, "utf-8");
+		return candidate;
+	} catch {}
+	return null;
+}
+function collectWorkflowImportNames(sourceFile) {
+	const names = new Map([
+		["Workflow", "workflow"],
+		["Agent", "agent"],
+		["Task", "task"]
+	]);
+	for (const statement of sourceFile.statements) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const moduleSpecifier = literalString(statement.source);
+		if (!moduleSpecifier || !Array.isArray(statement.specifiers)) continue;
+		if (WORKFLOW_IMPORT_SOURCES.includes(moduleSpecifier)) for (const specifier of statement.specifiers) {
+			if (!isNode(specifier) || specifier.type !== "ImportSpecifier") continue;
+			const importedName = identifierName(specifier.imported);
+			const localName = identifierName(specifier.local);
+			if (!importedName || !localName) continue;
+			if (importedName === "Workflow") names.set(localName, "workflow");
+			else if (importedName === "Agent") names.set(localName, "agent");
+			else if (importedName === "Task") names.set(localName, "task");
+		}
+		if (AGENT_FACTORY_IMPORT_SOURCES.includes(moduleSpecifier)) for (const specifier of statement.specifiers) {
+			if (!isNode(specifier) || specifier.type !== "ImportSpecifier") continue;
+			const importedName = identifierName(specifier.imported);
+			const localName = identifierName(specifier.local);
+			if (!importedName || !localName) continue;
+			if (AGENT_FACTORY_NAMES.includes(importedName)) names.set(localName, "agent");
+		}
+	}
+	return names;
+}
+function collectLocalWorkflowBindings(sourceFile, workflowImportNames) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) for (const declaration of getVariableDeclarators(statement)) {
+		const bindingName = identifierName(declaration.id);
+		if (!bindingName || !isNode(declaration.init)) continue;
+		const exportKind = classifyDiscoverableExpression(declaration.init, workflowImportNames);
+		if (exportKind) bindings.set(bindingName, exportKind);
+	}
+	return bindings;
+}
+function resolveDefaultExportAssignment(expression, filePath, localWorkflowBindings, workflowImportNames) {
+	const exportKind = classifyDiscoverableExpression(expression, workflowImportNames);
+	if (exportKind) return {
+		resolvedFilePath: filePath,
+		localExportName: "default",
+		exportKind
+	};
+	const bindingName = identifierName(expression);
+	const bindingKind = bindingName ? localWorkflowBindings.get(bindingName) : void 0;
+	if (bindingKind) return {
+		resolvedFilePath: filePath,
+		localExportName: "default",
+		exportKind: bindingKind
+	};
+	return null;
+}
+function isExportedVariableStatement(statement) {
+	return statement.type === "ExportNamedDeclaration" && isNode(statement.declaration) && statement.declaration.type === "VariableDeclaration";
+}
+function classifyDiscoverableExpression(expression, workflowImportNames) {
+	const unwrapped = unwrapExpression(expression);
+	if (unwrapped.type === "NewExpression") {
+		const callee = identifierName(unwrapped.callee);
+		return callee ? workflowImportNames.get(callee) ?? null : null;
+	}
+	if (unwrapped.type === "CallExpression") {
+		const callee = identifierName(unwrapped.callee);
+		return callee ? workflowImportNames.get(callee) ?? null : null;
+	}
+	return null;
+}
+function getVariableDeclarators(statement) {
+	const declaration = statement.type === "VariableDeclaration" ? statement : statement.type === "ExportNamedDeclaration" && isNode(statement.declaration) ? statement.declaration : null;
+	if (!declaration || declaration.type !== "VariableDeclaration") return [];
+	return Array.isArray(declaration.declarations) ? declaration.declarations.filter((node) => isNode(node)) : [];
+}
+//#endregion
+export { getLocalModuleSpecifier as a, removeAllMetadataArtifacts as c, resolveDefaultExportAssignment as d, resolveLocalModulePath as f, collectWorkflowImportNames as i, removeEmptyMetadataDirectories as l, DISCOVERY_IGNORE as n, getVariableDeclarators as o, collectLocalWorkflowBindings as r, isExportedVariableStatement as s, DISCOVERY_GLOB as t, removeMetadataArtifacts as u };

package/dist/spinner-progress-DMVwgqO9.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+import { a as originalConsole, c as isTTY, i as logger, o as ANSI, s as style } from "./keystroke.mjs";
+import { writeSync } from "node:fs";
+import { Worker } from "node:worker_threads";
+//#region src/lib/spinner-progress.ts
+/** Match `spinner-worker` (stdout) so `stopAll` clears the same stream as the worker. */
+const SPINNER_OUTPUT_FD = 1;
+const DEFAULT_PHASE_ID = "__default__";
+function formatProgressDuration(ms) {
+	if (ms < 1e3) return `${Math.round(ms)}ms`;
+	return `${(ms / 1e3).toFixed(1)}s`;
+}
+function printCompletedLine(label, elapsed) {
+	const check = style("✓", `${ANSI.bold}${ANSI.green}`);
+	if (elapsed) {
+		const timeStr = style(elapsed, ANSI.dim);
+		originalConsole.info(`  ${check} ${label}  ${timeStr}`);
+		return;
+	}
+	originalConsole.info(`  ${check} ${label}`);
+}
+function printFailedLine(label, elapsed) {
+	const cross = style("✗", `${ANSI.bold}${ANSI.red}`);
+	if (elapsed) {
+		const timeStr = style(elapsed, ANSI.dim);
+		originalConsole.info(`  ${cross} ${label}  ${timeStr}`);
+		return;
+	}
+	originalConsole.info(`  ${cross} ${label}`);
+}
+function printSkippedLine(label) {
+	const dash = style("-", ANSI.dim);
+	originalConsole.info(`  ${dash} ${label}`);
+}
+function createWorker() {
+	if (!isTTY()) return null;
+	try {
+		return new Worker(new URL("./spinner-worker.ts", import.meta.url));
+	} catch {
+		return null;
+	}
+}
+function createSpinnerProgress(logPrefix, options = {}) {
+	const worker = createWorker();
+	const phaseStartTimes = /* @__PURE__ */ new Map();
+	const visiblePhaseIds = /* @__PURE__ */ new Set();
+	const showElapsed = options.showElapsed ?? true;
+	let defaultLabel = "";
+	function addPendingPhase(id, label) {
+		visiblePhaseIds.add(id);
+		worker?.postMessage({
+			type: "addPendingPhase",
+			id,
+			label,
+			showElapsed
+		});
+	}
+	function startPhase(id, label) {
+		visiblePhaseIds.add(id);
+		phaseStartTimes.set(id, Date.now());
+		logger.info(`${logPrefix} → [${id}] ${label}`);
+		worker?.postMessage({
+			type: "addPhase",
+			id,
+			label,
+			showElapsed
+		});
+	}
+	function updatePhase(id, label) {
+		worker?.postMessage({
+			type: "updateLabel",
+			id,
+			label
+		});
+	}
+	function completePhase(id, label, elapsedMs) {
+		const phaseStart = phaseStartTimes.get(id);
+		const elapsed = formatProgressDuration(elapsedMs ?? (phaseStart ? Date.now() - phaseStart : 0));
+		phaseStartTimes.delete(id);
+		visiblePhaseIds.delete(id);
+		logger.info(`${logPrefix} ✓ [${id}] ${label}  ${elapsed}`);
+		if (worker) worker.postMessage({
+			type: "completePhase",
+			id,
+			label,
+			elapsed,
+			showElapsed
+		});
+		else printCompletedLine(label, showElapsed ? elapsed : void 0);
+	}
+	function failPhase(id, label, elapsedMs, error) {
+		const phaseStart = phaseStartTimes.get(id);
+		const elapsed = formatProgressDuration(elapsedMs ?? (phaseStart ? Date.now() - phaseStart : 0));
+		phaseStartTimes.delete(id);
+		visiblePhaseIds.delete(id);
+		const msg = error ? `${label}: ${error}` : label;
+		logger.info(`${logPrefix} ✗ [${id}] ${msg}  ${elapsed}`);
+		if (worker) worker.postMessage({
+			type: "failPhase",
+			id,
+			label: msg,
+			elapsed,
+			showElapsed
+		});
+		else printFailedLine(msg, showElapsed ? elapsed : void 0);
+	}
+	function skipPhase(id, label) {
+		phaseStartTimes.delete(id);
+		visiblePhaseIds.delete(id);
+		logger.info(`${logPrefix} - [${id}] ${label}`);
+		if (worker) worker.postMessage({
+			type: "skipPhase",
+			id,
+			label
+		});
+		else printSkippedLine(label);
+	}
+	function stopAll() {
+		const lineCount = visiblePhaseIds.size;
+		phaseStartTimes.clear();
+		visiblePhaseIds.clear();
+		worker?.postMessage({ type: "stopAll" });
+		if (isTTY() && lineCount > 0) {
+			let clearOutput = "";
+			if (lineCount > 1) clearOutput += "\x1B[A".repeat(lineCount - 1);
+			for (let i = 0; i < lineCount; i++) {
+				clearOutput += "\r\x1B[2K";
+				if (i < lineCount - 1) clearOutput += "\n";
+			}
+			if (lineCount > 1) clearOutput += "\x1B[A".repeat(lineCount - 1);
+			writeSync(SPINNER_OUTPUT_FD, clearOutput);
+		}
+	}
+	function start(label) {
+		defaultLabel = label;
+		startPhase(DEFAULT_PHASE_ID, label);
+	}
+	function setLabel(label) {
+		defaultLabel = label;
+		updatePhase(DEFAULT_PHASE_ID, label);
+	}
+	function complete(label, elapsedMs) {
+		completePhase(DEFAULT_PHASE_ID, label, elapsedMs);
+	}
+	function fail(label, elapsedMs, error) {
+		failPhase(DEFAULT_PHASE_ID, label, elapsedMs, error);
+	}
+	function skip(label) {
+		skipPhase(DEFAULT_PHASE_ID, label);
+	}
+	function stop() {
+		stopAll();
+	}
+	return {
+		start,
+		setLabel,
+		complete,
+		fail,
+		skip,
+		stop,
+		isRunning: () => visiblePhaseIds.size > 0,
+		currentLabel: () => defaultLabel,
+		addPendingPhase,
+		startPhase,
+		updatePhase,
+		completePhase,
+		failPhase,
+		skipPhase
+	};
+}
+//#endregion
+export { formatProgressDuration as n, createSpinnerProgress as t };