@kici-dev/sdk 0.1.27 → 0.2.0

package/dist/rules/types.d.ts

@@ -9,8 +9,18 @@ export type { EventPayload } from '../events/event-payloads.js';
 export interface RuleContext {
     /** The triggering event payload */
     event: EventPayload;
-    /** List of files changed in this event (e.g., PR diff) */
+    /**
+     * Files changed in this event (PR diff / push diff). Available on push and
+     * pull_request events (the agent computes the diff from the checkout — no
+     * `paths:` trigger required). Accessing this throws
+     * `ChangedFilesUnavailableError` when the diff is not available
+     * (`changedFilesStatus !== 'fetched'`) — e.g. a schedule/tag/manual event.
+     * Guard with `changedFilesStatus` first when a rule runs on such events:
+     * `if (ctx.changedFilesStatus !== 'fetched') return true`.
+     */
     changedFiles: string[];
+    /** Availability of `changedFiles` (see `changedFiles`). */
+    changedFilesStatus: import('@kici-dev/engine').ChangedFilesStatus;
     /** Environment variables */
     env: Record<string, string | undefined>;
     /** Operator-supplied, validated + coerced workflow-dispatch inputs. Empty when none declared. */

package/dist/step.d.ts

@@ -8,7 +8,7 @@ import type { Step, StepOptions, StepOptionsWithCheck, StepRunFn } from './types
  *   await ctx.$`echo hello`;
  * });
  */
-export declare function step<TResult = void>(run: (ctx: import('./context.js').StepContext) => Promise<TResult>): Step<TResult>;
+export declare function step<TResult = void>(run: (ctx: import('./context.js').StepContext) => Promise<TResult>): Step<TResult, ''>;
 /**
  * Create an id-less step with full options.
  * The compiler assigns a counter-based ID at lock file generation.
@@ -21,7 +21,7 @@ export declare function step<TResult = void>(run: (ctx: import('./context.js').S
  *   timeout: 60000,
  * });
  */
-export declare function step<TResult = void>(options: StepOptions<TResult>): Step<TResult>;
+export declare function step<TResult = void>(options: StepOptions<TResult>): Step<TResult, ''>;
 /**
  * Create a named step with just a run function (no outputs).
  *
@@ -30,7 +30,7 @@ export declare function step<TResult = void>(options: StepOptions<TResult>): Ste
  *   await ctx.$`git checkout`;
  * });
  */
-export declare function step(name: string, run: StepRunFn): Step<void>;
+export declare function step<TName extends string>(name: TName, run: StepRunFn): Step<void, TName>;
 /**
  * Create a named step with full options and generic return type.
  *
@@ -46,7 +46,7 @@ export declare function step(name: string, run: StepRunFn): Step<void>;
  *   }
  * });
  */
-export declare function step<TResult = void>(name: string, options: StepOptions<TResult>): Step<TResult>;
+export declare function step<TResult = void, TName extends string = string>(name: TName, options: StepOptions<TResult>): Step<TResult, TName>;
 /**
  * Create a named idempotent step with a check facet.
  *
@@ -62,9 +62,9 @@ export declare function step<TResult = void>(name: string, options: StepOptions<
  *   whenInSync: async () => ({ reloaded: false }),
  * });
  */
-export declare function step<TResult = void, TDrift = unknown>(name: string, options: StepOptionsWithCheck<TResult, TDrift>): Step<TResult>;
+export declare function step<TResult = void, TDrift = unknown, TName extends string = string>(name: TName, options: StepOptionsWithCheck<TResult, TDrift>): Step<TResult, TName>;
 /**
  * Create an id-less idempotent step with a check facet.
  */
-export declare function step<TResult = void, TDrift = unknown>(options: StepOptionsWithCheck<TResult, TDrift>): Step<TResult>;
+export declare function step<TResult = void, TDrift = unknown>(options: StepOptionsWithCheck<TResult, TDrift>): Step<TResult, ''>;
 //# sourceMappingURL=step.d.ts.map

package/dist/step.js

@@ -40,6 +40,8 @@ function captureCallSite() {
 			if (match) {
 				let file = match[1];
 				if (file.startsWith("file://")) file = file.slice(7);
+				const queryIndex = file.indexOf("?");
+				if (queryIndex !== -1) file = file.slice(0, queryIndex);
 				return {
 					file,
 					line: parseInt(match[2], 10),
@@ -78,7 +80,7 @@ function step(nameOrRunOrOptions, runOrOptions) {
 	if (options.check && !options.summarize) throw new Error("summarize is required when check is set");
 	if (options.approval !== void 0 && normalizeApproval(options.approval).when === "drift" && !options.check) throw new Error("approval.when \"drift\" requires a check facet");
 	const retry = normalizeRetry(options.retry);
-	return {
+	const stepObj = {
 		_tag: "Step",
 		name,
 		outputs: options.outputs,
@@ -95,9 +97,10 @@ function step(nameOrRunOrOptions, runOrOptions) {
 		onCancel: options.onCancel,
 		cleanup: options.cleanup,
 		...options.approval !== void 0 && { approval: options.approval },
-		_sourceLocation,
-		result: createStepOutputProxy(name)
+		_sourceLocation
 	};
+	stepObj.result = createStepOutputProxy(stepObj);
+	return stepObj;
 }
 //#endregion
 export { step };

package/dist/testing/index.d.ts

@@ -0,0 +1,2 @@
+export { createTestStepContext, type TestStepContextOptions, type TestStepContext, type RecordedEmit, } from './step-context.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.js

@@ -0,0 +1,3 @@
+import "../rolldown-runtime-ClRpJifh.js";
+import { createTestStepContext } from "./step-context.js";
+export { createTestStepContext };

package/dist/testing/step-context.d.ts

@@ -0,0 +1,56 @@
+import { type TempScope } from '@kici-dev/core/tmp';
+import type { StepContext, Logger } from '../context.js';
+import type { EventEmitOptions } from '../events/types.js';
+/** A single recorded `ctx.emit(...)` invocation, for assertion in tests. */
+export interface RecordedEmit {
+    eventName: string;
+    payload?: Record<string, unknown>;
+    options?: EventEmitOptions;
+}
+/**
+ * Options for {@link createTestStepContext}. Every field is optional — call it
+ * with no arguments for a fully-defaulted context. Convenience seed fields
+ * (`repoRoot`, `secrets`) sit alongside direct `StepContext` member overrides
+ * (everything else), which are shallow-merged on top of the defaults.
+ */
+export interface TestStepContextOptions extends Partial<Omit<StepContext, 'secrets' | 'log'>> {
+    /** Working directory `ctx.$` is pinned to. Defaults to `process.cwd()`. */
+    repoRoot?: string;
+    /**
+     * Seed secrets for `ctx.secrets`. `flat` keys are global; `contexts` values are
+     * flattened into the flat map (last-write-wins), matching the local runner.
+     */
+    secrets?: {
+        flat?: Record<string, string>;
+        contexts?: Record<string, Record<string, string>>;
+    };
+    /** Logger override. Defaults to a console-backed logger. */
+    log?: Logger;
+}
+/** Handle returned by {@link createTestStepContext}. */
+export interface TestStepContext {
+    /** The built step context to pass into your step function. */
+    ctx: StepContext;
+    /** Every `ctx.emit(...)` call, in order — assert against this in tests. */
+    emitCalls: ReadonlyArray<RecordedEmit>;
+    /**
+     * The job-scoped temp allocator backing `ctx.mktemp`/`ctx.mktempFile`. Call
+     * `tempScope.disposeAll()` to drain every still-live temp dir/file manually;
+     * `dispose()` also drains it.
+     */
+    tempScope: TempScope;
+    /** Tear down secrets state + the per-context tmpdir + temp scope. Call in `afterEach`. */
+    dispose: () => Promise<void>;
+}
+/**
+ * Build a real {@link StepContext} for unit-testing a step function in vitest.
+ *
+ * `ctx.$` is real zx pinned to `repoRoot`, `ctx.secrets` is real
+ * (`createStepSecrets` seeded from `options.secrets`), and `ctx.emit` records
+ * each call on `emitCalls` while returning the local delivery receipt.
+ * Orchestrator-backed APIs (`ctx.kici.*`, `ctx.attestProvenance`,
+ * `ctx.artifacts.*`) reject, and `ctx.cache` no-ops — override any of them via
+ * the options object.
+ */
+export declare function createTestStepContext(options?: TestStepContextOptions): TestStepContext;
+//# sourceMappingURL=step-context.d.ts.map

package/dist/testing/step-context.js

@@ -0,0 +1,259 @@
+import "../rolldown-runtime-ClRpJifh.js";
+import { resolveJobOutputs, resolveStepOutputs } from "../outputs.js";
+import { createStepSecrets } from "../secrets.js";
+import { isEventDefinition } from "../events/define-event.js";
+import { initZx } from "@kici-dev/core";
+import { $ } from "zx";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { createTempScope } from "@kici-dev/core/tmp";
+//#region src/testing/step-context.ts
+initZx();
+const DEFAULT_WORKFLOW = { name: "test-workflow" };
+const DEFAULT_JOB = {
+	name: "test-job",
+	runsOn: "local"
+};
+const NOOP_DELIVERY_ID = "local-test-noop";
+function createConsoleLogger() {
+	return {
+		info: (message, ...args) => console.log(message, ...args),
+		warn: (message, ...args) => console.warn(`⚠ ${message}`, ...args),
+		error: (message, ...args) => console.error(`✗ ${message}`, ...args),
+		debug: (message, ...args) => {
+			if (process.env.KICI_DEBUG === "true") console.debug(`[debug] ${message}`, ...args);
+		}
+	};
+}
+/**
+* Wire a real secrets surface backed by an on-demand tmpdir file host.
+*
+* The tmpdir is allocated lazily on first `mountFile`/`exposeFile` so steps that
+* never mount pay nothing, and the `process.on('exit')` cleanup handler is
+* registered lazily too (to avoid Node's MaxListeners warning at scale).
+*/
+function createTestSecrets(mergedFlat, env) {
+	let tmpdirPath = null;
+	const exposedEnvVars = /* @__PURE__ */ new Set();
+	let mountCounter = 0;
+	let exitHandlerRegistered = false;
+	const onProcessExit = () => {
+		for (const envVar of exposedEnvVars) delete env[envVar];
+		exposedEnvVars.clear();
+		if (tmpdirPath !== null) {
+			try {
+				rmSync(tmpdirPath, {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+			tmpdirPath = null;
+		}
+	};
+	const handle = createStepSecrets(mergedFlat, env, void 0, {
+		host: {
+			async writeMountedFile(args) {
+				if (tmpdirPath === null) tmpdirPath = mkdtempSync(join(tmpdir(), "kici-secret-files-"));
+				if (!exitHandlerRegistered) {
+					process.once("exit", onProcessExit);
+					exitHandlerRegistered = true;
+				}
+				mountCounter += 1;
+				const filename = args.name ?? `secret-${mountCounter}`;
+				const filePath = join(tmpdirPath, filename);
+				writeFileSync(filePath, args.content);
+				chmodSync(filePath, args.mode);
+				return filePath;
+			},
+			trackExposedEnv(envVar) {
+				exposedEnvVars.add(envVar);
+			}
+		},
+		cleanup: async () => {
+			if (exitHandlerRegistered) {
+				process.off("exit", onProcessExit);
+				exitHandlerRegistered = false;
+			}
+			onProcessExit();
+		}
+	});
+	return {
+		secrets: handle.secrets,
+		dispose: handle.dispose
+	};
+}
+/**
+* Sanitize a raw identifier into a valid temp label: lowercase, every
+* non-`[a-z0-9-]` char to `-`, falling back to `'step'` when the result is
+* empty. Applied to both the caller-supplied label and the default step id so
+* `ctx.mktemp(...)` never rejects a friendly-but-irregular label.
+*/
+function sanitizeTempLabel(raw) {
+	const cleaned = raw.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+	return cleaned.length > 0 ? cleaned : "step";
+}
+/**
+* Wire a job-scoped temp allocator for the test step context.
+*
+* `mktemp`/`mktempFile` delegate to a {@link createTempScope} instance and track
+* each allocated root so an exit backstop can reclaim it. The `process.once('exit')`
+* handler is registered lazily on first allocation (to avoid Node's MaxListeners
+* warning at scale) and synchronously removes any still-live temp paths — mirroring
+* the secrets-tmpdir exit cleanup. `dispose()` drains the scope and removes the
+* handler; the scope is exposed for manual drain in tests.
+*/
+function createTestTempScope(defaultLabel) {
+	const scope = createTempScope();
+	const liveRoots = [];
+	let exitHandlerRegistered = false;
+	const onProcessExit = () => {
+		for (const root of liveRoots) try {
+			rmSync(root, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+		liveRoots.length = 0;
+	};
+	const ensureExitHandler = () => {
+		if (!exitHandlerRegistered) {
+			process.once("exit", onProcessExit);
+			exitHandlerRegistered = true;
+		}
+	};
+	return {
+		async mktemp(label) {
+			ensureExitHandler();
+			const handle = await scope.mktemp(sanitizeTempLabel(label ?? defaultLabel));
+			liveRoots.push(handle.path);
+			return handle;
+		},
+		async mktempFile(label, opts) {
+			ensureExitHandler();
+			const handle = await scope.mktempFile(sanitizeTempLabel(label ?? defaultLabel), opts);
+			liveRoots.push(dirname(handle.path));
+			return handle;
+		},
+		scope,
+		async dispose() {
+			if (exitHandlerRegistered) {
+				process.off("exit", onProcessExit);
+				exitHandlerRegistered = false;
+			}
+			await scope.disposeAll();
+			liveRoots.length = 0;
+		}
+	};
+}
+/**
+* Build a real {@link StepContext} for unit-testing a step function in vitest.
+*
+* `ctx.$` is real zx pinned to `repoRoot`, `ctx.secrets` is real
+* (`createStepSecrets` seeded from `options.secrets`), and `ctx.emit` records
+* each call on `emitCalls` while returning the local delivery receipt.
+* Orchestrator-backed APIs (`ctx.kici.*`, `ctx.attestProvenance`,
+* `ctx.artifacts.*`) reject, and `ctx.cache` no-ops — override any of them via
+* the options object.
+*/
+function createTestStepContext(options = {}) {
+	const { repoRoot = process.cwd(), secrets: seed, log, ...overrides } = options;
+	const flat = seed?.flat ?? {};
+	const namespaced = seed?.contexts ?? {};
+	const mergedFlat = { ...flat };
+	for (const contextSecrets of Object.values(namespaced)) Object.assign(mergedFlat, contextSecrets);
+	const env = overrides.env ?? { ...process.env };
+	const processEnvRestores = /* @__PURE__ */ new Map();
+	const recordProcessEnvOriginal = (key) => {
+		if (!processEnvRestores.has(key)) processEnvRestores.set(key, process.env[key]);
+	};
+	const scoped$ = $({ cwd: repoRoot });
+	const { secrets, dispose: disposeSecrets } = createTestSecrets(mergedFlat, env);
+	const temp = createTestTempScope((overrides.job ?? DEFAULT_JOB).name);
+	const emitCalls = [];
+	const emit = (async (nameOrDefinition, payload, opts) => {
+		const eventName = isEventDefinition(nameOrDefinition) ? nameOrDefinition.name : nameOrDefinition;
+		emitCalls.push({
+			eventName,
+			payload,
+			options: opts
+		});
+		return { deliveryId: NOOP_DELIVERY_ID };
+	});
+	const ctx = {
+		$: scoped$,
+		log: log ?? createConsoleLogger(),
+		signal: overrides.signal ?? new AbortController().signal,
+		env,
+		setEnv: (key, value) => {
+			env[key] = value;
+			recordProcessEnvOriginal(key);
+			process.env[key] = value;
+		},
+		addPath: (dir) => {
+			const updated = `${dir}:${env.PATH ?? process.env.PATH ?? ""}`;
+			env.PATH = updated;
+			recordProcessEnvOriginal("PATH");
+			process.env.PATH = updated;
+		},
+		inputs: {},
+		dispatchInputs: {},
+		workflow: DEFAULT_WORKFLOW,
+		job: DEFAULT_JOB,
+		isTestRun: false,
+		secrets,
+		emit,
+		outputsOf: (ref) => resolveStepOutputs(ref),
+		jobOutputs: (ref) => resolveJobOutputs(ref),
+		setSecretOutput: () => {},
+		mktemp: (label) => temp.mktemp(label),
+		mktempFile: (label, opts) => temp.mktempFile(label, opts),
+		kici: {
+			infrastructure: { list: () => Promise.resolve({
+				scalers: [],
+				agents: []
+			}) },
+			inventory: {
+				query: () => Promise.resolve([]),
+				get: () => Promise.resolve(null)
+			},
+			oidc: { token: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.oidc.token() is not available in a test step context")) },
+			host: { requestReboot: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.host.requestReboot() is not available in a test step context")) },
+			bootstrap: {
+				ensureInitRunner: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.bootstrap.ensureInitRunner() is not available in a test step context")),
+				preBootSend: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.bootstrap.preBootSend() is not available in a test step context")),
+				agentVersionStatus: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.bootstrap.agentVersionStatus() is not available in a test step context")),
+				restageAgent: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.bootstrap.restageAgent() is not available in a test step context"))
+			}
+		},
+		cache: {
+			restore: async () => ({ hit: false }),
+			save: async () => {}
+		},
+		artifacts: {
+			upload: () => Promise.reject(/* @__PURE__ */ new Error("ctx.artifacts.upload() is not available in a test step context")),
+			download: () => Promise.reject(/* @__PURE__ */ new Error("ctx.artifacts.download() is not available in a test step context"))
+		},
+		attestProvenance: () => Promise.reject(/* @__PURE__ */ new Error("ctx.attestProvenance() is not available in a test step context")),
+		...overrides,
+		env,
+		$: overrides.$ ?? scoped$
+	};
+	const dispose = async () => {
+		await disposeSecrets();
+		await temp.dispose();
+		for (const [key, original] of processEnvRestores) if (original === void 0) delete process.env[key];
+		else process.env[key] = original;
+		processEnvRestores.clear();
+	};
+	return {
+		ctx,
+		emitCalls,
+		tempScope: temp.scope,
+		dispose
+	};
+}
+//#endregion
+export { createTestStepContext };
+
+//# sourceMappingURL=step-context.js.map

package/dist/triggers/index.d.ts

@@ -19,12 +19,13 @@ export { watch } from './watch.js';
 export { webhook } from './webhook.js';
 export { kiciEvent } from './kici-event.js';
 export { workflowComplete } from './workflow-complete.js';
+export { workflowsFailedBatch } from './workflows-failed-batch.js';
 export { jobComplete } from './job-complete.js';
 export { genericWebhook } from './generic-webhook.js';
 export { schedule } from './schedule.js';
 export { lifecycle } from './lifecycle.js';
 export { defineDispatchInputs } from './dispatch-inputs.js';
 export type { DefinedDispatchInputs, InferDispatchInputs } from './dispatch-inputs.js';
-export type { DispatchInputsMap, BranchPattern, BodyMatchPattern, PrEvent, PushEvent, PrTriggerConfig, PushTriggerConfig, TagTriggerConfig, CommentTriggerConfig, ReviewTriggerConfig, ReviewCommentTriggerConfig, ReleaseTriggerConfig, DispatchTriggerConfig, CreateTriggerConfig, DeleteTriggerConfig, StatusTriggerConfig, WorkflowRunTriggerConfig, ForkTriggerConfig, StarTriggerConfig, WatchTriggerConfig, WebhookTriggerConfig, TriggerConfig, PrConfigInput, PushConfigInput, TagConfigInput, CommentConfigInput, CommentAction, CommentSource, ReviewConfigInput, ReviewAction, ReviewState, ReviewCommentConfigInput, ReviewCommentAction, ReleaseConfigInput, ReleaseAction, DispatchConfigInput, CreateConfigInput, DeleteConfigInput, RefType, StatusConfigInput, StatusState, WorkflowRunConfigInput, WorkflowRunAction, ForkConfigInput, StarConfigInput, StarAction, WatchConfigInput, WatchAction, WebhookConfigInput, KiciEventConfigInput, KiciEventTriggerConfig, WorkflowCompleteConfigInput, WorkflowCompleteTriggerConfig, WorkflowCompleteStatus, JobCompleteConfigInput, JobCompleteTriggerConfig, JobCompleteStatus, GenericWebhookConfigInput, GenericWebhookTriggerConfig, GenericWebhookAuthMethod, GenericWebhookHmacAuth, GenericWebhookApiKeyAuth, GenericWebhookAuth, ScheduleConfigInput, ScheduleTriggerConfig, LifecycleEvent, LifecycleConfigInput, LifecycleTriggerConfig, } from './types.js';
+export type { DispatchInputsMap, BranchPattern, BodyMatchPattern, PrEvent, PushEvent, PrTriggerConfig, PushTriggerConfig, TagTriggerConfig, CommentTriggerConfig, ReviewTriggerConfig, ReviewCommentTriggerConfig, ReleaseTriggerConfig, DispatchTriggerConfig, CreateTriggerConfig, DeleteTriggerConfig, StatusTriggerConfig, WorkflowRunTriggerConfig, ForkTriggerConfig, StarTriggerConfig, WatchTriggerConfig, WebhookTriggerConfig, TriggerConfig, PrConfigInput, PushConfigInput, TagConfigInput, CommentConfigInput, CommentAction, CommentSource, ReviewConfigInput, ReviewAction, ReviewState, ReviewCommentConfigInput, ReviewCommentAction, ReleaseConfigInput, ReleaseAction, DispatchConfigInput, CreateConfigInput, DeleteConfigInput, RefType, StatusConfigInput, StatusState, WorkflowRunConfigInput, WorkflowRunAction, ForkConfigInput, StarConfigInput, StarAction, WatchConfigInput, WatchAction, WebhookConfigInput, KiciEventConfigInput, KiciEventTriggerConfig, WorkflowCompleteConfigInput, WorkflowCompleteTriggerConfig, WorkflowCompleteStatus, WorkflowsFailedBatchConfigInput, WorkflowsFailedBatchTriggerConfig, JobCompleteConfigInput, JobCompleteTriggerConfig, JobCompleteStatus, GenericWebhookConfigInput, GenericWebhookTriggerConfig, GenericWebhookAuthMethod, GenericWebhookHmacAuth, GenericWebhookApiKeyAuth, GenericWebhookAuth, ScheduleConfigInput, ScheduleTriggerConfig, LifecycleEvent, LifecycleConfigInput, LifecycleTriggerConfig, } from './types.js';
 export { DEFAULT_PR_EVENTS, toBranchPattern } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/triggers/index.js

@@ -18,9 +18,10 @@ import { watch } from "./watch.js";
 import { webhook } from "./webhook.js";
 import { kiciEvent } from "./kici-event.js";
 import { workflowComplete } from "./workflow-complete.js";
+import { workflowsFailedBatch } from "./workflows-failed-batch.js";
 import { jobComplete } from "./job-complete.js";
 import { genericWebhook } from "./generic-webhook.js";
 import { schedule } from "./schedule.js";
 import { lifecycle } from "./lifecycle.js";
 import { defineDispatchInputs } from "./dispatch-inputs.js";
-export { DEFAULT_PR_EVENTS, comment, create, defineDispatchInputs, del as delete, dispatch, fork, genericWebhook, jobComplete, kiciEvent, lifecycle, pr, push, release, review, reviewComment, schedule, star, status, tag, toBranchPattern, watch, webhook, workflowComplete, workflowRun };
+export { DEFAULT_PR_EVENTS, comment, create, defineDispatchInputs, del as delete, dispatch, fork, genericWebhook, jobComplete, kiciEvent, lifecycle, pr, push, release, review, reviewComment, schedule, star, status, tag, toBranchPattern, watch, webhook, workflowComplete, workflowRun, workflowsFailedBatch };

package/dist/triggers/types.d.ts

@@ -371,6 +371,28 @@ export interface WorkflowCompleteTriggerConfig {
     readonly source?: string;
     readonly description?: string;
 }
+/**
+ * Input configuration for workflowsFailedBatch() factory function.
+ * Accumulate failed workflow completions over a window, notify once.
+ */
+export interface WorkflowsFailedBatchConfigInput {
+    /** Accumulation window in milliseconds; the window opens on the first failure. */
+    readonly accumulateFor: number;
+    readonly name?: string;
+    readonly source?: string;
+    readonly description?: string;
+}
+/**
+ * Configuration for a workflows-failed-batch trigger.
+ */
+export interface WorkflowsFailedBatchTriggerConfig {
+    readonly _tag: 'WorkflowsFailedBatchTrigger';
+    /** Accumulation window in milliseconds; the window opens on the first failure. */
+    readonly accumulateFor: number;
+    readonly name?: string;
+    readonly source?: string;
+    readonly description?: string;
+}
 /**
  * Valid job completion statuses.
  */
@@ -525,7 +547,7 @@ export interface WebhookConfigInput {
 /**
  * Union type for all trigger configurations (21 types).
  */
-export type TriggerConfig = PrTriggerConfig | PushTriggerConfig | TagTriggerConfig | CommentTriggerConfig | ReviewTriggerConfig | ReviewCommentTriggerConfig | ReleaseTriggerConfig | DispatchTriggerConfig | CreateTriggerConfig | DeleteTriggerConfig | StatusTriggerConfig | WorkflowRunTriggerConfig | ForkTriggerConfig | StarTriggerConfig | WatchTriggerConfig | WebhookTriggerConfig | KiciEventTriggerConfig | WorkflowCompleteTriggerConfig | JobCompleteTriggerConfig | GenericWebhookTriggerConfig | ScheduleTriggerConfig | LifecycleTriggerConfig;
+export type TriggerConfig = PrTriggerConfig | PushTriggerConfig | TagTriggerConfig | CommentTriggerConfig | ReviewTriggerConfig | ReviewCommentTriggerConfig | ReleaseTriggerConfig | DispatchTriggerConfig | CreateTriggerConfig | DeleteTriggerConfig | StatusTriggerConfig | WorkflowRunTriggerConfig | ForkTriggerConfig | StarTriggerConfig | WatchTriggerConfig | WebhookTriggerConfig | KiciEventTriggerConfig | WorkflowCompleteTriggerConfig | WorkflowsFailedBatchTriggerConfig | JobCompleteTriggerConfig | GenericWebhookTriggerConfig | ScheduleTriggerConfig | LifecycleTriggerConfig;
 /**
  * Input configuration for pr() factory function.
  * All fields optional - sensible defaults applied.

package/dist/triggers/workflows-failed-batch.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Workflows-failed-batch trigger helper.
+ *
+ * Accumulates failed workflow completions over a time window and fires the
+ * subscribing global workflow once per window with the batched run list, so a
+ * mass incident notifies a single time instead of once per failed run.
+ */
+import type { WorkflowsFailedBatchConfigInput, WorkflowsFailedBatchTriggerConfig } from './types.js';
+/**
+ * Create a workflows-failed-batch trigger configuration.
+ *
+ * @example
+ * // Notify once for every burst of failures within a 10s window
+ * workflowsFailedBatch({ accumulateFor: 10000 })
+ *
+ * // Scope the batch to a named workflow and a specific source repo
+ * workflowsFailedBatch({ accumulateFor: 10000, name: 'CI', source: 'org/repo' })
+ */
+export declare function workflowsFailedBatch(config: WorkflowsFailedBatchConfigInput): WorkflowsFailedBatchTriggerConfig;
+//# sourceMappingURL=workflows-failed-batch.d.ts.map

package/dist/triggers/workflows-failed-batch.js

@@ -0,0 +1,25 @@
+import "../rolldown-runtime-ClRpJifh.js";
+//#region src/triggers/workflows-failed-batch.ts
+/**
+* Create a workflows-failed-batch trigger configuration.
+*
+* @example
+* // Notify once for every burst of failures within a 10s window
+* workflowsFailedBatch({ accumulateFor: 10000 })
+*
+* // Scope the batch to a named workflow and a specific source repo
+* workflowsFailedBatch({ accumulateFor: 10000, name: 'CI', source: 'org/repo' })
+*/
+function workflowsFailedBatch(config) {
+	return Object.freeze({
+		_tag: "WorkflowsFailedBatchTrigger",
+		accumulateFor: config.accumulateFor,
+		...config.name !== void 0 && { name: config.name },
+		...config.source !== void 0 && { source: config.source },
+		...config.description !== void 0 && { description: config.description }
+	});
+}
+//#endregion
+export { workflowsFailedBatch };
+
+//# sourceMappingURL=workflows-failed-batch.js.map