@kici-dev/compiler 0.1.22 → 0.1.24

package/dist/commands/run.d.ts

@@ -1,6 +1,6 @@
-import type { HostTargetSelector } from '@kici-dev/engine';
+import { type HostTargetSelector, type InputsDescriptorMap } from '@kici-dev/engine';
 import type { RunLocalOptions } from '../local-executor/types.js';
-import type { RemoteRunOptions } from './test.js';
+import type { RemoteRunOptions } from './preview.js';
 /**
  * Compile `--target` selector strings into a {@link HostTargetSelector}. Each
  * string becomes one AND value (its own include set); repeated values
@@ -8,6 +8,31 @@ import type { RemoteRunOptions } from './test.js';
  * `--target-allow-empty` is set without at least one `--target`.
  */
 export declare function buildTargetSelector(targets: string[] | undefined, allowEmpty: boolean): HostTargetSelector | undefined;
+/**
+ * Look up the dispatch-trigger `inputs` descriptor for a workflow from a parsed
+ * inline lock file. When `workflowName` is given, only that workflow's dispatch
+ * triggers are considered; otherwise descriptors across all workflows are merged
+ * (best-effort fast-fail — the orchestrator re-validates against the matched
+ * workflow authoritatively). Returns undefined when no dispatch inputs declared.
+ */
+export declare function lookupDispatchInputsDescriptor(inlineLockFile: string | undefined, workflowName: string | undefined): InputsDescriptorMap | undefined;
+/**
+ * Validate raw `--input KEY=VALUE` pairs against the (optional) lock descriptor
+ * and return the raw operator pairs verbatim. The CLI fast-fails on malformed /
+ * invalid input for UX, but forwards the **raw** strings — the orchestrator is
+ * authoritative and applies coercion + defaults exactly once.
+ */
+export declare function buildDispatchInputs(pairs: string[], descriptor: InputsDescriptorMap | undefined): Record<string, string>;
+/**
+ * Run `fn` with everything written to `process.stdout` redirected to
+ * `process.stderr`, then restore the original writer. Compiling a repo
+ * evaluates every user workflow / fixture module, and a `console.log` at a
+ * module's top level writes straight to stdout. On a machine-readable
+ * (`--json`) run that stdout MUST carry only the final JSON result, so the
+ * compile phases run inside this guard — workflow log output belongs on
+ * stderr regardless.
+ */
+export declare function withStdoutOnStderr<T>(fn: () => Promise<T>): Promise<T>;
 /**
  * Run a workflow locally using the local executor.
  * Thin wrapper that delegates to executeLocal from local-executor.

package/dist/commands/run.js

@@ -3,19 +3,24 @@ import { resolveKiciDir } from "../execution/executor.js";
 import "../execution/index.js";
 import { loadGlobalConfig } from "../remote/config.js";
 import { RunHistory } from "../remote/history.js";
+import { buildLocalRepoIdentity } from "../remote/local-repo-identity.js";
 import { AccessDeniedError, AmbiguousClusterError, AuthenticationError, ConnectionError, NoClusterError, PlatformRunClient } from "../remote/platform-client.js";
 import { buildEncryptedSecrets } from "../remote/secret-upload.js";
 import { createOverlayTarball, getSizeWarning, uploadTarball } from "../remote/uploader.js";
 import { formatJsonResult } from "../remote/output/json.js";
 import { formatJunitResult } from "../remote/output/junit.js";
 import { formatErrorHighlight, formatMultiFixtureSummary, formatSummary } from "../remote/output/summary.js";
+import { compileCommand } from "./compile.js";
 import { compileFixtures, filterFixtures } from "../fixtures/compiler.js";
+import { describeEvent } from "../fixtures/describe-event.js";
+import { FixturePickerCancelledError, runFixturePicker } from "../fixtures/picker.js";
 import { listHeldRunsForRun, resolveHeldRunContext } from "./held-run-client.js";
 import { handleNewHolds } from "./run-hold-watch.js";
 import path from "node:path";
 import pc from "picocolors";
 import { readFile, writeFile } from "node:fs/promises";
 import { formatBytes, logger, toErrorMessage } from "@kici-dev/core";
+import { coerceDispatchInputs, parseInputPairs } from "@kici-dev/engine";
 import { normalizeRunsOnToMatchers } from "@kici-dev/engine/labels/compile";
 import { confirm } from "@inquirer/prompts";
 //#region src/commands/run.ts
@@ -42,9 +47,85 @@ function buildTargetSelector(targets, allowEmpty) {
 		allowEmpty
 	};
 }
+/**
+* Look up the dispatch-trigger `inputs` descriptor for a workflow from a parsed
+* inline lock file. When `workflowName` is given, only that workflow's dispatch
+* triggers are considered; otherwise descriptors across all workflows are merged
+* (best-effort fast-fail — the orchestrator re-validates against the matched
+* workflow authoritatively). Returns undefined when no dispatch inputs declared.
+*/
+function lookupDispatchInputsDescriptor(inlineLockFile, workflowName) {
+	if (!inlineLockFile) return void 0;
+	let lock;
+	try {
+		lock = JSON.parse(inlineLockFile);
+	} catch {
+		return;
+	}
+	const merged = {};
+	let found = false;
+	for (const wf of lock.workflows ?? []) {
+		if (workflowName && wf.name !== workflowName) continue;
+		for (const trigger of wf.triggers ?? []) if (trigger._type === "dispatch" && trigger.inputs) {
+			Object.assign(merged, trigger.inputs);
+			found = true;
+		}
+	}
+	return found ? merged : void 0;
+}
+/**
+* Validate raw `--input KEY=VALUE` pairs against the (optional) lock descriptor
+* and return the raw operator pairs verbatim. The CLI fast-fails on malformed /
+* invalid input for UX, but forwards the **raw** strings — the orchestrator is
+* authoritative and applies coercion + defaults exactly once.
+*/
+function buildDispatchInputs(pairs, descriptor) {
+	if (!pairs.length) return {};
+	const raw = parseInputPairs(pairs);
+	if (descriptor) {
+		const r = coerceDispatchInputs(raw, descriptor);
+		if ("error" in r) throw r.error;
+	}
+	return raw;
+}
 /** Interval between status/log polls while a run is active. */
 const POLL_INTERVAL_MS = 750;
 /**
+* Run `fn` with everything written to `process.stdout` redirected to
+* `process.stderr`, then restore the original writer. Compiling a repo
+* evaluates every user workflow / fixture module, and a `console.log` at a
+* module's top level writes straight to stdout. On a machine-readable
+* (`--json`) run that stdout MUST carry only the final JSON result, so the
+* compile phases run inside this guard — workflow log output belongs on
+* stderr regardless.
+*/
+async function withStdoutOnStderr(fn) {
+	const realWrite = process.stdout.write.bind(process.stdout);
+	process.stdout.write = process.stderr.write.bind(process.stderr);
+	try {
+		return await fn();
+	} finally {
+		process.stdout.write = realWrite;
+	}
+}
+/**
+* Recompile `.kici/workflows` → `kici.lock.json` before a remote run, mirroring
+* `kici run local`. The orchestrator matches triggers and dispatches against the
+* inline lock, so a stale lock would route an edited or newly-added workflow
+* incorrectly. Returns false on a compile/validation error so the caller can
+* abort before any upload or dispatch.
+*/
+async function compileBeforeRemoteRun(options) {
+	const pureStdout = Boolean(options.json || options.quiet);
+	const compile = () => compileCommand({
+		kiciDir: options.kiciDir ?? ".kici",
+		check: false,
+		verbose: options.debug ?? false,
+		quiet: pureStdout
+	});
+	return pureStdout ? withStdoutOnStderr(compile) : compile();
+}
+/**
 * Run a workflow locally using the local executor.
 * Thin wrapper that delegates to executeLocal from local-executor.
 *
@@ -88,10 +169,22 @@ async function runRemoteCommand(fixture, options) {
 			console.log(history.formatTable(entries));
 			return true;
 		}
-		const fixtures = await compileFixtures(path.join(kiciDir, "tests"));
-		if (!fixture && !options.all) return listFixtures(fixtures);
+		const testsDir = path.join(kiciDir, "tests");
+		const fixtures = options.json ? await withStdoutOnStderr(() => compileFixtures(testsDir)) : await compileFixtures(testsDir);
 		let selected;
-		if (options.all) selected = fixtures;
+		if (options.pick) {
+			if (fixtures.length === 0) return listFixtures(fixtures);
+			try {
+				selected = await runFixturePicker(fixtures);
+			} catch (err) {
+				if (err instanceof FixturePickerCancelledError) {
+					logger.info(pc.gray(err.message));
+					return false;
+				}
+				throw err;
+			}
+		} else if (!fixture && !options.all) return listFixtures(fixtures);
+		else if (options.all) selected = fixtures;
 		else selected = filterFixtures(fixtures, fixture);
 		if (selected.length === 0) {
 			logger.info(pc.yellow(`No fixtures matched: ${fixture ?? "(none)"}`));
@@ -132,17 +225,6 @@ function listFixtures(fixtures) {
 	return true;
 }
 /**
-* Describe the event type from a fixture's trigger config.
-*/
-function describeEvent(event) {
-	if (!event || typeof event !== "object") return "unknown";
-	const e = event;
-	if (e._type === "push") return "push";
-	if (e._type === "pr") return `pr:${e.action ?? "open"}`;
-	if (typeof e._type === "string") return String(e._type);
-	return "custom";
-}
-/**
 * Resolve the authenticated Platform client and the run target (org + cluster).
 *
 * Org resolution: `--org` → `config.activeOrgId` → error.
@@ -182,6 +264,7 @@ function resolvePlatformContext(config, options) {
 * Run fixtures remotely against the Platform.
 */
 async function runFixturesRemotely(fixtures, options) {
+	if (!await compileBeforeRemoteRun(options)) return false;
 	const config = await loadGlobalConfig();
 	const ctx = resolvePlatformContext(config, options);
 	if (!ctx) return false;
@@ -294,11 +377,12 @@ async function runSingleFixture(fixture, ctx, options, config, history) {
 		const uploaded = await initAndUpload(ctx, overlay, options);
 		const event = buildEventFromFixture(opts);
 		{
-			const repoName = path.basename(overlay.repoRoot);
+			const identity = buildLocalRepoIdentity(overlay.repoRoot);
 			const repo = event.payload.repository;
 			event.payload.repository = {
 				...repo ?? {},
-				full_name: `local/${repoName}`
+				full_name: identity.repoIdentifier,
+				provider: identity.provider
 			};
 		}
 		if (!options.quiet) logger.info(pc.gray("Triggering test run..."));
@@ -320,6 +404,11 @@ async function runSingleFixture(fixture, ctx, options, config, history) {
 			...(() => {
 				const target = buildTargetSelector(options.targets, options.targetAllowEmpty ?? false);
 				return target ? { target } : {};
+			})(),
+			...(() => {
+				const descriptor = lookupDispatchInputsDescriptor(overlay.inlineLockFile, opts.workflowName);
+				const dispatchInputs = buildDispatchInputs(options.inputs ?? [], descriptor);
+				return Object.keys(dispatchInputs).length ? { dispatchInputs } : {};
 			})()
 		});
 		if (triggerResult.status === "rejected") {
@@ -513,6 +602,7 @@ function buildEventFromFixture(opts) {
 * Platform.
 */
 async function runDirectWorkflow(workflowName, options) {
+	if (!await compileBeforeRemoteRun(options)) return false;
 	const ctx = resolvePlatformContext(await loadGlobalConfig(), options);
 	if (!ctx) return false;
 	if (options.json) options.quiet = true;
@@ -522,7 +612,11 @@ async function runDirectWorkflow(workflowName, options) {
 	try {
 		const overlay = await prepareOverlay(options);
 		const uploaded = await initAndUpload(ctx, overlay, options);
-		const payload = { repository: { full_name: `local/${path.basename(overlay.repoRoot)}` } };
+		const identity = buildLocalRepoIdentity(overlay.repoRoot);
+		const payload = { repository: {
+			full_name: identity.repoIdentifier,
+			provider: identity.provider
+		} };
 		const encrypted = await buildEncryptedSecrets(overlay.kiciDir, options.envFlags, options.context, uploaded.publicKey);
 		const triggerResult = await ctx.client.trigger(ctx.orgId, ctx.target, {
 			fixtureId,
@@ -544,6 +638,11 @@ async function runDirectWorkflow(workflowName, options) {
 			...(() => {
 				const target = buildTargetSelector(options.targets, options.targetAllowEmpty ?? false);
 				return target ? { target } : {};
+			})(),
+			...(() => {
+				const descriptor = lookupDispatchInputsDescriptor(overlay.inlineLockFile, workflowName);
+				const dispatchInputs = buildDispatchInputs(options.inputs ?? [], descriptor);
+				return Object.keys(dispatchInputs).length ? { dispatchInputs } : {};
 			})()
 		});
 		if (!options.quiet) logger.info(pc.green(`Run started: ${triggerResult.runId}`));
@@ -572,6 +671,6 @@ function displayRemoteResults(results) {
 	logger.info("");
 }
 //#endregion
-export { buildTargetSelector, runLocalCommand, runRemoteCommand };
+export { buildDispatchInputs, buildTargetSelector, lookupDispatchInputsDescriptor, runLocalCommand, runRemoteCommand, withStdoutOnStderr };
 
 //# sourceMappingURL=run.js.map

package/dist/commands/test.d.ts

@@ -19,6 +19,8 @@ export interface TestOptions extends PayloadOptions {
 export interface RemoteRunOptions extends TestOptions {
     /** Run all available fixtures */
     all?: boolean;
+    /** Interactively pick fixtures to run (multi-select checkbox). */
+    pick?: boolean;
     /** Run matching fixtures concurrently */
     parallel?: boolean;
     /** Fire and forget (print runIds, don't stream) */
@@ -55,6 +57,8 @@ export interface RemoteRunOptions extends TestOptions {
      * operator must still be clause-eligible per hold; an ineligible hold blocks.
      */
     approveAll?: boolean;
+    /** `--input KEY=VALUE` values (repeatable): typed workflow-dispatch inputs. */
+    inputs?: string[];
 }
 /** Result of a single remote fixture run */
 export interface RemoteRunResult {

package/dist/commands/types.d.ts

@@ -1,6 +1,8 @@
 export interface TypesOptions {
     /** Path to .kici directory (defaults to .kici) */
     kiciDir?: string;
+    /** Suppress the success line on stdout (so machine-readable output stays pure). */
+    quiet?: boolean;
 }
 /**
  * Generate TypeScript declarations for environment secrets.

package/dist/commands/types.js

@@ -33,7 +33,7 @@ async function typesCommand(options = {}) {
 		await fs.mkdir(typesDir, { recursive: true });
 		const outputPath = path.join(typesDir, "secrets.d.ts");
 		await fs.writeFile(outputPath, dtsContent, "utf-8");
-		console.log(pc.green("Types generated") + pc.dim(` ${outputPath}`));
+		if (!options.quiet) console.log(pc.green("Types generated") + pc.dim(` ${outputPath}`));
 		return true;
 	} catch (err) {
 		if (err instanceof DashboardClientError) {

package/dist/commands/verify-attestation.d.ts

@@ -1,7 +1,10 @@
 export interface VerifyAttestationOptions {
     /** Path or `http(s)` URL to the attestation bundle JSON. Required. */
     bundle?: string;
-    /** Trusted issuer URL (online discovery) or a self-contained `{ issuer, jwks }` file. Required. */
+    /**
+     * Trusted issuer URL (online discovery) or a self-contained `{ issuer, jwks }`
+     * file. Optional — defaults to the hosted KiCI Platform's provenance issuer.
+     */
     trustRoot?: string;
     /** Expected token audience (defaults to the KiCI provenance audience). */
     audience?: string;

package/dist/commands/verify-attestation.js

@@ -1,5 +1,6 @@
 import "../chunk-BTugEXQM.js";
 import { resolveTrustRoot } from "../provenance-trust-root.js";
+import "../remote/prod-defaults.js";
 import pc from "picocolors";
 import { readFile } from "node:fs/promises";
 import { logger, sha256File, toErrorMessage } from "@kici-dev/core";
@@ -7,13 +8,18 @@ import { KICI_PROVENANCE_AUDIENCE } from "@kici-dev/engine/provenance/bundle";
 import { verifyKiciBundle } from "@kici-dev/engine/provenance/verify";
 //#region src/commands/verify-attestation.ts
 /**
-* `kici verify-attestation [artifact] --bundle <path|url> --trust-root <url|file>`
+* `kici verify-attestation [artifact] --bundle <path|url> [--trust-root <url|file>]`
 *
 * Offline verification of a KiCI-signed provenance bundle: read the bundle,
-* resolve the trusted issuer + JWKS out-of-band (`--trust-root`), optionally
-* digest the artifact, and hand everything to the shared browser-safe
-* `verifyKiciBundle` core in `@kici-dev/engine`. The engine owns all crypto;
-* this command is the thin Node wrapper (fs / fetch / artifact digest / output).
+* resolve the trusted issuer + JWKS out-of-band, optionally digest the artifact,
+* and hand everything to the shared browser-safe `verifyKiciBundle` core in
+* `@kici-dev/engine`. The engine owns all crypto; this command is the thin Node
+* wrapper (fs / fetch / artifact digest / output).
+*
+* `--trust-root` is optional: when omitted it defaults to the hosted KiCI
+* Platform's provenance issuer, so the common case (verifying a bundle attested
+* on the hosted platform) needs no flag. Pass `--trust-root` to verify against a
+* different environment (e.g. staging) or an offline `{ issuer, jwks }` file.
 *
 * Returns a boolean (verified) so `cli.ts` can map it to an exit code (0/1).
 */
@@ -23,12 +29,22 @@ async function verifyAttestationCommand(artifact, options = {}) {
 			logger.error(pc.red("Error: --bundle <path|url> is required"));
 			return false;
 		}
-		if (!options.trustRoot) {
-			logger.error(pc.red("Error: --trust-root <url|file> is required"));
-			return false;
-		}
+		const trustRoot = options.trustRoot ?? "https://api.kici.dev";
+		const usingDefault = !options.trustRoot;
+		if (usingDefault) logger.info(pc.gray(`Using default trust root ${trustRoot} (pass --trust-root to override)`));
 		const bundle = JSON.parse(await readBundle(options.bundle));
-		const { issuer, jwks } = await resolveTrustRoot(options.trustRoot);
+		let resolved;
+		try {
+			resolved = await resolveTrustRoot(trustRoot);
+		} catch (error) {
+			const msg = toErrorMessage(error);
+			if (usingDefault && /\b503\b/.test(msg)) {
+				logger.error(pc.red(`Error: build provenance is not enabled on the hosted KiCI platform yet (${trustRoot} returned 503). Pass --trust-root to verify against another environment (e.g. staging) or an offline { issuer, jwks } file.`));
+				return false;
+			}
+			throw error;
+		}
+		const { issuer, jwks } = resolved;
 		const expectedDigest = artifact ? {
 			alg: "sha256",
 			hex: await sha256File(artifact)

package/dist/fixtures/describe-event.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Describe the event type from a fixture's trigger config, for the fixtures
+ * table and the interactive picker.
+ */
+export declare function describeEvent(event: unknown): string;
+//# sourceMappingURL=describe-event.d.ts.map

package/dist/fixtures/describe-event.js

@@ -0,0 +1,18 @@
+import "../chunk-BTugEXQM.js";
+//#region src/fixtures/describe-event.ts
+/**
+* Describe the event type from a fixture's trigger config, for the fixtures
+* table and the interactive picker.
+*/
+function describeEvent(event) {
+	if (!event || typeof event !== "object") return "unknown";
+	const e = event;
+	if (e._type === "push") return "push";
+	if (e._type === "pr") return `pr:${e.action ?? "open"}`;
+	if (typeof e._type === "string") return String(e._type);
+	return "custom";
+}
+//#endregion
+export { describeEvent };
+
+//# sourceMappingURL=describe-event.js.map

package/dist/fixtures/picker.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Interactive multi-select fixture picker for `kici run remote --pick`.
+ *
+ * Lists every available fixture with its source and event type, lets the user
+ * toggle one or more via a checkbox prompt, and returns the chosen fixtures.
+ * The caller feeds them into the standard remote-dispatch pipeline, so a picked
+ * run is identical to one selected by name / glob / --all.
+ */
+import type { CompiledFixture } from './compiler.js';
+export declare class FixturePickerCancelledError extends Error {
+    constructor(message: string);
+}
+/**
+ * Run the interactive multi-select fixture picker.
+ *
+ * @throws FixturePickerCancelledError when stdin is not a TTY or the user aborts.
+ */
+export declare function runFixturePicker(fixtures: CompiledFixture[]): Promise<CompiledFixture[]>;
+//# sourceMappingURL=picker.d.ts.map

package/dist/fixtures/picker.js

@@ -0,0 +1,64 @@
+import "../chunk-BTugEXQM.js";
+import { describeEvent } from "./describe-event.js";
+import path from "node:path";
+import pc from "picocolors";
+import { logger } from "@kici-dev/core";
+import { checkbox } from "@inquirer/prompts";
+//#region src/fixtures/picker.ts
+/**
+* Interactive multi-select fixture picker for `kici run remote --pick`.
+*
+* Lists every available fixture with its source and event type, lets the user
+* toggle one or more via a checkbox prompt, and returns the chosen fixtures.
+* The caller feeds them into the standard remote-dispatch pipeline, so a picked
+* run is identical to one selected by name / glob / --all.
+*/
+var FixturePickerCancelledError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FixturePickerCancelledError";
+	}
+};
+function isStdinTty() {
+	return Boolean(process.stdin.isTTY);
+}
+/** Build a single fixture's display row: `id  <source>  <event type>`. */
+function fixtureRow(f) {
+	const opts = typeof f.fixture.options === "function" ? null : f.fixture.options;
+	const eventType = opts?.event ? describeEvent(opts.event) : "(async)";
+	const source = path.relative(process.cwd(), f.sourceFile);
+	return `${f.id}  ${pc.gray(source)}  ${eventType}`;
+}
+function printFixtureList(fixtures) {
+	logger.info(pc.bold("Available fixtures:"));
+	for (const f of fixtures) logger.info(`  ${pc.cyan(f.id)} — ${fixtureRow(f)}`);
+}
+/**
+* Run the interactive multi-select fixture picker.
+*
+* @throws FixturePickerCancelledError when stdin is not a TTY or the user aborts.
+*/
+async function runFixturePicker(fixtures) {
+	if (!isStdinTty()) {
+		printFixtureList(fixtures);
+		throw new FixturePickerCancelledError("--pick requires an interactive terminal. Pass a fixture name instead.");
+	}
+	let chosenIds;
+	try {
+		chosenIds = await checkbox({
+			message: "Select fixtures to run",
+			choices: fixtures.map((f) => ({
+				name: fixtureRow(f),
+				value: f.id
+			})),
+			required: true
+		});
+	} catch (err) {
+		throw new FixturePickerCancelledError(`Picker cancelled: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	return fixtures.filter((f) => chosenIds.includes(f.id));
+}
+//#endregion
+export { FixturePickerCancelledError, runFixturePicker };
+
+//# sourceMappingURL=picker.js.map

package/dist/generators/secrets-dts.js

@@ -59,6 +59,8 @@ function generateSecretsDts(options) {
 	lines.push("  }");
 	lines.push("}");
 	lines.push("");
+	lines.push("export {};");
+	lines.push("");
 	return lines.join("\n");
 }
 //#endregion

package/dist/index.d.ts

@@ -3,8 +3,8 @@ export type { ExecutionResult } from './execution/index.js';
 export { validateConfig } from './validation/index.js';
 export type { ValidationResult } from './validation/index.js';
 export { generateLockFile, serializeLockFile } from './lockfile/index.js';
-export { SCHEMA_VERSION, isLockStaticJob } from './types.js';
-export type { LockFile, LockWorkflow, LockJob, LockDynamicJobFn, LockJobOrFactory, LockTrigger, LockPrTrigger, LockPushTrigger, LockMatrix, LockRule, LockStep, LockApproval, LockSource, LockBranchPattern, } from './types.js';
+export { SCHEMA_VERSION, isLockStaticJob, isLockParallelStep } from './types.js';
+export type { LockFile, LockWorkflow, LockJob, LockDynamicJobFn, LockJobOrFactory, LockTrigger, LockPrTrigger, LockPushTrigger, LockMatrix, LockRule, LockStep, LockParallelStep, LockStepEntry, LockApproval, LockSource, LockBranchPattern, } from './types.js';
 export { formatError, compilerError, isCompilerError } from './errors/index.js';
 export type { SourceLocation, CompilerError } from './errors/index.js';
 export { CapabilityGapError, formatCapabilityGapError } from './errors/index.js';

package/dist/index.js

@@ -6,7 +6,7 @@ import { executeConfig } from "./execution/executor.js";
 import "./execution/index.js";
 import { validateConfig } from "./validation/validator.js";
 import "./validation/index.js";
-import { SCHEMA_VERSION, isLockStaticJob } from "./types.js";
+import { SCHEMA_VERSION, isLockParallelStep, isLockStaticJob } from "./types.js";
 import { generateLockFile, serializeLockFile } from "./lockfile/generator.js";
 import "./lockfile/index.js";
-export { CapabilityGapError, SCHEMA_VERSION, compilerError, executeConfig, formatCapabilityGapError, formatError, generateLockFile, isCompilerError, isLockStaticJob, serializeLockFile, validateConfig };
+export { CapabilityGapError, SCHEMA_VERSION, compilerError, executeConfig, formatCapabilityGapError, formatError, generateLockFile, isCompilerError, isLockParallelStep, isLockStaticJob, serializeLockFile, validateConfig };