@astrale-os/sdk 0.5.0-beta.13 → 0.5.0-beta.130

package/dist/application/runtime/define.js

@@ -0,0 +1,42 @@
+import { isAction } from '../action/index.js';
+import { admitIntegrations } from '../integration/index.js';
+import { isWorkflow } from '../workflow/index.js';
+const admittedRuntimes = new WeakSet();
+/** Define one inert Runtime declaration; realization requires an exact loaded DSL Domain. */
+export function defineRuntime() {
+    return function define(input) {
+        if (input === null || typeof input !== 'object' || Array.isArray(input))
+            invalid();
+        const keys = Reflect.ownKeys(input);
+        if (keys.length !== 3 ||
+            !keys.every((key) => key === 'integrations' || key === 'initialize' || key === 'functions')) {
+            invalid();
+        }
+        if (input.integrations === null ||
+            typeof input.integrations !== 'object' ||
+            Array.isArray(input.integrations)) {
+            throw new TypeError('Runtime integrations must be an object.');
+        }
+        if (typeof input.initialize !== 'function') {
+            throw new TypeError('Runtime initialize must be a function.');
+        }
+        if (!Array.isArray(input.functions) ||
+            input.functions.some((implementation) => !isAction(implementation) && !isWorkflow(implementation))) {
+            throw new TypeError('Runtime functions must contain only admitted Actions and Workflows.');
+        }
+        const runtime = Object.freeze({
+            kind: 'runtime',
+            integrations: admitIntegrations(input.integrations),
+            initialize: input.initialize,
+            functions: Object.freeze([...input.functions]),
+        });
+        admittedRuntimes.add(runtime);
+        return runtime;
+    };
+}
+export function isRuntime(input) {
+    return input !== null && typeof input === 'object' && admittedRuntimes.has(input);
+}
+function invalid() {
+    throw new TypeError('Runtime definition must contain exactly integrations, initialize, and functions.');
+}

package/dist/application/runtime/index.d.ts

@@ -0,0 +1,6 @@
+export { defineRuntime, isRuntime } from './define.js';
+export type { RuntimeInput } from './define.js';
+export type { RuntimeInitialization, RuntimeInitializationContext, RuntimeInitializer, } from './initialize.js';
+export type { RuntimeIntegrations } from './integrations.js';
+export { admitRuntimeRegistry } from './runtime.js';
+export type { Runtime, RuntimeImplementation, RuntimeRegistry, SchemaOfRuntime } from './runtime.js';

package/dist/application/runtime/index.js

@@ -0,0 +1,2 @@
+export { defineRuntime, isRuntime } from './define.js';
+export { admitRuntimeRegistry } from './runtime.js';

package/dist/application/runtime/initialize.d.ts

@@ -0,0 +1,10 @@
+import type { schema } from '../../platform/schema/index.js';
+/** Exact values created once from one adapter environment for a realized Runtime. */
+export interface RuntimeInitialization<ProviderValues = unknown> {
+    readonly providers: ProviderValues;
+}
+/** Exact loaded Domain available while Providers are constructed once. */
+export interface RuntimeInitializationContext<Schema extends schema.DomainSchema> {
+    readonly domain: schema.DomainOf<Schema>;
+}
+export type RuntimeInitializer<Environment = unknown, Initialization extends RuntimeInitialization = RuntimeInitialization, Schema extends schema.DomainSchema = schema.DomainSchema> = (environment: Environment, context: RuntimeInitializationContext<Schema>) => Initialization | Promise<Initialization>;

package/dist/application/runtime/initialize.js

@@ -0,0 +1 @@
+export {};

package/dist/application/runtime/integrations.d.ts

@@ -0,0 +1,3 @@
+import type { Integrations } from '../integration/index.js';
+/** Authored provider-neutral Integration declarations keyed by their local names. */
+export type RuntimeIntegrations = Integrations;

package/dist/application/runtime/integrations.js

@@ -0,0 +1 @@
+export {};

package/dist/application/runtime/runtime.d.ts

@@ -0,0 +1,30 @@
+import type { Domain, schema } from '../../platform/schema/index.js';
+import type { RuntimeAction } from './actions.js';
+import type { RuntimeInitialization, RuntimeInitializer } from './initialize.js';
+import type { RuntimeIntegrations } from './integrations.js';
+import type { RuntimeWorkflow } from './workflows.js';
+export type RuntimeImplementation = RuntimeAction | RuntimeWorkflow;
+declare const RUNTIME_SCHEMA: unique symbol;
+/** Inert authored Runtime declaration; exact Domain association occurs during realization. */
+export interface Runtime<Schema extends schema.DomainSchema = schema.DomainSchema, Integrations extends RuntimeIntegrations = RuntimeIntegrations, Initialize extends RuntimeInitializer<never, RuntimeInitialization, Schema> = RuntimeInitializer<never, RuntimeInitialization, Schema>, Functions extends readonly unknown[] = readonly unknown[]> {
+    readonly kind: 'runtime';
+    readonly integrations: Integrations;
+    readonly initialize: Initialize;
+    readonly functions: Functions;
+    readonly [RUNTIME_SCHEMA]: Schema;
+}
+/** Recover the exact Schema witness retained by one authored Runtime. */
+export type SchemaOfRuntime<Value> = Value extends {
+    readonly [RUNTIME_SCHEMA]: infer Schema extends schema.DomainSchema;
+} ? Schema : never;
+/** One exact canonical implementation registry for a realized Runtime. */
+export interface RuntimeRegistry {
+    readonly implementations: readonly RuntimeImplementation[];
+    readonly actions: readonly RuntimeAction[];
+    readonly workflows: readonly RuntimeWorkflow[];
+}
+/** Prove unique and exhaustive Action/Workflow coverage of the root executable set. */
+export declare function admitRuntimeRegistry(domain: Domain, input: {
+    readonly functions: unknown;
+}): RuntimeRegistry;
+export {};

package/dist/application/runtime/runtime.js

@@ -0,0 +1,37 @@
+import { isAction } from '../action/index.js';
+import { isWorkflow } from '../workflow/index.js';
+import { admitActions } from './actions.js';
+import { runtimeCallables } from './callables.js';
+import { admitWorkflows } from './workflows.js';
+/** Prove unique and exhaustive Action/Workflow coverage of the root executable set. */
+export function admitRuntimeRegistry(domain, input) {
+    const callables = runtimeCallables(domain);
+    if (!Array.isArray(input.functions)) {
+        throw new TypeError('Runtime functions must be an array.');
+    }
+    const unknown = input.functions.filter((implementation) => !isAction(implementation) && !isWorkflow(implementation));
+    if (unknown.length > 0) {
+        throw new TypeError('Runtime functions must contain only admitted Actions and Workflows.');
+    }
+    const actions = admitActions(callables, input.functions.filter(isAction));
+    const workflows = admitWorkflows(callables, input.functions.filter(isWorkflow));
+    const implementations = [...actions, ...workflows];
+    const addresses = new Set();
+    for (const implementation of implementations) {
+        if (addresses.has(implementation.address)) {
+            throw new TypeError(`Runtime callable ${implementation.address} has both Action and Workflow implementations.`);
+        }
+        addresses.add(implementation.address);
+    }
+    const missing = callables
+        .map(({ address }) => address)
+        .filter((address) => !addresses.has(address));
+    if (missing.length > 0) {
+        throw new TypeError(`Runtime is missing implementations: ${missing.join(', ')}.`);
+    }
+    return Object.freeze({
+        implementations: Object.freeze(implementations),
+        actions,
+        workflows,
+    });
+}

package/dist/application/runtime/workflows.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedCallable } from '../action/index.js';
+import type { WorkflowDefinition } from '../workflow/index.js';
+import type { RuntimeCallable } from './callables.js';
+export interface RuntimeWorkflow {
+    readonly kind: 'workflow';
+    readonly address: string;
+    readonly callable: ResolvedCallable;
+    readonly definition: WorkflowDefinition;
+}
+/** Associate admitted Workflows with their exact authenticated value callables. */
+export declare function admitWorkflows(callables: readonly RuntimeCallable[], input: unknown): readonly RuntimeWorkflow[];

package/dist/application/runtime/workflows.js

@@ -0,0 +1,33 @@
+import { isWorkflow } from '../workflow/index.js';
+import { runtimeCallableAt } from './callables.js';
+/** Associate admitted Workflows with their exact authenticated value callables. */
+export function admitWorkflows(callables, input) {
+    if (!Array.isArray(input))
+        throw new TypeError('Runtime workflows must be an array.');
+    const addresses = new Set();
+    const workflows = input.map((definition) => {
+        if (!isWorkflow(definition))
+            throw new TypeError('Runtime contains an unadmitted Workflow.');
+        if (addresses.has(definition.address)) {
+            throw new TypeError(`Runtime Workflow ${definition.address} occurs more than once.`);
+        }
+        addresses.add(definition.address);
+        const callable = runtimeCallableAt(callables, definition.address);
+        if (callable === undefined) {
+            throw new TypeError(`Runtime Workflow ${definition.address} is not root-local and executable.`);
+        }
+        if (callable.auth === 'anonymous') {
+            throw new TypeError(`Runtime Workflow ${definition.address} must be authenticated.`);
+        }
+        if (callable.output.mode !== 'value') {
+            throw new TypeError(`Runtime Workflow ${definition.address} must have value output.`);
+        }
+        return Object.freeze({
+            kind: 'workflow',
+            address: definition.address,
+            callable,
+            definition,
+        });
+    });
+    return Object.freeze(workflows);
+}

package/dist/application/state/index.d.ts

@@ -0,0 +1,2 @@
+export { stateMachine } from '@astrale-os/kernel-dsl/v1/language/state';
+export type { StateMachine, StateTopology, StateOf, EventOf, } from '@astrale-os/kernel-dsl/v1/language/state';

package/dist/application/state/index.js

@@ -0,0 +1 @@
+export { stateMachine } from '@astrale-os/kernel-dsl/v1/language/state';

package/dist/application/view/admission.d.ts

@@ -0,0 +1,3 @@
+import type { Frontend } from './frontend.js';
+export declare function capture<FrontendValue extends Frontend>(frontend: FrontendValue): FrontendValue;
+export declare function isFrontend(input: unknown): input is Frontend;

package/dist/application/view/admission.js

@@ -0,0 +1,8 @@
+const admittedFrontends = new WeakSet();
+export function capture(frontend) {
+    admittedFrontends.add(frontend);
+    return frontend;
+}
+export function isFrontend(input) {
+    return input !== null && typeof input === 'object' && admittedFrontends.has(input);
+}

package/dist/application/view/define.d.ts

@@ -0,0 +1,4 @@
+import type { schema } from '../../platform/schema/index.js';
+import type { Frontend, FrontendInput } from './frontend.js';
+/** Define one framework-neutral browser source and exact Schema View routing. */
+export declare function defineFrontend<const Schema extends schema.DomainSchema>(input: FrontendInput<Schema>): Frontend<Schema>;

package/dist/application/view/define.js

@@ -0,0 +1,52 @@
+import { capture } from './admission.js';
+import { defaultRoute, normalizeRoute } from './route.js';
+import { isFrontendSource } from './source.js';
+/** Define one framework-neutral browser source and exact Schema View routing. */
+export function defineFrontend(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    if (Reflect.ownKeys(input).some((key) => key !== 'schema' && key !== 'source' && key !== 'routes' && key !== 'entrypoint')) {
+        invalid();
+    }
+    const names = Object.keys(input.schema.views).sort(compare);
+    if (names.length === 0)
+        throw new TypeError('Frontend requires at least one Schema View.');
+    const source = admitSource(input.source);
+    const authored = input.routes ?? {};
+    if (authored === null || typeof authored !== 'object' || Array.isArray(authored))
+        invalid();
+    const unknown = Reflect.ownKeys(authored).find((name) => typeof name !== 'string' || !names.includes(name));
+    if (unknown !== undefined)
+        throw new TypeError(`Frontend route ${String(unknown)} is unknown.`);
+    const entrypoint = input.entrypoint ?? (names.length === 1 ? names[0] : undefined);
+    if (entrypoint === undefined || !names.includes(entrypoint)) {
+        throw new TypeError('Frontend entrypoint must name one Schema View.');
+    }
+    const paths = new Set();
+    const routes = {};
+    for (const name of names) {
+        const route = normalizeRoute(authored[name], defaultRoute(name));
+        if (paths.has(route.path))
+            throw new TypeError(`Frontend route ${route.path} is duplicated.`);
+        paths.add(route.path);
+        routes[name] = route;
+    }
+    return capture(Object.freeze({
+        kind: 'frontend',
+        schema: input.schema,
+        source,
+        routes: Object.freeze(routes),
+        entrypoint: entrypoint,
+    }));
+}
+function admitSource(input) {
+    if (!isFrontendSource(input))
+        invalid();
+    return input;
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function invalid() {
+    throw new TypeError('Frontend definition is invalid.');
+}

package/dist/application/view/frontend.d.ts

@@ -0,0 +1,19 @@
+import type { schema } from '../../platform/schema/index.js';
+import type { FrontendRoute, FrontendRouteInput } from './route.js';
+import type { FrontendSource } from './source.js';
+export type ViewName<Schema extends schema.DomainSchema> = Extract<keyof schema.DomainOf<Schema>['views'], string>;
+export type FrontendRoutes<Schema extends schema.DomainSchema> = Readonly<Record<ViewName<Schema>, FrontendRoute>>;
+export type FrontendRouteInputs<Schema extends schema.DomainSchema> = Readonly<Partial<Record<ViewName<Schema>, FrontendRouteInput>>>;
+export interface FrontendInput<Schema extends schema.DomainSchema> {
+    readonly schema: Schema;
+    readonly source: FrontendSource;
+    readonly routes?: FrontendRouteInputs<Schema>;
+    readonly entrypoint?: ViewName<Schema>;
+}
+export interface Frontend<Schema extends schema.DomainSchema = schema.DomainSchema> {
+    readonly kind: 'frontend';
+    readonly schema: Schema;
+    readonly source: FrontendSource;
+    readonly routes: FrontendRoutes<Schema>;
+    readonly entrypoint: ViewName<Schema>;
+}

package/dist/application/view/frontend.js

@@ -0,0 +1 @@
+export {};

package/dist/application/view/index.d.ts

@@ -0,0 +1,6 @@
+export { isFrontend } from './admission.js';
+export { defineFrontend } from './define.js';
+export type { Frontend, FrontendInput, FrontendRouteInputs, FrontendRoutes, ViewName, } from './frontend.js';
+export type { FrontendHandshake, FrontendRoute, FrontendRouteInput, IframeRequirements, } from './route.js';
+export { external, isFrontendSource, vite } from './source.js';
+export type { ExternalSource, FrontendSource, ViteSource } from './source.js';

package/dist/application/view/index.js

@@ -0,0 +1,3 @@
+export { isFrontend } from './admission.js';
+export { defineFrontend } from './define.js';
+export { external, isFrontendSource, vite } from './source.js';

package/dist/application/view/route.d.ts

@@ -0,0 +1,19 @@
+export type FrontendHandshake = 'shell' | 'none';
+export interface IframeRequirements {
+    readonly sandbox?: readonly string[];
+    readonly allow?: readonly string[];
+}
+export type FrontendRouteInput = string | {
+    readonly path?: string;
+    readonly document?: string;
+    readonly handshake?: FrontendHandshake;
+    readonly iframe?: IframeRequirements;
+};
+export interface FrontendRoute {
+    readonly path: string;
+    readonly document: string;
+    readonly handshake: FrontendHandshake;
+    readonly iframe?: IframeRequirements;
+}
+export declare function normalizeRoute(input: FrontendRouteInput | undefined, fallback: string): FrontendRoute;
+export declare function defaultRoute(name: string): string;

package/dist/application/view/route.js

@@ -0,0 +1,131 @@
+const TOKEN = /^[a-z][a-z0-9-]*$/u;
+const BASELINES = Object.freeze({
+    none: iframeRequirements(['allow-scripts'], []),
+    shell: iframeRequirements(['allow-same-origin', 'allow-scripts'], ['clipboard-write']),
+});
+export function normalizeRoute(input, fallback) {
+    if (typeof input === 'string') {
+        return Object.freeze({ path: routePath(input), document: 'index.html', handshake: 'shell' });
+    }
+    const value = plainRecord(input ?? {});
+    if (Reflect.ownKeys(value).some((key) => typeof key !== 'string' || !['path', 'document', 'handshake', 'iframe'].includes(key))) {
+        invalid();
+    }
+    const authoredHandshake = dataValue(value, 'handshake');
+    if (authoredHandshake !== undefined &&
+        authoredHandshake !== 'shell' &&
+        authoredHandshake !== 'none') {
+        invalid();
+    }
+    const handshake = authoredHandshake ?? 'shell';
+    const iframe = normalizeIframeRequirements(dataValue(value, 'iframe'), handshake);
+    return Object.freeze({
+        path: routePath(dataValue(value, 'path') ?? fallback),
+        document: filePath(dataValue(value, 'document') ?? 'index.html'),
+        handshake,
+        ...(iframe === undefined ? {} : { iframe }),
+    });
+}
+function normalizeIframeRequirements(input, handshake) {
+    if (input === undefined)
+        return undefined;
+    const value = plainRecord(input);
+    if (Reflect.ownKeys(value).some((key) => key !== 'sandbox' && key !== 'allow'))
+        invalid();
+    const authored = iframeRequirements(tokenArray(dataValue(value, 'sandbox')), tokenArray(dataValue(value, 'allow')));
+    assertSandboxRelationships(authored.sandbox);
+    const baseline = BASELINES[handshake];
+    const sandbox = authored.sandbox.filter((token) => !baseline.sandbox.includes(token));
+    const allow = authored.allow.filter((feature) => !baseline.allow.includes(feature));
+    return sandbox.length === 0 && allow.length === 0 ? undefined : iframeRequirements(sandbox, allow);
+}
+function iframeRequirements(sandbox, allow) {
+    return Object.freeze({
+        sandbox: Object.freeze([...new Set(sandbox)].sort()),
+        allow: Object.freeze([...new Set(allow)].sort()),
+    });
+}
+function tokenArray(input) {
+    if (input === undefined)
+        return [];
+    if (!Array.isArray(input))
+        invalid();
+    const descriptors = Object.getOwnPropertyDescriptors(input);
+    const result = [];
+    for (let index = 0; index < input.length; index += 1) {
+        const descriptor = descriptors[String(index)];
+        if (descriptor === undefined || !('value' in descriptor))
+            invalid();
+        if (typeof descriptor.value !== 'string' || !TOKEN.test(descriptor.value))
+            invalid();
+        result.push(descriptor.value);
+    }
+    for (const key of Reflect.ownKeys(descriptors)) {
+        if (key === 'length')
+            continue;
+        if (typeof key !== 'string' || !/^(0|[1-9][0-9]*)$/u.test(key) || Number(key) >= input.length) {
+            invalid();
+        }
+    }
+    return result;
+}
+function plainRecord(input) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input))
+        invalid();
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== Object.prototype && prototype !== null)
+        invalid();
+    return input;
+}
+function dataValue(input, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (descriptor === undefined)
+        return undefined;
+    if (!('value' in descriptor))
+        invalid();
+    return descriptor.value;
+}
+function assertSandboxRelationships(sandbox) {
+    const tokens = new Set(sandbox);
+    if (tokens.has('allow-popups-to-escape-sandbox') && !tokens.has('allow-popups'))
+        invalid();
+    if (tokens.has('allow-top-navigation') && tokens.has('allow-top-navigation-by-user-activation')) {
+        invalid();
+    }
+    if (tokens.has('allow-top-navigation-to-custom-protocols') &&
+        (tokens.has('allow-top-navigation') || tokens.has('allow-popups'))) {
+        invalid();
+    }
+}
+export function defaultRoute(name) {
+    return routePath(`/${name
+        .replace(/([a-z0-9])([A-Z])/gu, '$1-$2')
+        .replace(/[_\s]+/gu, '-')
+        .toLowerCase()}`);
+}
+function routePath(input) {
+    if (typeof input !== 'string' || !input.startsWith('/') || input.startsWith('//'))
+        invalid();
+    const url = new URL(input, 'https://frontend.invalid');
+    if (url.origin !== 'https://frontend.invalid' ||
+        url.pathname !== input ||
+        url.search !== '' ||
+        url.hash !== '' ||
+        input.includes('..')) {
+        invalid();
+    }
+    return input === '/' ? '/' : input.replace(/\/$/u, '');
+}
+function filePath(input) {
+    if (typeof input !== 'string' ||
+        input.length === 0 ||
+        input.startsWith('/') ||
+        input.includes('\\') ||
+        input.split('/').some((segment) => segment === '' || segment === '.' || segment === '..')) {
+        invalid();
+    }
+    return input;
+}
+function invalid() {
+    throw new TypeError('Frontend route is invalid.');
+}

package/dist/application/view/source.d.ts

@@ -0,0 +1,16 @@
+export interface ViteSource {
+    readonly kind: 'vite';
+    readonly config?: string;
+    readonly spa: boolean;
+}
+export interface ExternalSource {
+    readonly kind: 'external';
+    readonly origin: string;
+}
+export type FrontendSource = ViteSource | ExternalSource;
+export declare function vite(input?: Readonly<{
+    readonly config?: string;
+    readonly spa?: boolean;
+}>): ViteSource;
+export declare function external(origin: string): ExternalSource;
+export declare function isFrontendSource(input: unknown): input is FrontendSource;

package/dist/application/view/source.js

@@ -0,0 +1,55 @@
+const admittedSources = new WeakSet();
+export function vite(input = {}) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    if (Reflect.ownKeys(input).some((key) => key !== 'config' && key !== 'spa'))
+        invalid();
+    if (input.spa !== undefined && typeof input.spa !== 'boolean')
+        invalid();
+    const source = Object.freeze({
+        kind: 'vite',
+        ...(input.config === undefined ? {} : { config: projectPath(input.config) }),
+        spa: input.spa ?? true,
+    });
+    admittedSources.add(source);
+    return source;
+}
+export function external(origin) {
+    let url;
+    try {
+        url = new URL(origin);
+    }
+    catch (cause) {
+        throw new TypeError('External frontend origin must be an absolute HTTPS origin.', { cause });
+    }
+    if (url.protocol !== 'https:' ||
+        url.username !== '' ||
+        url.password !== '' ||
+        url.pathname !== '/' ||
+        url.search !== '' ||
+        url.hash !== '') {
+        throw new TypeError('External frontend origin must be an absolute HTTPS origin.');
+    }
+    const source = Object.freeze({ kind: 'external', origin: url.origin });
+    admittedSources.add(source);
+    return source;
+}
+export function isFrontendSource(input) {
+    return input !== null && typeof input === 'object' && admittedSources.has(input);
+}
+function projectPath(input) {
+    if (typeof input !== 'string' ||
+        input.length === 0 ||
+        input.startsWith('/') ||
+        input.includes('\\')) {
+        invalid();
+    }
+    const value = input.startsWith('./') ? input.slice(2) : input;
+    if (value.split('/').some((segment) => segment === '' || segment === '.' || segment === '..')) {
+        invalid();
+    }
+    return `./${value}`;
+}
+function invalid() {
+    throw new TypeError('Vite frontend source is invalid.');
+}

package/dist/application/workflow/authoring.d.ts

@@ -0,0 +1,4 @@
+export { defineWorkflow } from './define.js';
+export type { WorkflowContext } from './context.js';
+export type { Workflow, WorkflowAddress, WorkflowDefinition } from './workflow.js';
+export type { DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, } from '../error/index.js';

package/dist/application/workflow/authoring.js

@@ -0,0 +1 @@
+export { defineWorkflow } from './define.js';

package/dist/application/workflow/context.d.ts

@@ -0,0 +1,9 @@
+import type { Domain } from '../../platform/schema/index.js';
+import type { ActionContext, ResolvedCallable } from '../action/index.js';
+import type { DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
+import type { Integrations } from '../integration/index.js';
+import type { WorkflowStep } from './step/index.js';
+/** Exact multi-step Workflow context for one authenticated value-output callable. */
+export type WorkflowContext<Callable extends ResolvedCallable, DomainValue extends Domain = Domain, Definitions extends Integrations = Readonly<Record<never, never>>, Errors extends DeclaredErrors = NoDeclaredErrors> = ActionContext<Callable, DomainValue, Definitions, Errors> & {
+    readonly step: WorkflowStep;
+};

package/dist/application/workflow/context.js

@@ -0,0 +1 @@
+export {};

package/dist/application/workflow/define.d.ts

@@ -0,0 +1,11 @@
+import type { schema } from '../../platform/schema/index.js';
+import type { ResolvedDomainOf } from '../action/index.js';
+import type { DeclaredErrorOptions, DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
+import type { Integrations } from '../integration/index.js';
+import type { CallableAtWorkflowAddress, Workflow, WorkflowAddress, WorkflowDefinition } from './workflow.js';
+/** Define one authenticated multi-step value-output implementation by its SDK Action address. */
+export declare function defineWorkflow<Schema extends schema.DomainSchema, Definitions extends Integrations = Readonly<Record<never, never>>>(): {
+    <const Address extends WorkflowAddress<Schema>>(address: Address, run: Workflow<CallableAtWorkflowAddress<Schema, Address>, Definitions, ResolvedDomainOf<Schema>, NoDeclaredErrors>): WorkflowDefinition<Schema, Address, Definitions, NoDeclaredErrors>;
+    <const Address extends WorkflowAddress<Schema>, const Errors extends DeclaredErrors>(address: Address, options: DeclaredErrorOptions<Errors>, run: Workflow<CallableAtWorkflowAddress<Schema, Address>, Definitions, ResolvedDomainOf<Schema>, Errors>): WorkflowDefinition<Schema, Address, Definitions, Errors>;
+};
+export declare function isWorkflow(input: unknown): input is WorkflowDefinition;

package/dist/application/workflow/define.js

@@ -0,0 +1,37 @@
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { rememberDeclaredErrors } from '../error/index.js';
+const admittedWorkflows = new WeakSet();
+/** Define one authenticated multi-step value-output implementation by its SDK Action address. */
+export function defineWorkflow() {
+    return function define(address, optionsOrRun, possibleRun) {
+        acceptWorkflowAddress(address);
+        const options = possibleRun === undefined ? undefined : optionsOrRun;
+        const run = possibleRun ?? optionsOrRun;
+        if (typeof run !== 'function')
+            throw new TypeError('Workflow run must be a function.');
+        const workflow = Object.freeze({
+            kind: 'workflow',
+            address,
+            run,
+        });
+        if (options !== undefined)
+            rememberDeclaredErrors(workflow, options);
+        admittedWorkflows.add(workflow);
+        return workflow;
+    };
+}
+export function isWorkflow(input) {
+    return input !== null && typeof input === 'object' && admittedWorkflows.has(input);
+}
+function acceptWorkflowAddress(input) {
+    if (typeof input !== 'string')
+        invalidAddress(input);
+    const members = input.split('.');
+    if ((members.length !== 1 && members.length !== 2) ||
+        members.some((member) => !patterns.memberName.test(member))) {
+        invalidAddress(input);
+    }
+}
+function invalidAddress(input) {
+    throw new TypeError(`Invalid Workflow address: ${JSON.stringify(input)}.`);
+}

package/dist/application/workflow/index.d.ts

@@ -0,0 +1,6 @@
+export { defineWorkflow, isWorkflow } from './define.js';
+export type { WorkflowContext } from './context.js';
+export type { CallableAtWorkflowAddress, Workflow, WorkflowAddress, WorkflowCallable, WorkflowDefinition, } from './workflow.js';
+export * as step from './step/index.js';
+export * as runner from './runner/index.js';
+export type { DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, } from '../error/index.js';

package/dist/application/workflow/index.js

@@ -0,0 +1,3 @@
+export { defineWorkflow, isWorkflow } from './define.js';
+export * as step from './step/index.js';
+export * as runner from './runner/index.js';

package/dist/application/workflow/runner/index.d.ts

@@ -0,0 +1,2 @@
+export { createInlineWorkflowRunner } from './inline.js';
+export type { WorkflowExecutionContext, WorkflowRunner } from './runner.js';

package/dist/application/workflow/runner/index.js

@@ -0,0 +1 @@
+export { createInlineWorkflowRunner } from './inline.js';

package/dist/application/workflow/runner/inline.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowRunner } from './runner.js';
+/** Process-local runner for tests and explicitly non-durable embeddings. */
+export declare function createInlineWorkflowRunner(): WorkflowRunner;