@akshatmittal/invoker 0.1.0 → 0.2.0

package/README.md

@@ -10,7 +10,91 @@ validated JSON Output in Vitest metadata for reporters and later analysis.
 pnpm add -D @akshatmittal/invoker vitest
 ```
 
-Invoker supports Node 24 and Vitest 4.1.10 or newer within Vitest 4.
+Invoker supports Node 24.18.1 or newer within Node 24 and Vitest 4.1.10 or newer within Vitest 4.
+
+## Schedule GitHub Actions
+
+`@akshatmittal/invoker/github` runs code-defined GitHub Actions schedules from
+a small, long-running Node process. It is independent from the Vitest SDK, so a
+scheduler-only installation does not need Vitest.
+
+Create a GitHub App with repository **Actions: read and write**, disable its
+webhook, install it on the selected repositories, and generate a private key.
+No other repository, organization, user, OAuth, or webhook permissions are
+needed.
+
+Install the scheduler with t3-env and Zod in a plain ESM application:
+
+```sh
+npm install @akshatmittal/invoker @t3-oss/env-core zod
+```
+
+```js
+// schedule.mjs
+import { createEnv } from "@t3-oss/env-core";
+import { defineGitHubSchedule } from "@akshatmittal/invoker/github";
+import { z } from "zod";
+
+const env = createEnv({
+  server: {
+    GITHUB_APP_ID: z.coerce.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    GITHUB_APP_PRIVATE_KEY: z.string().min(1),
+  },
+  runtimeEnv: process.env,
+});
+
+await defineGitHubSchedule({
+  app: {
+    id: env.GITHUB_APP_ID,
+    privateKey: env.GITHUB_APP_PRIVATE_KEY,
+  },
+  schedules: [
+    {
+      cron: "0 9 * * 1",
+      timezone: "UTC",
+      repository: "acme/regressions",
+      workflow: "invoker.yml",
+      ref: "main",
+      inputs: { dataset: "weekly", publish: true },
+    },
+  ],
+});
+```
+
+Schedules use five-field cron expressions and default to UTC when `timezone`
+is omitted. Configuration is fixed at startup. Every repository installation
+and active workflow is validated before timers begin; GitHub validates the ref,
+`workflow_dispatch` declaration, and input schema when a Dispatch is due.
+
+Run exactly one replica. Dispatches may overlap, are not persisted or retried,
+and failures do not stop later occurrences. The process emits events through
+evlog's shared logger, so the host's filtering, sampling, redaction, and drain
+configuration applies. The module does not initialize or configure evlog.
+`SIGINT` and `SIGTERM` stop new Dispatches, await in-flight requests, and
+resolve the long-running promise.
+
+### Docker
+
+Keep `package.json`, `package-lock.json`, and `schedule.mjs` in a deployment
+directory and build this image:
+
+```dockerfile
+FROM node:24-slim
+
+WORKDIR /app
+COPY package.json package-lock.json ./
+RUN npm ci --omit=dev
+COPY schedule.mjs ./
+
+USER node
+CMD ["node", "schedule.mjs"]
+```
+
+Exclude `.env`, PEM, and private-key files from the build context. Inject
+`GITHUB_APP_ID` and the real multiline `GITHUB_APP_PRIVATE_KEY` through the
+runtime platform's secret mechanism; never bake them into the image. Use the
+platform's process-liveness check and restart policy with one replica. The
+scheduler intentionally has no HTTP health endpoint.
 
 ## Define a Workflow
 
@@ -41,9 +125,9 @@ export const evaluateModels = defineTask({
 ```
 
 ```ts
-// regressions/model/index.test.ts
+// regressions/workflows/model-regressions.test.ts
 import { defineWorkflow } from "@akshatmittal/invoker";
-import { evaluateModels } from "./tasks/evaluate-models.js";
+import { evaluateModels } from "../tasks/evaluate-models.js";
 
 defineWorkflow({
   name: "model-regressions",
@@ -57,14 +141,15 @@ defineWorkflow({
 
 Matrix literals determine the exact `matrix` type, `setup` determines the exact
 shared setup type, and the exact JSON return type is retained on the Task.
+Axis names must be non-empty, enumerable strings that are not array indexes.
 Omitting `matrix` creates one Case with `{}`. Setup runs once per Task, Cases
 within that Task run concurrently, and teardown runs once after successful
 setup. Tasks run sequentially in their Workflow.
 
 ## Configure Vitest
 
-Invoker uses Vitest's built-in reporters. The JSON reporter includes each
-Case's data at `assertionResults[].meta.invoker`:
+The JSON reporter includes each Case's data at
+`assertionResults[].meta.invoker`:
 
 ```ts
 // vitest.config.ts
@@ -85,9 +170,13 @@ Run every Workflow or filter to one Task with ordinary Vitest commands:
 
 ```sh
 pnpm vitest run
-pnpm vitest run regressions/model/index.test.ts -t evaluate-models
+pnpm vitest run regressions/workflows/model-regressions.test.ts -t evaluate-models
 ```
 
+Define additional Workflows in separate `*.test.ts` files. Vitest discovers
+them automatically; Invoker does not scan directories or require a central
+index.
+
 The metadata envelope is stable and JSON-compatible:
 
 ```json
@@ -103,6 +192,48 @@ The metadata envelope is stable and JSON-compatible:
 report remains authoritative for status, failures, timing, hierarchy, and
 retries.
 
+## Notify Slack
+
+Invoker's optional Slack reporter posts one `Invoker Report` parent message per
+Vitest run. It places additional Workflow cards in the message thread so every
+Task table remains within Slack's row and character limits. Each card includes
+aggregate results, Workflow metadata, and a table of Task counts and durations.
+A shared footer contains the elapsed span from the first Case start to the final
+Case completion, a localized timestamp, and the optional run link. Final
+failures are posted in the same thread with one reply per failed Task in each
+Workflow. Unhandled run errors are reported once. Delivery failures are
+isolated to the affected reply. Ambiguous transport failures are not retried;
+an explicit Slack rate-limit rejection is reattempted only after its required
+delay.
+
+```ts
+import { slackReporter } from "@akshatmittal/invoker/slack";
+import { defineConfig } from "vitest/config";
+
+const runUrl =
+  process.env.GITHUB_ACTIONS === "true"
+    ? `${process.env.GITHUB_SERVER_URL}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`
+    : undefined;
+
+export default defineConfig({
+  test: {
+    reporters: [
+      "tree",
+      slackReporter({
+        token: process.env.SLACK_BOT_TOKEN!,
+        channel: process.env.SLACK_CHANNEL_ID!,
+        runUrl,
+      }),
+    ],
+  },
+});
+```
+
+Create a Slack app with the `chat:write` bot scope, install it to the workspace,
+and expose its bot token and target channel ID as `SLACK_BOT_TOKEN` and
+`SLACK_CHANNEL_ID`. Invite the bot to private target channels. Slack delivery
+failures produce a warning but do not change Vitest's exit status.
+
 ## GitHub Actions artifacts
 
 Create the output directory before Vitest and upload the report even when the
@@ -122,7 +253,7 @@ queries or reports. Invoker does not upload, index, or persist results itself.
 
 ## v1 scope
 
-Invoker does not provide a CLI, directory discovery, custom runner, custom
-reporter, configuration helper, Task-level parallelism, matrix include/exclude,
-or hosted result storage. Use Vitest configuration and your CI runner for those
-concerns.
+Invoker does not provide a CLI, directory discovery, custom runner, general
+reporter framework, configuration helper, Task-level parallelism, matrix
+include/exclude, or hosted result storage. Use Vitest configuration and your CI
+runner for those concerns.

package/dist/github.d.mts

@@ -0,0 +1,22 @@
+//#region src/github/types.d.ts
+type WorkflowInput = string | number | boolean;
+type GitHubSchedule = {
+  readonly cron: string;
+  readonly timezone?: string;
+  readonly repository: string;
+  readonly workflow: string | number;
+  readonly ref: string;
+  readonly inputs?: Readonly<Record<string, WorkflowInput>>;
+};
+type GitHubScheduleDefinition = {
+  readonly app: {
+    readonly id: number;
+    readonly privateKey: string;
+  };
+  readonly schedules: readonly [GitHubSchedule, ...GitHubSchedule[]];
+};
+//#endregion
+//#region src/github.d.ts
+declare function defineGitHubSchedule(definition: GitHubScheduleDefinition): Promise<void>;
+//#endregion
+export { defineGitHubSchedule };

package/dist/github.mjs

@@ -0,0 +1,353 @@
+import { z } from "zod";
+import { Cron } from "croner";
+import { createAppAuth } from "@octokit/auth-app";
+import { request } from "@octokit/request";
+import { log } from "evlog";
+//#region src/github/client.ts
+const API_VERSION = "2026-03-10";
+const dispatchResponseSchema = z.object({
+	workflow_run_id: z.int().positive(),
+	html_url: z.url()
+});
+const requestFailureSchema = z.object({
+	status: z.int().optional(),
+	response: z.object({ headers: z.object({ "x-github-request-id": z.string().optional() }) }).optional()
+});
+const githubFailures = /* @__PURE__ */ new WeakMap();
+function createGitHubClient(app, signal) {
+	const apiRequest = request.defaults({
+		headers: {
+			accept: "application/vnd.github+json",
+			"x-github-api-version": API_VERSION
+		},
+		request: { signal }
+	});
+	const auth = createAppAuth({
+		appId: app.id,
+		privateKey: app.privateKey,
+		request: apiRequest,
+		log: { warn() {} }
+	});
+	const resolveInstallation = async (target) => {
+		try {
+			const authentication = await auth({ type: "app" });
+			return (await apiRequest("GET /repos/{owner}/{repo}/installation", {
+				owner: target.owner,
+				repo: target.repo,
+				headers: { authorization: `Bearer ${authentication.token}` }
+			})).data.id;
+		} catch (error) {
+			throw githubError(githubFailure(error, "resolve installation", target));
+		}
+	};
+	const installationToken = async (target, installationId) => {
+		try {
+			return (await auth({
+				type: "installation",
+				installationId,
+				repositoryNames: [target.repo],
+				permissions: { actions: "write" }
+			})).token;
+		} catch (error) {
+			throw githubError(githubFailure(error, "create installation token", target));
+		}
+	};
+	const resolveWorkflow = async (target, installationId) => {
+		try {
+			const token = await installationToken(target, installationId);
+			const response = await apiRequest("GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}", {
+				owner: target.owner,
+				repo: target.repo,
+				workflow_id: target.workflow,
+				headers: { authorization: `Bearer ${token}` }
+			});
+			if (response.data.state !== "active") throw new Error("workflow is not active");
+			return response.data.id;
+		} catch (error) {
+			throw githubError(githubFailure(error, "resolve workflow", target));
+		}
+	};
+	const dispatch = async (target) => {
+		try {
+			const token = await installationToken(target, target.installationId);
+			const response = await apiRequest("POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches", {
+				owner: target.owner,
+				repo: target.repo,
+				workflow_id: target.workflowId,
+				ref: target.ref,
+				return_run_details: true,
+				inputs: target.inputs,
+				headers: { authorization: `Bearer ${token}` }
+			});
+			const data = dispatchResponseSchema.parse(response.data);
+			return {
+				runId: data.workflow_run_id,
+				webUrl: data.html_url
+			};
+		} catch (error) {
+			throw githubError(githubFailure(error, "dispatch workflow", target));
+		}
+	};
+	return {
+		dispatch,
+		resolveInstallation,
+		resolveWorkflow
+	};
+}
+function githubFailure(cause, operation, target) {
+	if (cause instanceof Error) {
+		const known = githubFailures.get(cause);
+		if (known) return known;
+	}
+	const parsed = requestFailureSchema.safeParse(cause);
+	const status = parsed.success ? parsed.data.status : void 0;
+	const requestId = parsed.success ? parsed.data.response?.headers["x-github-request-id"] : void 0;
+	return {
+		message: `GitHub ${operation}${target ? ` for ${target.repository} workflow ${String(target.workflow)}` : ""}: ${status === 404 ? "not found or inaccessible" : "request failed"}${status === void 0 ? "" : ` (${status})`}${requestId === void 0 ? "" : ` [request ${requestId}]`}`,
+		operation,
+		repository: target?.repository,
+		workflow: target?.workflow,
+		status,
+		requestId
+	};
+}
+function githubError(failure) {
+	const error = new Error(failure.message);
+	githubFailures.set(error, failure);
+	return error;
+}
+//#endregion
+//#region src/github/config.ts
+const GITHUB_SCHEDULE_OWNER = "GitHub Schedule";
+const inputSchema = z.union([
+	z.string(),
+	z.number().finite(),
+	z.boolean()
+]);
+const timezoneSchema = z.string().refine((timezone) => {
+	try {
+		new Intl.DateTimeFormat(void 0, { timeZone: timezone });
+		return true;
+	} catch {
+		return false;
+	}
+}, "expected a valid IANA timezone");
+const scheduleSchema = z.strictObject({
+	cron: z.string().min(1),
+	timezone: timezoneSchema.default("UTC"),
+	repository: z.string().regex(/^[^/\s]+\/[^/\s]+$/),
+	workflow: z.union([z.int().positive(), z.string().min(1).refine((value) => value.trim() === value && !value.includes("/"))]),
+	ref: z.string().refine((value) => value.trim() !== ""),
+	inputs: z.record(z.string(), inputSchema).refine((inputs) => Object.keys(inputs).length <= 25).refine((inputs) => JSON.stringify(inputs).length <= 65535).optional()
+});
+const definitionSchema = z.strictObject({
+	app: z.strictObject({
+		id: z.int().positive(),
+		privateKey: z.string().min(1)
+	}),
+	schedules: z.array(scheduleSchema).min(1)
+});
+function normalizeDefinition(value) {
+	const result = definitionSchema.safeParse(value);
+	if (!result.success) throw new TypeError(`${GITHUB_SCHEDULE_OWNER}: ${z.prettifyError(result.error)}`);
+	const schedules = result.data.schedules.map((schedule, index) => {
+		let validationJob;
+		try {
+			validationJob = new Cron(schedule.cron, {
+				mode: "5-part",
+				paused: true,
+				timezone: schedule.timezone
+			});
+			validationJob.nextRun();
+		} catch {
+			throw new TypeError(`${GITHUB_SCHEDULE_OWNER}.schedules[${index}].cron: expected a valid five-field cron expression`);
+		} finally {
+			validationJob?.stop();
+		}
+		const separator = schedule.repository.indexOf("/");
+		const owner = schedule.repository.slice(0, separator);
+		const repo = schedule.repository.slice(separator + 1);
+		return {
+			...schedule,
+			owner,
+			repo
+		};
+	});
+	return {
+		app: result.data.app,
+		schedules
+	};
+}
+function workflowKey(schedule) {
+	return `${schedule.repository}\0${String(schedule.workflow)}`;
+}
+//#endregion
+//#region src/github/events.ts
+const SERVICE = "github-schedule";
+function logStartup(schedules, repositories, workflows, failure) {
+	log[failure ? "error" : "info"]({
+		service: SERVICE,
+		event: "github_schedule.startup",
+		schedules,
+		repositories,
+		workflows,
+		...failure ? {
+			outcome: "failure",
+			failure
+		} : { outcome: "success" }
+	});
+}
+function logDispatch(schedule, scheduledAt, result, failure) {
+	log[failure ? "error" : "info"]({
+		service: SERVICE,
+		event: "github_schedule.dispatch",
+		repository: schedule.repository,
+		workflow: schedule.workflow,
+		ref: schedule.ref,
+		cron: schedule.cron,
+		timezone: schedule.timezone,
+		scheduledAt,
+		...failure ? {
+			outcome: "failure",
+			failure
+		} : {
+			outcome: "success",
+			runId: result.runId,
+			runUrl: result.webUrl
+		}
+	});
+}
+function logShutdown(signal, drainedDispatches) {
+	log.info({
+		service: SERVICE,
+		event: "github_schedule.shutdown",
+		signal,
+		drainedDispatches,
+		outcome: "success"
+	});
+}
+//#endregion
+//#region src/github/scheduler.ts
+let schedulerActive = false;
+async function runGitHubSchedule(definition) {
+	let normalized;
+	try {
+		normalized = normalizeDefinition(definition);
+	} catch (error) {
+		logStartup(0, 0, 0, localFailure(error));
+		throw error;
+	}
+	const repositoryCount = new Set(normalized.schedules.map(({ repository }) => repository)).size;
+	const workflowCount = new Set(normalized.schedules.map(workflowKey)).size;
+	if (schedulerActive) {
+		const error = /* @__PURE__ */ new TypeError(`${GITHUB_SCHEDULE_OWNER}: another scheduler is already active`);
+		logStartup(normalized.schedules.length, repositoryCount, workflowCount, localFailure(error));
+		throw error;
+	}
+	schedulerActive = true;
+	const startupAbort = new AbortController();
+	const jobs = [];
+	const inFlight = /* @__PURE__ */ new Set();
+	let state = "starting";
+	let stopSignal;
+	let drainedCount = 0;
+	let resolveStop;
+	const stopRequested = new Promise((resolve) => {
+		resolveStop = resolve;
+	});
+	const isStopping = () => state === "stopping";
+	const removeSignalHandlers = () => {
+		process.removeListener("SIGINT", onSigint);
+		process.removeListener("SIGTERM", onSigterm);
+	};
+	const requestStop = (signal) => {
+		if (isStopping()) return;
+		const duringStartup = state === "starting";
+		state = "stopping";
+		stopSignal = signal;
+		drainedCount = inFlight.size;
+		jobs.forEach((job) => job.stop());
+		removeSignalHandlers();
+		if (duringStartup) startupAbort.abort();
+		resolveStop();
+	};
+	function onSigint() {
+		requestStop("SIGINT");
+	}
+	function onSigterm() {
+		requestStop("SIGTERM");
+	}
+	process.on("SIGINT", onSigint);
+	process.on("SIGTERM", onSigterm);
+	try {
+		const github = createGitHubClient(normalized.app, startupAbort.signal);
+		const installations = /* @__PURE__ */ new Map();
+		for (const schedule of normalized.schedules) if (!installations.has(schedule.repository)) installations.set(schedule.repository, await github.resolveInstallation(schedule));
+		const workflows = /* @__PURE__ */ new Map();
+		for (const schedule of normalized.schedules) {
+			const key = workflowKey(schedule);
+			if (!workflows.has(key)) workflows.set(key, await github.resolveWorkflow(schedule, installations.get(schedule.repository)));
+		}
+		if (isStopping()) {
+			await finishShutdown(inFlight, stopSignal, drainedCount);
+			return;
+		}
+		const schedules = normalized.schedules.map((schedule) => ({
+			...schedule,
+			installationId: installations.get(schedule.repository),
+			workflowId: workflows.get(workflowKey(schedule))
+		}));
+		for (const schedule of schedules) {
+			const job = new Cron(schedule.cron, {
+				catch: true,
+				mode: "5-part",
+				timezone: schedule.timezone
+			}, (currentJob) => {
+				if (state !== "running") return;
+				const scheduledAt = (currentJob.currentRun() ?? /* @__PURE__ */ new Date()).toISOString();
+				const dispatch = github.dispatch(schedule).then((result) => logDispatch(schedule, scheduledAt, result), (cause) => {
+					const failure = githubFailure(cause, "dispatch workflow", schedule);
+					logDispatch(schedule, scheduledAt, void 0, failure);
+					throw new Error(failure.message);
+				});
+				inFlight.add(dispatch);
+				dispatch.then(() => inFlight.delete(dispatch), () => inFlight.delete(dispatch));
+				return dispatch;
+			});
+			jobs.push(job);
+		}
+		state = "running";
+		logStartup(normalized.schedules.length, repositoryCount, workflowCount);
+		await stopRequested;
+		await finishShutdown(inFlight, stopSignal, drainedCount);
+	} catch (error) {
+		if (isStopping()) {
+			await finishShutdown(inFlight, stopSignal, drainedCount);
+			return;
+		}
+		jobs.forEach((job) => job.stop());
+		removeSignalHandlers();
+		schedulerActive = false;
+		const failure = githubFailure(error, "start scheduler");
+		logStartup(normalized.schedules.length, repositoryCount, workflowCount, failure);
+		throw githubError(failure);
+	}
+}
+async function finishShutdown(inFlight, signal, drainedCount) {
+	await Promise.allSettled(inFlight);
+	schedulerActive = false;
+	logShutdown(signal, drainedCount);
+}
+function localFailure(cause) {
+	return {
+		message: cause instanceof Error ? cause.message : `${GITHUB_SCHEDULE_OWNER}: startup validation failed`,
+		operation: "validate configuration"
+	};
+}
+//#endregion
+//#region src/github.ts
+function defineGitHubSchedule(definition) {
+	return runGitHubSchedule(definition);
+}
+//#endregion
+export { defineGitHubSchedule };

package/dist/index.d.mts

@@ -35,10 +35,7 @@ declare const taskDefinitionBrand: unique symbol;
 interface TaskDefinition<Name extends string = string, M extends Matrix = Matrix, Setup = unknown, Output extends JsonValue = JsonValue> {
   readonly name: Name;
   readonly matrix: M;
-  readonly [taskDefinitionBrand]: {
-    readonly setup: Setup;
-    readonly output: Output;
-  };
+  readonly [taskDefinitionBrand]: true;
   readonly setup?: (context: SetupContext<M>) => Awaitable<Setup>;
   readonly run: (context: TaskContext<CaseCoordinates<M>, Setup>) => Awaitable<Output>;
   readonly teardown?: (context: TeardownContext<M, Setup>) => Awaitable<void>;
@@ -62,10 +59,7 @@ declare function defineTask<const Name extends string, const M extends Matrix =
 type AnyTaskDefinition = {
   readonly name: string;
   readonly matrix: Matrix;
-  readonly [taskDefinitionBrand]: {
-    readonly setup: unknown;
-    readonly output: JsonValue;
-  };
+  readonly [taskDefinitionBrand]: true;
 };
 //#endregion
 //#region src/workflow.d.ts

package/dist/index.mjs

@@ -1,4 +1,5 @@
 import { beforeAll, describe, test } from "vitest";
+import { z } from "zod";
 //#region src/task.ts
 const taskDefinitionBrand = Symbol("invoker.task");
 function defineTask(definition) {
@@ -10,72 +11,91 @@ function defineTask(definition) {
 }
 //#endregion
 //#region src/json.ts
-function assertJson(value, owner, path, ancestors = /* @__PURE__ */ new Set()) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return;
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) fail(owner, path, "expected a finite number");
-		return;
-	}
-	if (typeof value !== "object") fail(owner, path, `expected JSON, received ${typeof value}`);
+const scalarSchema = z.union([
+	z.null(),
+	z.string(),
+	z.boolean(),
+	z.number()
+]);
+const nameSchema = z.string().trim().min(1);
+function snapshotJson(value, owner, path, ancestors = /* @__PURE__ */ new Set()) {
+	return cloneJson(value, owner, path, ancestors);
+}
+function cloneJson(value, owner, path, ancestors) {
+	if (scalarSchema.safeParse(value).success) return value;
+	if (!isJsonContainer(value)) fail(owner, path, "expected JSON");
 	if (ancestors.has(value)) fail(owner, path, "cyclic values are not JSON");
 	ancestors.add(value);
-	if (Array.isArray(value)) for (let index = 0; index < value.length; index += 1) {
-		if (!(index in value)) fail(owner, `${path}[${index}]`, "sparse arrays are not JSON");
-		assertJson(value[index], owner, `${path}[${index}]`, ancestors);
-	}
-	else {
+	if (Array.isArray(value)) {
+		const snapshot = [];
+		for (let index = 0; index < value.length; index += 1) {
+			if (!(index in value)) fail(owner, `${path}[${index}]`, "sparse arrays are not JSON");
+			snapshot.push(cloneJson(value[index], owner, `${path}[${index}]`, ancestors));
+		}
+		ancestors.delete(value);
+		return snapshot;
+	} else {
 		assertPlainObject(value, owner, path);
 		if (Object.getOwnPropertySymbols(value).length > 0) fail(owner, path, "JSON objects cannot have symbol keys");
-		for (const [key, child] of Object.entries(value)) assertJson(child, owner, `${path}.${key}`, ancestors);
+		const snapshot = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, cloneJson(child, owner, `${path}.${key}`, ancestors)]));
+		ancestors.delete(value);
+		return snapshot;
 	}
-	ancestors.delete(value);
 }
 function assertPlainObject(value, owner, path) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) fail(owner, path, "expected a plain object");
+	if (Object(value) !== value || Array.isArray(value)) fail(owner, path, "expected a plain object");
 	const prototype = Object.getPrototypeOf(value);
 	if (prototype !== Object.prototype && prototype !== null) fail(owner, path, "expected a plain object");
 }
 function assertName(value, owner, path) {
-	if (typeof value !== "string" || value.trim() === "") fail(owner, path, "expected a non-empty string");
+	if (!nameSchema.safeParse(value).success) fail(owner, path, "expected a non-empty string");
 }
 function assertOnlyKeys(value, allowed, owner) {
 	for (const key of Object.keys(value)) if (!allowed.includes(key)) fail(owner, `.${key}`, "unknown property");
 }
 function canonicalJson(value) {
 	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-	if (value !== null && typeof value === "object") {
-		const object = value;
-		return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(object[key])}`).join(",")}}`;
-	}
+	if (isJsonObject(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
 	return JSON.stringify(value);
 }
 function fail(owner, path, message) {
 	throw new TypeError(`${owner}${path}: ${message}`);
 }
+function isJsonContainer(value) {
+	return value !== null && Object(value) === value;
+}
+function isJsonObject(value) {
+	return isJsonContainer(value) && !Array.isArray(value);
+}
 //#endregion
 //#region src/matrix.ts
+const axisSchema = z.string();
 function expandMatrix(matrix, owner) {
 	if (matrix === void 0) return [{}];
 	assertPlainObject(matrix, owner, ".matrix");
 	let cases = [{}];
-	for (const [axis, values] of Object.entries(matrix)) {
+	for (const candidate of Reflect.ownKeys(matrix)) {
+		const parsed = axisSchema.safeParse(candidate);
+		if (!parsed.success || !Object.prototype.propertyIsEnumerable.call(matrix, candidate)) fail(owner, ".matrix", "axis names must be enumerable strings");
+		const axis = parsed.data;
 		if (axis.trim() === "") fail(owner, ".matrix", "axis names must not be empty");
+		const index = Number(axis);
+		if (Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === axis) fail(owner, `.matrix.${axis}`, "array-index axis names cannot preserve insertion order");
+		const values = matrix[axis];
 		if (!Array.isArray(values)) fail(owner, `.matrix.${axis}`, "expected an array");
 		if (values.length === 0) fail(owner, `.matrix.${axis}`, "expected at least one value");
-		values.forEach((value, index) => {
-			assertJson(value, owner, `.matrix.${axis}[${index}]`);
-		});
-		cases = cases.flatMap((coordinates) => values.map((value) => ({
+		const snapshots = values.map((value, index) => snapshotJson(value, owner, `.matrix.${axis}[${index}]`));
+		const axisValues = /* @__PURE__ */ new Set();
+		for (const [index, value] of snapshots.entries()) {
+			const key = canonicalJson(value);
+			if (axisValues.has(key)) fail(owner, `.matrix.${axis}[${index}]`, `duplicate axis value ${JSON.stringify(value)}`);
+			axisValues.add(key);
+		}
+		cases = cases.flatMap((coordinates) => snapshots.map((value) => ({
 			...coordinates,
 			[axis]: value
 		})));
 	}
-	const coordinates = /* @__PURE__ */ new Set();
-	for (const value of cases) {
-		const key = canonicalJson(value);
-		if (coordinates.has(key)) fail(owner, ".matrix", `duplicate coordinate ${JSON.stringify(value)}`);
-		coordinates.add(key);
-	}
 	return cases;
 }
 function caseName(matrix, index) {
@@ -109,8 +129,7 @@ function defineWorkflow(definition) {
 						setup,
 						vitest
 					});
-					assertJson(output, `Task ${JSON.stringify(prepared.task.name)}`, ".output");
-					meta.invoker.output = output;
+					meta.invoker.output = snapshotJson(output, `Task ${JSON.stringify(prepared.task.name)}`, ".output");
 				});
 			}
 		});
@@ -123,51 +142,49 @@ function prepareWorkflow(definition) {
 		"metadata",
 		"tasks"
 	], "Workflow");
-	assertName(definition.name, "Workflow", ".name");
-	const metadata = definition.metadata;
-	if (metadata !== void 0) {
-		assertJson(metadata, `Workflow ${JSON.stringify(definition.name)}`, ".metadata");
-		assertPlainObject(metadata, `Workflow ${JSON.stringify(definition.name)}`, ".metadata");
-	}
-	if (!Array.isArray(definition.tasks) || definition.tasks.length === 0) fail("Workflow", ".tasks", "expected a non-empty Task tuple");
+	const { name, metadata: workflowMetadata, tasks: taskDefinitions } = definition;
+	assertName(name, "Workflow", ".name");
+	const metadata = workflowMetadata === void 0 ? void 0 : snapshotJson(workflowMetadata, `Workflow ${JSON.stringify(name)}`, ".metadata");
+	if (metadata !== void 0) assertPlainObject(metadata, `Workflow ${JSON.stringify(name)}`, ".metadata");
+	if (!Array.isArray(taskDefinitions) || taskDefinitions.length === 0) fail("Workflow", ".tasks", "expected a non-empty Task tuple");
 	const names = /* @__PURE__ */ new Set();
-	const tasks = definition.tasks.map((value, index) => {
-		const owner = `Workflow ${JSON.stringify(definition.name)} Task ${index + 1}`;
-		assertPlainObject(value, owner, "");
-		const task = value;
-		if (task[taskDefinitionBrand] !== true) fail(owner, "", "expected a Task created by defineTask");
-		assertOnlyKeys(task, [
-			"name",
-			"matrix",
-			"setup",
-			"run",
-			"teardown"
-		], owner);
-		assertName(task.name, owner, ".name");
-		if (names.has(task.name)) fail(owner, ".name", `duplicate Task name ${JSON.stringify(task.name)}`);
-		names.add(task.name);
-		if (typeof task.run !== "function") fail(owner, ".run", "expected a function");
-		if (task.setup !== void 0 && typeof task.setup !== "function") fail(owner, ".setup", "expected a function");
-		if (task.teardown !== void 0 && typeof task.teardown !== "function") fail(owner, ".teardown", "expected a function");
-		if (task.teardown && !task.setup) fail(owner, ".teardown", "requires setup");
-		const cases = expandMatrix(task.matrix, `Task ${JSON.stringify(task.name)}`);
-		return {
-			task,
-			cases,
-			names: cases.map(caseName),
-			metadata: cases.map((matrix) => metadata === void 0 ? {
-				schema: 1,
-				matrix
-			} : {
-				schema: 1,
-				matrix,
-				metadata
-			})
-		};
-	});
 	return {
-		name: definition.name,
-		tasks
+		name,
+		tasks: taskDefinitions.map((value, index) => {
+			const owner = `Workflow ${JSON.stringify(name)} Task ${index + 1}`;
+			assertPlainObject(value, owner, "");
+			if (value[taskDefinitionBrand] !== true) fail(owner, "", "expected a Task created by defineTask");
+			const task = value;
+			assertOnlyKeys(task, [
+				"name",
+				"matrix",
+				"setup",
+				"run",
+				"teardown"
+			], owner);
+			const taskSnapshot = { ...task };
+			assertName(taskSnapshot.name, owner, ".name");
+			if (names.has(taskSnapshot.name)) fail(owner, ".name", `duplicate Task name ${JSON.stringify(taskSnapshot.name)}`);
+			names.add(taskSnapshot.name);
+			if (!z.function().safeParse(taskSnapshot.run).success) fail(owner, ".run", "expected a function");
+			if (taskSnapshot.setup !== void 0 && !z.function().safeParse(taskSnapshot.setup).success) fail(owner, ".setup", "expected a function");
+			if (taskSnapshot.teardown !== void 0 && !z.function().safeParse(taskSnapshot.teardown).success) fail(owner, ".teardown", "expected a function");
+			if (taskSnapshot.teardown && !taskSnapshot.setup) fail(owner, ".teardown", "requires setup");
+			const cases = expandMatrix(taskSnapshot.matrix, `Task ${JSON.stringify(taskSnapshot.name)}`);
+			return {
+				task: taskSnapshot,
+				cases,
+				names: cases.map(caseName),
+				metadata: cases.map((matrix) => metadata === void 0 ? {
+					schema: 1,
+					matrix
+				} : {
+					schema: 1,
+					matrix,
+					metadata
+				})
+			};
+		})
 	};
 }
 //#endregion

package/dist/slack.d.mts

@@ -0,0 +1,10 @@
+import { Reporter } from "vitest/reporters";
+//#region src/slack/reporter.d.ts
+type SlackReporterOptions = {
+  readonly token: string;
+  readonly channel: string;
+  readonly runUrl?: string;
+};
+declare function slackReporter(options: SlackReporterOptions): Reporter;
+//#endregion
+export { type SlackReporterOptions, slackReporter };

package/dist/slack.mjs

@@ -0,0 +1,425 @@
+import { z } from "zod";
+import { WebAPIRateLimitedError, WebClient } from "@slack/web-api";
+import { setTimeout } from "node:timers/promises";
+//#region src/slack/report.ts
+const stringSchema = z.string();
+const jsonObjectSchema = z.record(stringSchema, z.json());
+const invokerMetaSchema = z.strictObject({
+	schema: z.literal(1),
+	matrix: jsonObjectSchema,
+	metadata: jsonObjectSchema.optional(),
+	output: z.json().optional()
+});
+const testMetaSchema = z.object({ invoker: invokerMetaSchema.optional() });
+const errorMessageSchema = z.object({ message: stringSchema });
+const errorStackSchema = z.object({ stack: stringSchema });
+const TABLE_ROW_LIMIT = 100;
+const TABLE_CHARACTER_LIMIT = 1e4;
+const SECTION_CHARACTER_LIMIT = 3e3;
+const NAME_CHARACTER_LIMIT = 200;
+const METADATA_CHARACTER_LIMIT = 1800;
+function collectWorkflowReports(modules) {
+	const workflows = /* @__PURE__ */ new Map();
+	for (const module of modules) for (const testCase of module.children.allTests()) {
+		const meta = testMetaSchema.safeParse(testCase.meta());
+		const invoker = meta.success ? meta.data.invoker : void 0;
+		const taskSuite = testCase.parent;
+		const workflowSuite = taskSuite.type === "suite" ? taskSuite.parent : void 0;
+		if (!invoker || taskSuite.type !== "suite" || workflowSuite?.type !== "suite") continue;
+		let workflow = workflows.get(workflowSuite);
+		if (!workflow) {
+			workflow = {
+				name: workflowSuite.name,
+				module,
+				suite: workflowSuite,
+				metadata: invoker.metadata,
+				tasks: /* @__PURE__ */ new Map()
+			};
+			workflows.set(workflowSuite, workflow);
+		}
+		let task = workflow.tasks.get(taskSuite);
+		if (!task) {
+			task = {
+				name: taskSuite.name,
+				suite: taskSuite,
+				total: 0,
+				passed: 0,
+				retried: 0,
+				failed: 0,
+				skipped: 0,
+				incomplete: 0,
+				failures: []
+			};
+			workflow.tasks.set(taskSuite, task);
+		}
+		task.total += 1;
+		const result = testCase.result();
+		const diagnostic = testCase.diagnostic();
+		task[result.state === "pending" ? "incomplete" : result.state] += 1;
+		if ((diagnostic?.retryCount ?? 0) > 0) task.retried += 1;
+		if (diagnostic) {
+			task.startedAt = Math.min(task.startedAt ?? diagnostic.startTime, diagnostic.startTime);
+			task.endedAt = Math.max(task.endedAt ?? 0, diagnostic.startTime + diagnostic.duration);
+		}
+		if (result.state === "failed") task.failures.push({
+			task: task.name,
+			caseName: testCase.name,
+			matrix: invoker.matrix,
+			messages: result.errors.map(errorMessage)
+		});
+	}
+	return [...workflows.values()].map((workflow) => {
+		const failures = [];
+		addErrors(failures, workflow.suite.errors());
+		addErrors(failures, workflow.module.errors());
+		const collectedTasks = [...workflow.tasks.values()];
+		for (const task of collectedTasks) {
+			failures.push(...task.failures);
+			addErrors(failures, task.suite.errors(), task.name);
+		}
+		const { startedAt, endedAt } = timeSpan(collectedTasks);
+		return {
+			name: workflow.name,
+			metadata: workflow.metadata,
+			tasks: collectedTasks.map(({ suite: _suite, failures: _failures, startedAt, endedAt, ...task }) => ({
+				...task,
+				duration: startedAt === void 0 || endedAt === void 0 ? 0 : endedAt - startedAt
+			})),
+			failures: deduplicateFailures(failures),
+			startedAt,
+			endedAt
+		};
+	});
+}
+function summaryMessages(reports, runUrl) {
+	const timestamp = Math.floor(Date.now() / 1e3);
+	const { startedAt, endedAt } = timeSpan(reports);
+	const footer = [
+		`Elapsed: ${formatDuration(startedAt === void 0 || endedAt === void 0 ? 0 : endedAt - startedAt)}`,
+		`<!date^${timestamp}^{date_short_pretty} at {time}|${(/* @__PURE__ */ new Date(timestamp * 1e3)).toISOString()}>`,
+		...runUrl ? [`<${escapeSlackControl(runUrl)}|View run>`] : []
+	].join(" • ");
+	return reports.flatMap(workflowAttachments).map((attachment, index) => ({
+		text: index === 0 ? "Invoker Report" : "Invoker Report (continued)",
+		attachments: [attachment, ...index === 0 ? [{ blocks: [{
+			type: "context",
+			elements: [{
+				type: "mrkdwn",
+				text: footer
+			}]
+		}] }] : []]
+	}));
+}
+function workflowAttachments(report) {
+	const tables = taskTables(report.tasks);
+	return tables.map((rows, index) => workflowAttachment(report, rows, index, tables.length));
+}
+function workflowAttachment(report, rows, index, pages) {
+	const totals = taskTotals(report.tasks);
+	const status = workflowStatus(report);
+	const metadata = metadataText(report.metadata);
+	const page = pages > 1 ? ` (${index + 1}/${pages})` : "";
+	const headline = `${status.emoji} *${escapeSlack(truncate(report.name, NAME_CHARACTER_LIMIT))} — ${totals.passed}/${totals.total} passed${page}*`;
+	return {
+		color: status.color,
+		blocks: [
+			{
+				type: "section",
+				text: {
+					type: "mrkdwn",
+					text: headline
+				}
+			},
+			...metadata ? [{
+				type: "context",
+				elements: [{
+					type: "mrkdwn",
+					text: metadata
+				}]
+			}] : [],
+			{
+				type: "table",
+				column_settings: [
+					{ is_wrapped: true },
+					{ align: "right" },
+					{ align: "right" },
+					{ align: "right" },
+					{ align: "right" },
+					{ align: "right" }
+				],
+				rows
+			}
+		]
+	};
+}
+function failureMessages(report) {
+	return [...Map.groupBy(report.failures, (failure) => failure.task)].flatMap(([task, failures]) => {
+		const title = escapeSlack(truncate(task ?? "Workflow errors", NAME_CHARACTER_LIMIT));
+		const workflow = `*Workflow:* ${escapeSlack(truncate(report.name, NAME_CHARACTER_LIMIT))}`;
+		const metadata = metadataText(report.metadata);
+		const context = metadata ? `${workflow}  •  ${metadata}` : workflow;
+		return chunk(failures.map((failure) => {
+			return `${failure.caseName ? `*${escapeSlack(failure.caseName)}*` : task ? "*Task error*" : "*Workflow error*"}${failure.matrix ? `\nMatrix: ${escapeSlack(JSON.stringify(failure.matrix))}` : ""}${failure.messages.map((message) => `\n• ${escapeSlack(message)}`).join("")}`;
+		}), 3e3).map((details, index, messages) => {
+			const part = messages.length > 1 ? ` (${index + 1}/${messages.length})` : "";
+			return {
+				text: `${truncate(report.name, NAME_CHARACTER_LIMIT)} › ${truncate(task ?? "Workflow", NAME_CHARACTER_LIMIT)} — ${failures.length} failed${part}`,
+				attachments: [{
+					color: "danger",
+					blocks: [
+						{
+							type: "section",
+							text: {
+								type: "mrkdwn",
+								text: `🔴 *${title} — ${failures.length} failed${part}*`
+							}
+						},
+						{
+							type: "context",
+							elements: [{
+								type: "mrkdwn",
+								text: context
+							}]
+						},
+						{
+							type: "section",
+							text: {
+								type: "mrkdwn",
+								text: details
+							}
+						}
+					]
+				}]
+			};
+		});
+	});
+}
+function unhandledErrorMessages(errors) {
+	const messages = [...new Set(errors.map(errorMessage))];
+	return chunk(messages.map((message) => `• ${escapeSlack(message)}`), SECTION_CHARACTER_LIMIT).map((details, index, chunks) => {
+		const part = chunks.length > 1 ? ` (${index + 1}/${chunks.length})` : "";
+		return {
+			text: `Invoker run — ${messages.length} unhandled error${messages.length === 1 ? "" : "s"}${part}`,
+			attachments: [{
+				color: "danger",
+				blocks: [{
+					type: "section",
+					text: {
+						type: "mrkdwn",
+						text: `🔴 *Run errors${part}*`
+					}
+				}, {
+					type: "section",
+					text: {
+						type: "mrkdwn",
+						text: details
+					}
+				}]
+			}]
+		};
+	});
+}
+function addErrors(failures, errors, task) {
+	const messages = errors.map(errorMessage);
+	if (messages.length > 0) failures.push({
+		task,
+		messages
+	});
+}
+function errorMessage(cause) {
+	const message = errorMessageSchema.safeParse(cause);
+	if (message.success) return message.data.message;
+	const stack = errorStackSchema.safeParse(cause);
+	if (stack.success) return stack.data.stack.split("\n", 1)[0];
+	return String(cause);
+}
+function deduplicateFailures(failures) {
+	const seen = /* @__PURE__ */ new Set();
+	return failures.flatMap((failure) => {
+		const messages = failure.messages.filter((message) => {
+			const key = JSON.stringify([
+				failure.task,
+				failure.caseName,
+				failure.matrix,
+				message
+			]);
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		});
+		return messages.length > 0 ? [{
+			...failure,
+			messages
+		}] : [];
+	});
+}
+function escapeSlack(value) {
+	return escapeSlackControl(value).replaceAll("*", "∗").replaceAll("_", "＿").replaceAll("~", "∼").replaceAll("`", "ˋ");
+}
+function escapeSlackControl(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function taskTotals(tasks) {
+	return tasks.reduce((totals, task) => ({
+		total: totals.total + task.total,
+		passed: totals.passed + task.passed
+	}), {
+		total: 0,
+		passed: 0
+	});
+}
+function workflowStatus(report) {
+	if (report.failures.length > 0 || report.tasks.some((task) => task.failed > 0)) return {
+		emoji: "🔴",
+		color: "danger"
+	};
+	if (report.tasks.some((task) => task.retried > 0 || task.skipped > 0 || task.incomplete > 0)) return {
+		emoji: "🟡",
+		color: "warning"
+	};
+	return {
+		emoji: "🟢",
+		color: "good"
+	};
+}
+function metadataText(metadata) {
+	if (!metadata || Object.keys(metadata).length === 0) return void 0;
+	return truncate(Object.entries(metadata).map(([key, value]) => {
+		const string = stringSchema.safeParse(value);
+		return `*${escapeSlack(key)}:* ${escapeSlack(string.success ? string.data : JSON.stringify(value))}`;
+	}).join("  •  "), METADATA_CHARACTER_LIMIT);
+}
+function rawCell(text) {
+	return {
+		type: "raw_text",
+		text
+	};
+}
+function taskTables(tasks) {
+	const header = [
+		"Task",
+		"Passed",
+		"Retries",
+		"Failed",
+		"Skipped",
+		"Time"
+	].map(rawCell);
+	const headerCharacters = rowCharacters(header);
+	const tables = [];
+	let rows = [header];
+	let characters = headerCharacters;
+	for (const task of tasks) {
+		const values = [
+			String(task.passed),
+			String(task.retried),
+			String(task.failed),
+			String(task.skipped),
+			formatDuration(task.duration)
+		];
+		const taskNameLimit = TABLE_CHARACTER_LIMIT - headerCharacters - values.reduce((total, value) => total + value.length, 0);
+		const row = [truncate(task.name, taskNameLimit), ...values].map(rawCell);
+		const rowLength = rowCharacters(row);
+		if (rows.length === TABLE_ROW_LIMIT || characters + rowLength > TABLE_CHARACTER_LIMIT) {
+			tables.push(rows);
+			rows = [header];
+			characters = headerCharacters;
+		}
+		rows.push(row);
+		characters += rowLength;
+	}
+	tables.push(rows);
+	return tables;
+}
+function rowCharacters(row) {
+	return row.reduce((total, cell) => total + cell.text.length, 0);
+}
+function formatDuration(milliseconds) {
+	if (milliseconds < 1e3) return `${Math.round(milliseconds)}ms`;
+	return `${(milliseconds / 1e3).toFixed(1)}s`;
+}
+function chunk(entries, limit) {
+	const chunks = [];
+	for (const entry of entries) {
+		const value = entry.length > limit ? `${entry.slice(0, limit - 1)}…` : entry;
+		const previous = chunks.at(-1);
+		if (previous && previous.length + value.length + 2 <= limit) chunks[chunks.length - 1] = `${previous}\n\n${value}`;
+		else chunks.push(value);
+	}
+	return chunks;
+}
+function truncate(value, limit) {
+	return value.length > limit ? `${value.slice(0, limit - 1)}…` : value;
+}
+function timeSpan(values) {
+	let startedAt;
+	let endedAt;
+	for (const value of values) {
+		if (value.startedAt !== void 0) startedAt = Math.min(startedAt ?? value.startedAt, value.startedAt);
+		if (value.endedAt !== void 0) endedAt = Math.max(endedAt ?? value.endedAt, value.endedAt);
+	}
+	return {
+		startedAt,
+		endedAt
+	};
+}
+//#endregion
+//#region src/slack/reporter.ts
+function slackReporter(options) {
+	const client = new WebClient(options.token, {
+		rejectRateLimitedCalls: true,
+		retryConfig: { retries: 0 },
+		timeout: 1e4
+	});
+	const postMessage = async (arguments_) => {
+		try {
+			return await client.chat.postMessage(arguments_);
+		} catch (error) {
+			if (!(error instanceof WebAPIRateLimitedError)) throw error;
+			await setTimeout(error.retryAfter * 1e3);
+			return client.chat.postMessage(arguments_);
+		}
+	};
+	return { async onTestRunEnd(modules, unhandledErrors) {
+		const reports = collectWorkflowReports(modules);
+		if (reports.length === 0) return;
+		const [parentMessage, ...continuations] = summaryMessages(reports, options.runUrl);
+		if (!parentMessage) return;
+		let parentTimestamp;
+		try {
+			const parentArguments = {
+				channel: options.channel,
+				...parentMessage,
+				mrkdwn: false,
+				unfurl_links: false
+			};
+			parentTimestamp = (await postMessage(parentArguments)).ts;
+		} catch {
+			console.warn("[invoker] Could not post the Slack report.");
+			return;
+		}
+		const replies = [
+			...continuations,
+			...reports.flatMap(failureMessages),
+			...unhandledErrorMessages(unhandledErrors)
+		];
+		if (replies.length > 0 && !parentTimestamp) {
+			console.warn("[invoker] Slack did not return a timestamp for the report thread.");
+			return;
+		}
+		let failedMessages = 0;
+		for (const reply of replies) try {
+			await postMessage({
+				channel: options.channel,
+				...reply,
+				thread_ts: parentTimestamp,
+				mrkdwn: false,
+				unfurl_links: false
+			});
+		} catch {
+			failedMessages += 1;
+		}
+		if (failedMessages > 0) console.warn(`[invoker] Could not post ${failedMessages} Slack report message${failedMessages === 1 ? "" : "s"}.`);
+	} };
+}
+//#endregion
+export { slackReporter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akshatmittal/invoker",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Typed matrix-driven regression workflows for Vitest.",
   "keywords": [
     "matrix",
@@ -27,11 +27,27 @@
     ".": {
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
+    },
+    "./github": {
+      "types": "./dist/github.d.mts",
+      "import": "./dist/github.mjs"
+    },
+    "./slack": {
+      "types": "./dist/slack.d.mts",
+      "import": "./dist/slack.mjs"
     }
   },
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@octokit/auth-app": "^8.3.0",
+    "@octokit/request": "^10.0.13",
+    "@slack/web-api": "^8.0.0",
+    "croner": "^10.0.1",
+    "evlog": "^2.26.0",
+    "zod": "^4.4.3"
+  },
   "devDependencies": {
     "@types/node": "^24.13.3",
     "tsdown": "^0.22.14",
@@ -42,6 +58,11 @@
   "peerDependencies": {
     "vitest": "^4.1.10"
   },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": "^24.18.1"
   },