@protobase/workflows 0.0.0-stage → 0.68.0

package/dist/definition/types.d.ts

@@ -0,0 +1,92 @@
+//#region src/definition/types.d.ts
+/** A value written in a definition: JSON, where a string `{% ... %}` is a JSONata expression evaluated when the state runs. */
+export type Template = unknown;
+export type Retrier = {
+  ErrorEquals: string[];
+  IntervalSeconds?: number;
+  MaxAttempts?: number;
+  BackoffRate?: number;
+  MaxDelaySeconds?: number;
+};
+export type Catcher = {
+  ErrorEquals: string[];
+  Next: string;
+  Output?: Template;
+  Assign?: Record<string, Template>;
+};
+type Common = {
+  Comment?: string;
+  Output?: Template;
+  Assign?: Record<string, Template>;
+  QueryLanguage?: 'JSONata';
+};
+type Flow = {
+  Next?: string;
+  End?: boolean;
+};
+export type PassState = Common & Flow & {
+  Type: 'Pass';
+};
+export type TaskState = Common & Flow & {
+  Type: 'Task';
+  Resource: string;
+  Arguments?: Template;
+  TimeoutSeconds?: number;
+  Retry?: Retrier[];
+  Catch?: Catcher[];
+};
+export type ChoiceRule = {
+  Condition: string;
+  Next: string;
+  Comment?: string;
+  Output?: Template;
+  Assign?: Record<string, Template>;
+};
+export type ChoiceState = Common & {
+  Type: 'Choice';
+  Choices: ChoiceRule[];
+  Default?: string;
+};
+export type WaitState = Common & Flow & {
+  Type: 'Wait';
+  Seconds?: number | string;
+  Timestamp?: string;
+};
+export type SucceedState = Omit<Common, 'Assign'> & {
+  Type: 'Succeed';
+};
+export type FailState = Omit<Common, 'Output' | 'Assign'> & {
+  Type: 'Fail';
+  Error?: string;
+  Cause?: string;
+};
+export type MapState = Common & Flow & {
+  Type: 'Map';
+  Items: Template;
+  ItemProcessor: Machine;
+  MaxConcurrency?: number;
+  Retry?: Retrier[];
+  Catch?: Catcher[];
+};
+export type State = PassState | TaskState | ChoiceState | WaitState | SucceedState | FailState | MapState;
+/** States and where they start: a whole state machine, or a Map's item processor. */
+export type Machine = {
+  StartAt: string;
+  States: Record<string, State>;
+  Comment?: string;
+};
+/** The state machine of a workflow: the States Language with JSONata expressions, in the named-reads profile. */
+export type StateMachine = Machine & {
+  QueryLanguage: 'JSONata';
+};
+/** What starts a workflow's runs: one key, `manual` or a trigger type `<plugin>:<key>`, holding its input. */
+export type Trigger = {
+  manual?: Record<string, unknown>;
+  [type: `${string}:${string}`]: Record<string, unknown>;
+};
+/** A workflow definition: its trigger, and the state machine a run runs from `StartAt`. */
+export type Definition = {
+  trigger: Trigger;
+  stateMachine: StateMachine;
+};
+//#endregion

package/dist/definition/visible.js

@@ -0,0 +1,52 @@
+import { edges } from "./graph.js";
+//#region src/definition/visible.ts
+const passedOn = (state) => {
+	const own = Object.keys("Assign" in state && state.Assign || {});
+	const along = [];
+	if ("Next" in state && state.Next !== void 0) along.push({
+		target: state.Next,
+		names: own
+	});
+	if (state.Type === "Choice") {
+		for (const rule of state.Choices) along.push({
+			target: rule.Next,
+			names: Object.keys(rule.Assign ?? state.Assign ?? {})
+		});
+		if (state.Default !== void 0) along.push({
+			target: state.Default,
+			names: own
+		});
+	}
+	if ("Catch" in state) for (const catcher of state.Catch ?? []) along.push({
+		target: catcher.Next,
+		names: Object.keys(catcher.Assign ?? {})
+	});
+	return along;
+};
+const reachedFrom = (machine, start) => {
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [start];
+	while (stack.length > 0) {
+		const name = stack.pop();
+		const state = machine.States[name];
+		if (seen.has(name) || !state) continue;
+		seen.add(name);
+		stack.push(...edges(state).map((edge) => edge.target));
+	}
+	return seen;
+};
+/**
+* The variables each state of a machine may read: those of the outer scopes, and each one assigned on an edge some path
+* from `StartAt` takes before it. A state's own Assign takes effect from the next state on, and only along the edges
+* that assign it: a Choice rule's along its Next, a catcher's along its own.
+*/
+const visibleVariables = (machine, outer) => {
+	const visible = new Map(Object.keys(machine.States).map((name) => [name, new Set(outer)]));
+	for (const state of Object.values(machine.States)) for (const { target, names } of passedOn(state)) {
+		if (names.length === 0) continue;
+		for (const later of reachedFrom(machine, target)) for (const variable of names) visible.get(later)?.add(variable);
+	}
+	return visible;
+};
+//#endregion
+export { visibleVariables };

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { Problem, problemText } from "./definition/problem.js";
+import { Catcher, ChoiceRule, ChoiceState, Definition, Machine, MapState, Retrier, State, StateMachine, TaskState, Trigger } from "./definition/types.js";
+import { TriggerCheck } from "./definition/check-trigger.js";
+import { CheckOptions, checkDefinition } from "./definition/check-definition.js";
+import { definitionSchema } from "./definition/schema.js";
+import { limits } from "./limits.js";
+import { nestingDepth } from "./nesting.js";
+import { ErrorOutput, StepError } from "./run/errors.js";
+import { Redactor, redacted, secretRedactor, shortestSecret } from "./run/redact.js";
+import { LoadedRun, RunChange, RunStatus, RunStore, SavedStep, SegmentQueue, StepLog, StepRecord, StepStatus, TaskContext, TaskHandler, TaskHandlers } from "./run/port.js";
+import { EarlierStep, rerunSteps } from "./run/rerun.js";
+import { Runner, RunnerPort, createRunner } from "./run/runner.js";
+import { SegmentInput, runSegment } from "./run/segment.js";
+import { LoadedPlugin, loadPlugins } from "./plugin/load-plugins.js";
+import { StepWiring, stepHandlers } from "./plugin/step-handlers.js";
+import { triggerChecks } from "./plugin/trigger-checks.js";
+import { TypeEntry, Unavailable, typeList } from "./plugin/type-list.js";
+import { CatalogEntry, TypeCatalog, typeCatalog } from "./plugin/type-catalog.js";
+export { type CatalogEntry, type Catcher, type CheckOptions, type ChoiceRule, type ChoiceState, type Definition, type EarlierStep, type ErrorOutput, type LoadedPlugin, type LoadedRun, type Machine, type MapState, type Problem, type Redactor, type Retrier, type RunChange, type RunStatus, type RunStore, type Runner, type RunnerPort, type SavedStep, type SegmentInput, type SegmentQueue, type State, type StateMachine, StepError, type StepLog, type StepRecord, type StepStatus, type StepWiring, type TaskContext, type TaskHandler, type TaskHandlers, type TaskState, type Trigger, type TriggerCheck, type TypeCatalog, type TypeEntry, type Unavailable, checkDefinition, createRunner, definitionSchema, limits, loadPlugins, nestingDepth, problemText, redacted, rerunSteps, runSegment, secretRedactor, shortestSecret, stepHandlers, triggerChecks, typeCatalog, typeList };

package/dist/index.js

@@ -0,0 +1,16 @@
+import { limits } from "./limits.js";
+import { definitionSchema } from "./definition/schema.js";
+import { problemText } from "./definition/problem.js";
+import { nestingDepth } from "./nesting.js";
+import { checkDefinition } from "./definition/check-definition.js";
+import { StepError } from "./run/errors.js";
+import { redacted, secretRedactor, shortestSecret } from "./run/redact.js";
+import { rerunSteps } from "./run/rerun.js";
+import { runSegment } from "./run/segment.js";
+import { createRunner } from "./run/runner.js";
+import { loadPlugins } from "./plugin/load-plugins.js";
+import { stepHandlers } from "./plugin/step-handlers.js";
+import { triggerChecks } from "./plugin/trigger-checks.js";
+import { typeList } from "./plugin/type-list.js";
+import { typeCatalog } from "./plugin/type-catalog.js";
+export { StepError, checkDefinition, createRunner, definitionSchema, limits, loadPlugins, nestingDepth, problemText, redacted, rerunSteps, runSegment, secretRedactor, shortestSecret, stepHandlers, triggerChecks, typeCatalog, typeList };

package/dist/limits.d.ts

@@ -0,0 +1,39 @@
+//#region src/limits.d.ts
+/** The fixed limits of workflows, checked when a definition is saved or while it runs; each fails closed. */
+export declare const limits: {
+  /** A definition's size as JSON, and the length of one expression's source. */
+  readonly definitionBytes: number;
+  /** How deeply a definition's arrays and objects nest, so no walk of it overflows the call stack. */
+  readonly definitionDepth: 256;
+  readonly expressionLength: 4096;
+  /** States in one definition, the ones inside Maps counted. */
+  readonly states: 100;
+  /** The longest a Task may run before it fails with `States.Timeout`, and its default. */
+  readonly taskTimeoutSeconds: 300;
+  readonly defaultTaskTimeoutSeconds: 300;
+  /** The longest wait one Wait state may give in seconds: 366 days. */
+  readonly waitSeconds: number;
+  /** Retries of one retrier after the first try, and the longest wait between two. */
+  readonly retryAttempts: 19;
+  readonly retryDelaySeconds: number;
+  /** Items a Map runs at once; 0 or none means this limit. */
+  readonly mapConcurrency: 20;
+  /** Items one Map takes. */
+  readonly mapItems: 10000;
+  /** Steps one run may take, every attempt and every Map item's steps counted. */
+  readonly runSteps: 50000;
+  /** The size of each value a step saves (its input, output and variables), as JSON. */
+  readonly valueBytes: number;
+  /** Log lines one step keeps, and the length of each. */
+  readonly logLines: 100;
+  readonly logLineLength: 1000;
+  /** How long one expression may evaluate, and how deep it may nest. */
+  readonly expressionMs: 1000;
+  readonly expressionDepth: 300;
+  /** How long one segment runs steps before it hands the rest of the run to the next segment. */
+  readonly segmentMs: 60000;
+  /** A run's input: its size as JSON and how deeply its arrays and objects nest. */
+  readonly inputBytes: number;
+  readonly inputDepth: 64;
+};
+//#endregion

package/dist/limits.js

@@ -0,0 +1,40 @@
+//#region src/limits.ts
+/** The fixed limits of workflows, checked when a definition is saved or while it runs; each fails closed. */
+const limits = {
+	/** A definition's size as JSON, and the length of one expression's source. */
+	definitionBytes: 262144,
+	/** How deeply a definition's arrays and objects nest, so no walk of it overflows the call stack. */
+	definitionDepth: 256,
+	expressionLength: 4096,
+	/** States in one definition, the ones inside Maps counted. */
+	states: 100,
+	/** The longest a Task may run before it fails with `States.Timeout`, and its default. */
+	taskTimeoutSeconds: 300,
+	defaultTaskTimeoutSeconds: 300,
+	/** The longest wait one Wait state may give in seconds: 366 days. */
+	waitSeconds: 31622400,
+	/** Retries of one retrier after the first try, and the longest wait between two. */
+	retryAttempts: 19,
+	retryDelaySeconds: 86400,
+	/** Items a Map runs at once; 0 or none means this limit. */
+	mapConcurrency: 20,
+	/** Items one Map takes. */
+	mapItems: 1e4,
+	/** Steps one run may take, every attempt and every Map item's steps counted. */
+	runSteps: 5e4,
+	/** The size of each value a step saves (its input, output and variables), as JSON. */
+	valueBytes: 1048576,
+	/** Log lines one step keeps, and the length of each. */
+	logLines: 100,
+	logLineLength: 1e3,
+	/** How long one expression may evaluate, and how deep it may nest. */
+	expressionMs: 1e3,
+	expressionDepth: 300,
+	/** How long one segment runs steps before it hands the rest of the run to the next segment. */
+	segmentMs: 6e4,
+	/** A run's input: its size as JSON and how deeply its arrays and objects nest. */
+	inputBytes: 1048576,
+	inputDepth: 64
+};
+//#endregion
+export { limits };

package/dist/nesting.d.ts

@@ -0,0 +1,7 @@
+//#region src/nesting.d.ts
+/**
+ * How deeply a value's arrays and objects nest, walked with a stack of its own so no value can overflow the call stack;
+ * it stops counting once past `most`, returning `most + 1`.
+ */
+export declare const nestingDepth: (value: unknown, most: number) => number;
+//#endregion

package/dist/nesting.js

@@ -0,0 +1,19 @@
+//#region src/nesting.ts
+/**
+* How deeply a value's arrays and objects nest, walked with a stack of its own so no value can overflow the call stack;
+* it stops counting once past `most`, returning `most + 1`.
+*/
+const nestingDepth = (value, most) => {
+	let deepest = 0;
+	const stack = [[value, 0]];
+	while (stack.length > 0) {
+		const [item, depth] = stack.pop();
+		if (typeof item !== "object" || item === null) continue;
+		if (depth + 1 > most) return most + 1;
+		deepest = Math.max(deepest, depth + 1);
+		for (const child of Object.values(item)) stack.push([child, depth + 1]);
+	}
+	return deepest;
+};
+//#endregion
+export { nestingDepth };

package/dist/plugin/connection-error.d.ts

@@ -0,0 +1,10 @@
+//#region src/plugin/connection-error.d.ts
+/**
+ * Why a connection gave no token: `not_connected` when the workflow has no sign-in for it, `link_expired` when the
+ * provider refused it, so its owner must sign in again. A trigger that throws it waits for that sign-in.
+ */
+export declare class ConnectionError extends Error {
+  readonly code: 'not_connected' | 'link_expired';
+  constructor(code: 'not_connected' | 'link_expired', message: string);
+}
+//#endregion

package/dist/plugin/connection-error.js

@@ -0,0 +1,15 @@
+//#region src/plugin/connection-error.ts
+/**
+* Why a connection gave no token: `not_connected` when the workflow has no sign-in for it, `link_expired` when the
+* provider refused it, so its owner must sign in again. A trigger that throws it waits for that sign-in.
+*/
+var ConnectionError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "ConnectionError";
+	}
+};
+//#endregion
+export { ConnectionError };

package/dist/plugin/context.d.ts

@@ -0,0 +1,99 @@
+//#region src/plugin/context.d.ts
+/** A JSON Schema (draft-07), as plain data: what a step or trigger takes and gives. */
+export type JsonSchema = Record<string, unknown>;
+/** What `fetch` takes: a request's method, headers and body, and the most of the answer's body it reads. */
+export type PluginFetchInit = {
+  method?: string;
+  headers?: HeadersInit;
+  body?: string | Uint8Array;
+  signal?: AbortSignal;
+  /** The most bytes of the answer's body read off the wire; a longer body fails. Default and maximum 10 MiB. */
+  maxBytes?: number;
+};
+/**
+ * The only way a plugin sends a request: it resolves the host once, refuses a private, loopback or link-local address
+ * (unless the app allows them), connects to the address it checked, follows no redirect and reads at most `maxBytes`
+ * of the body as sent, never decoding a `Content-Encoding`. The answer's body is already read.
+ */
+export type PluginFetch = (url: string, init?: PluginFetchInit) => Promise<Response>;
+/** A file of the run: the handle the API gives for a file field. */
+export type FileValue = {
+  uri: string;
+  name: string;
+  type: string;
+  size: number;
+};
+/** The run's own files: a step keeps what it downloaded and reads what an earlier step kept, never other files. */
+export type PluginFiles = {
+  keep(bytes: Uint8Array, name: string, type: string): Promise<FileValue>;
+  /** The bytes of a file of this run; `field` names the argument in the error when it is not one. */
+  read(value: unknown, field: string): Promise<{
+    name: string;
+    type?: string;
+    bytes: Uint8Array;
+  }>;
+};
+type Key = string | number | (string | number)[];
+type Record_ = Record<string, unknown>;
+/**
+ * The app's records, read and written as the user who saved the version the run runs, with the roles they hold now,
+ * through the API: its access rules, tenant scope, validation and write hooks apply. A refusal fails the step with
+ * `Records.Refused`. A create in a retry of a step after its records committed creates none again and returns them.
+ */
+export type PluginRecords = {
+  create(resource: string, data: Record_): Promise<Record_>;
+  /** Several records in one batch, all or none. */
+  createMany(resource: string, data: Record_[]): Promise<Record_[]>;
+  update(resource: string, key: Key, data: Record_): Promise<Record_>;
+  get(resource: string, key: Key): Promise<Record_>;
+  list(resource: string, query: {
+    filter?: string;
+    order_by?: string;
+    limit?: number;
+  }): Promise<Record_[]>;
+};
+/** One message from the app's own sender. */
+export type PluginMailMessage = {
+  to: string;
+  subject: string;
+  text: string;
+  html?: string;
+  headers?: Record<string, string>;
+  attachments?: {
+    filename: string;
+    content: Uint8Array;
+    contentType?: string;
+  }[];
+};
+export type PluginMail = {
+  send(message: PluginMailMessage): Promise<void>;
+};
+/** The sign-in a step or trigger declared, bound by its workflow; it names no other. */
+export type PluginConnection = {
+  /** A current access token; throws `ConnectionError` when the workflow has no working sign-in for it. */
+  accessToken(): Promise<string>;
+};
+/** What the app gives every hook of a plugin: its guarded requests, records, files and mail. */
+export type PluginServices = {
+  fetch: PluginFetch;
+  records: PluginRecords;
+  files: PluginFiles;
+  /** Undefined when the app sends no mail. */
+  mail: PluginMail | undefined;
+};
+/** What a step's `run` gets: its checked input, the app's services, and the step's own run details. */
+export type StepContext<Input = Record<string, unknown>> = PluginServices & {
+  input: Input;
+  runId: string;
+  /** The same for every retry of one visit of this step in this run; a later visit of the step, such as in a loop, gets a new one. */
+  idempotencyKey: string;
+  /** Aborted at the step's timeout, or when the worker stops. */
+  signal: AbortSignal;
+  /** Adds a line to the step's logs, secrets blanked out. */
+  log: (message: string) => void;
+  /** The text with the app's secrets blanked out, for a step that cuts text short. */
+  redact: (text: string) => string;
+  /** Undefined unless the step declares a `connection`. */
+  connection: PluginConnection | undefined;
+};
+//#endregion

package/dist/plugin/define-plugin.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from "./types.js";
+//#region src/plugin/define-plugin.d.ts
+/** The version of this interface: releases add optional keys to it and never break it. */
+export declare const pluginApi = 1;
+/** Declares a workflow plugin, checking its names: a type is `<name>:<key>`, such as `app:http` or `acme:new_order`. */
+export declare const definePlugin: <const P extends Plugin>(plugin: P) => P;
+//#endregion

package/dist/plugin/define-plugin.js

@@ -0,0 +1,23 @@
+//#region src/plugin/define-plugin.ts
+/** The version of this interface: releases add optional keys to it and never break it. */
+const pluginApi = 1;
+const pluginName = /^[a-z][a-z0-9_]*$/;
+const typeKey = /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/;
+/** Throws when `plugin` breaks a naming rule, each error starting with `where`. */
+const checkPlugin = (plugin, where = `Workflow plugin "${plugin.name}"`) => {
+	if (!pluginName.test(plugin.name)) throw new Error(`${where}: a plugin's name is lowercase letters, digits and "_"`);
+	const invalid = [...Object.keys(plugin.triggers ?? {}), ...Object.keys(plugin.steps ?? {})].find((key) => !typeKey.test(key));
+	if (invalid !== void 0) throw new Error(`${where}: "${invalid}" is not a type key; use lowercase words joined by "_" or "."`);
+	const shared = Object.keys(plugin.steps ?? {}).find((key) => Object.hasOwn(plugin.triggers ?? {}, key));
+	if (shared !== void 0) throw new Error(`${where}: "${shared}" is both a step and a trigger; give each type its own key`);
+	const connections = Object.keys(plugin.connections ?? {});
+	if (connections.includes("")) throw new Error(`${where}: a connection's name is not empty`);
+	for (const [key, type] of [...Object.entries(plugin.triggers ?? {}), ...Object.entries(plugin.steps ?? {})]) if (type.connection !== void 0 && !connections.includes(type.connection)) throw new Error(`${where}: ${key} uses the connection "${type.connection}", which the plugin does not declare`);
+};
+/** Declares a workflow plugin, checking its names: a type is `<name>:<key>`, such as `app:http` or `acme:new_order`. */
+const definePlugin = (plugin) => {
+	checkPlugin(plugin);
+	return plugin;
+};
+//#endregion
+export { checkPlugin, definePlugin, pluginApi };

package/dist/plugin/fetch-errors.d.ts

@@ -0,0 +1,14 @@
+//#region src/plugin/fetch-errors.d.ts
+/** `fetch` refused the URL before sending: its scheme, or a host that is not a public address. Names the host only. */
+export declare class AddressRefusedError extends Error {
+  name: string;
+}
+/** The answer's body is longer than the `maxBytes` `fetch` reads. */
+export declare class ResponseTooLargeError extends Error {
+  readonly maxBytes: number;
+  name: string;
+  constructor(maxBytes: number);
+}
+/** The most a plugin's `fetch` reads of a body, and its default. */
+export declare const fetchMaxBytes: number;
+//#endregion

package/dist/plugin/fetch-errors.js

@@ -0,0 +1,18 @@
+//#region src/plugin/fetch-errors.ts
+/** `fetch` refused the URL before sending: its scheme, or a host that is not a public address. Names the host only. */
+var AddressRefusedError = class extends Error {
+	name = "AddressRefusedError";
+};
+/** The answer's body is longer than the `maxBytes` `fetch` reads. */
+var ResponseTooLargeError = class extends Error {
+	maxBytes;
+	name = "ResponseTooLargeError";
+	constructor(maxBytes) {
+		super(`The answer's body is longer than ${maxBytes} bytes`);
+		this.maxBytes = maxBytes;
+	}
+};
+/** The most a plugin's `fetch` reads of a body, and its default. */
+const fetchMaxBytes = 10485760;
+//#endregion
+export { AddressRefusedError, ResponseTooLargeError, fetchMaxBytes };

package/dist/plugin/file-value.d.ts

@@ -0,0 +1,5 @@
+import { FileValue } from "./context.js";
+//#region src/plugin/file-value.d.ts
+/** Whether a value has a file value's shape, all four fields; an object with only a `uri` is other data. */
+export declare const isFileValue: (value: unknown) => value is FileValue;
+//#endregion

package/dist/plugin/file-value.js

@@ -0,0 +1,9 @@
+//#region src/plugin/file-value.ts
+/** Whether a value has a file value's shape, all four fields; an object with only a `uri` is other data. */
+const isFileValue = (value) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const { uri, name, type, size } = value;
+	return typeof uri === "string" && typeof name === "string" && typeof type === "string" && typeof size === "number";
+};
+//#endregion
+export { isFileValue };

package/dist/plugin/index.d.ts

@@ -0,0 +1,8 @@
+import { StepError } from "../run/errors.js";
+import { FileValue, JsonSchema, PluginConnection, PluginFetch, PluginFetchInit, PluginFiles, PluginMail, PluginMailMessage, PluginRecords, PluginServices, StepContext } from "./context.js";
+import { ConnectionDeclaration, Plugin, PollingTrigger, ReadyTrigger, StepType, TriggerContext, TriggerItem, TriggerType, WebhookTrigger } from "./types.js";
+import { ConnectionError } from "./connection-error.js";
+import { definePlugin, pluginApi } from "./define-plugin.js";
+import { AddressRefusedError, ResponseTooLargeError, fetchMaxBytes } from "./fetch-errors.js";
+import { isFileValue } from "./file-value.js";
+export { AddressRefusedError, type ConnectionDeclaration, ConnectionError, type FileValue, type JsonSchema, type Plugin, type PluginConnection, type PluginFetch, type PluginFetchInit, type PluginFiles, type PluginMail, type PluginMailMessage, type PluginRecords, type PluginServices, type PollingTrigger, type ReadyTrigger, ResponseTooLargeError, type StepContext, StepError, type StepType, type TriggerContext, type TriggerItem, type TriggerType, type WebhookTrigger, definePlugin, fetchMaxBytes, isFileValue, pluginApi };

package/dist/plugin/index.js

@@ -0,0 +1,6 @@
+import { StepError } from "../run/errors.js";
+import { definePlugin, pluginApi } from "./define-plugin.js";
+import { ConnectionError } from "./connection-error.js";
+import { AddressRefusedError, ResponseTooLargeError, fetchMaxBytes } from "./fetch-errors.js";
+import { isFileValue } from "./file-value.js";
+export { AddressRefusedError, ConnectionError, ResponseTooLargeError, StepError, definePlugin, fetchMaxBytes, isFileValue, pluginApi };

package/dist/plugin/load-plugins.d.ts

@@ -0,0 +1,10 @@
+import { Plugin } from "./types.js";
+//#region src/plugin/load-plugins.d.ts
+/** A plugin and where it came from, such as a package name or a file, which an error names. */
+export type LoadedPlugin = {
+  plugin: Plugin;
+  source: string;
+};
+/** The plugins an app runs, each checked as definePlugin checks it, refusing two of one name, which would give two types one id. */
+export declare const loadPlugins: (loaded: readonly LoadedPlugin[]) => Plugin[];
+//#endregion

package/dist/plugin/load-plugins.js

@@ -0,0 +1,22 @@
+import { checkPlugin } from "./define-plugin.js";
+//#region src/plugin/load-plugins.ts
+const record = (value) => value === void 0 || typeof value === "object" && value !== null;
+const isPlugin = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const plugin = value;
+	return typeof plugin.name === "string" && typeof plugin.label === "string" && record(plugin.steps) && record(plugin.triggers) && record(plugin.connections);
+};
+/** The plugins an app runs, each checked as definePlugin checks it, refusing two of one name, which would give two types one id. */
+const loadPlugins = (loaded) => {
+	const seen = /* @__PURE__ */ new Map();
+	for (const { plugin, source } of loaded) {
+		if (!isPlugin(plugin)) throw new Error(`${source} does not export a workflow plugin as its default; export default definePlugin({ ... })`);
+		checkPlugin(plugin, `Workflow plugin "${plugin.name}" of ${source}`);
+		const first = seen.get(plugin.name);
+		if (first !== void 0) throw new Error(`Two workflow plugins are named "${plugin.name}": ${first} and ${source}`);
+		seen.set(plugin.name, source);
+	}
+	return loaded.map(({ plugin }) => plugin);
+};
+//#endregion
+export { loadPlugins };

package/dist/plugin/step-handlers.d.ts

@@ -0,0 +1,12 @@
+import { TaskContext, TaskHandlers } from "../run/port.js";
+import { PluginConnection, PluginServices } from "./context.js";
+import { Plugin } from "./types.js";
+//#region src/plugin/step-handlers.d.ts
+/** What the app gives each step: its services for this run, and the connection a step declared. */
+export type StepWiring = {
+  services: (task: TaskContext) => PluginServices;
+  connection: (stepId: string, name: string, task: TaskContext) => PluginConnection;
+};
+/** The runner's step types from the plugins' steps, each checking its input against its schema before it runs. */
+export declare const stepHandlers: (plugins: readonly Plugin[], wiring: StepWiring) => TaskHandlers;
+//#endregion

package/dist/plugin/step-handlers.js

@@ -0,0 +1,33 @@
+import { StepError } from "../run/errors.js";
+import { Ajv } from "ajv";
+//#region src/plugin/step-handlers.ts
+const ajv = new Ajv({
+	allErrors: true,
+	strict: false
+});
+const handler = (id, type, wiring) => {
+	const validate = ajv.compile(type.input);
+	const prefix = type.errorPrefix ?? "Step";
+	return async (input, task) => {
+		if (!validate(input)) {
+			const problems = (validate.errors ?? []).map((error) => `${error.instancePath.slice(1).replaceAll("/", ".") || "Arguments"} ${error.message}`);
+			throw new StepError(`${prefix}.InvalidArguments`, problems.join("; "));
+		}
+		const connection = type.connection === void 0 ? void 0 : wiring.connection(id, type.connection, task);
+		const { runId, idempotencyKey, signal, log, redact } = task;
+		return type.run({
+			...wiring.services(task),
+			input,
+			runId,
+			idempotencyKey,
+			signal,
+			log,
+			redact,
+			connection
+		});
+	};
+};
+/** The runner's step types from the plugins' steps, each checking its input against its schema before it runs. */
+const stepHandlers = (plugins, wiring) => Object.fromEntries(plugins.flatMap((plugin) => Object.entries(plugin.steps ?? {}).map(([key, type]) => [`${plugin.name}:${key}`, handler(`${plugin.name}:${key}`, type, wiring)])));
+//#endregion
+export { stepHandlers };

package/dist/plugin/trigger-checks.d.ts

@@ -0,0 +1,6 @@
+import { TriggerCheck } from "../definition/check-trigger.js";
+import { Plugin } from "./types.js";
+//#region src/plugin/trigger-checks.d.ts
+/** Each trigger type of `plugins` by id, with the check of its input a save runs: its schema, then its own check. */
+export declare const triggerChecks: (plugins: readonly Plugin[]) => Record<string, TriggerCheck>;
+//#endregion

package/dist/plugin/trigger-checks.js

@@ -0,0 +1,28 @@
+import { Ajv } from "ajv";
+//#region src/plugin/trigger-checks.ts
+const ajv = new Ajv({
+	allErrors: true,
+	strict: false
+});
+const problem = (error) => {
+	const path = error.instancePath.slice(1).split("/").filter(Boolean);
+	if (error.keyword === "required") return {
+		field: [...path, String(error.params.missingProperty)].join("."),
+		message: "is missing"
+	};
+	return {
+		...path.length > 0 && { field: path.join(".") },
+		message: error.message ?? "is not valid"
+	};
+};
+/** Each trigger type of `plugins` by id, with the check of its input a save runs: its schema, then its own check. */
+const triggerChecks = (plugins) => Object.fromEntries(plugins.flatMap((plugin) => Object.entries(plugin.triggers ?? {}).map(([key, type]) => {
+	const validate = ajv.compile(type.input);
+	const check = (input) => {
+		if (!validate(input)) return (validate.errors ?? []).map(problem);
+		return type.check?.(input) ?? [];
+	};
+	return [`${plugin.name}:${key}`, check];
+})));
+//#endregion
+export { triggerChecks };