@astrale-os/sdk 0.5.0-beta.4 → 0.5.0-beta.41

package/dist/application/routes/index.js

@@ -0,0 +1,45 @@
+import { isAction } from '../action/index.js';
+import { isWorkflow } from '../workflow/index.js';
+import { captureRoute } from './collection.js';
+export { admit } from './admission.js';
+export { isRoute, isRoutes, routes } from './collection.js';
+/** Define one HTTP route without exposing DSL Function or Method topology. */
+export function route(target, input) {
+    if (!isAction(target) && !isWorkflow(target)) {
+        throw new TypeError('Route target must be an admitted Action or Workflow.');
+    }
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    const allowed = new Set([
+        'name',
+        'path',
+        'method',
+        'requestMethod',
+        'default',
+        'receiver',
+        'query',
+        'headers',
+        'body',
+        'credential',
+    ]);
+    if (Reflect.ownKeys(input).some((key) => !allowed.has(key)))
+        invalid();
+    return captureRoute(Object.freeze({
+        target,
+        ...detach(input),
+    }));
+}
+function detach(input) {
+    return deepFreeze(structuredClone(input));
+}
+function deepFreeze(input) {
+    if (input !== null && typeof input === 'object') {
+        for (const value of Object.values(input))
+            deepFreeze(value);
+        Object.freeze(input);
+    }
+    return input;
+}
+function invalid() {
+    throw new TypeError('Route input contains unsupported fields.');
+}

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

@@ -0,0 +1,10 @@
+import type { publication } from '@astrale-os/kernel-protocol';
+export interface RouteTarget {
+    readonly kind: 'action' | 'workflow';
+    readonly address: string;
+}
+export type RouteInput = Omit<publication.HttpRouteDeclaration, 'callable'>;
+/** One provider-neutral HTTP route targeting an admitted Action or Workflow recipe. */
+export interface Route<Target extends RouteTarget = RouteTarget> extends RouteInput {
+    readonly target: Target;
+}

package/dist/application/routes/route.js

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

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

@@ -0,0 +1,10 @@
+import type { ActionDefinition, ResolvedCallable } from '../action/index.js';
+import type { RuntimeCallable } from './callables.js';
+export interface RuntimeAction {
+    readonly kind: 'action';
+    readonly address: string;
+    readonly callable: ResolvedCallable;
+    readonly definition: ActionDefinition;
+}
+/** Associate admitted Actions with exact canonical root-local callable descriptors. */
+export declare function admitActions(callables: readonly RuntimeCallable[], input: unknown): readonly RuntimeAction[];

package/dist/application/runtime/actions.js

@@ -0,0 +1,27 @@
+import { isAction } from '../action/index.js';
+import { runtimeCallableAt } from './callables.js';
+/** Associate admitted Actions with exact canonical root-local callable descriptors. */
+export function admitActions(callables, input) {
+    if (!Array.isArray(input))
+        throw new TypeError('Runtime actions must be an array.');
+    const addresses = new Set();
+    const actions = input.map((definition) => {
+        if (!isAction(definition))
+            throw new TypeError('Runtime contains an unadmitted Action.');
+        if (addresses.has(definition.address)) {
+            throw new TypeError(`Runtime Action ${definition.address} occurs more than once.`);
+        }
+        addresses.add(definition.address);
+        const callable = runtimeCallableAt(callables, definition.address);
+        if (callable === undefined) {
+            throw new TypeError(`Runtime Action ${definition.address} is not root-local and executable.`);
+        }
+        return Object.freeze({
+            kind: 'action',
+            address: definition.address,
+            callable,
+            definition,
+        });
+    });
+    return Object.freeze(actions);
+}

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

@@ -0,0 +1,5 @@
+export { defineRuntime } from './define.js';
+export type { RuntimeInput } from './define.js';
+export type { RuntimeInitialization, RuntimeInitializationContext, RuntimeInitializer, } from './initialize.js';
+export type { RuntimeIntegrations } from './integrations.js';
+export type { Runtime } from './runtime.js';

package/dist/application/runtime/authoring.js

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

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

@@ -0,0 +1,11 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1/domain';
+import type { ResolvedCallable } from '../action/context.js';
+import type { ActionAddressOf } from '../action/index.js';
+export interface RuntimeCallable<Callable extends ResolvedCallable = ResolvedCallable> {
+    readonly address: ActionAddressOf<Callable>;
+    readonly callable: Callable;
+}
+/** Enumerate only the exact executable callable set owned by the root Domain. */
+export declare function runtimeCallables(domain: Domain): readonly RuntimeCallable[];
+/** Resolve one SDK Action address through an already admitted root-local projection. */
+export declare function runtimeCallableAt(callables: readonly RuntimeCallable[], address: string): ResolvedCallable | undefined;

package/dist/application/runtime/callables.js

@@ -0,0 +1,40 @@
+import { callableAddress } from '@astrale-os/kernel-dsl/v1/addressing';
+import { isDomain } from '@astrale-os/kernel-dsl/v1/domain';
+/** Enumerate only the exact executable callable set owned by the root Domain. */
+export function runtimeCallables(domain) {
+    if (!isDomain(domain))
+        throw new TypeError('Runtime callables require an admitted Domain.');
+    const result = [];
+    const addresses = new Set();
+    for (const callable of Object.values(domain.functions))
+        append(callable);
+    for (const selected of Object.values(domain.classes)) {
+        if (selected.kind !== 'node')
+            continue;
+        for (const callable of selected.self.methods) {
+            if (callable.inheritance !== 'abstract')
+                append(callable);
+        }
+        for (const callable of selected.self.static.methods) {
+            if (callable.inheritance !== 'abstract')
+                append(callable);
+        }
+    }
+    return Object.freeze(result.sort((left, right) => left.address.localeCompare(right.address)));
+    function append(callable) {
+        const address = actionAddress(callable);
+        if (addresses.has(address)) {
+            throw new TypeError(`Runtime Action address ${address} is ambiguous.`);
+        }
+        addresses.add(address);
+        result.push(Object.freeze({ address, callable }));
+    }
+}
+/** Resolve one SDK Action address through an already admitted root-local projection. */
+export function runtimeCallableAt(callables, address) {
+    return callables.find((entry) => entry.address === address)?.callable;
+}
+function actionAddress(callable) {
+    const address = callableAddress(callable.key);
+    return address.kind === 'method' ? `${address.owner.name}.${address.name}` : address.name;
+}

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

@@ -0,0 +1,28 @@
+import type { schema } from '../../platform/schema/index.js';
+import type { ActionDefinition } from '../action/index.js';
+import type { Providers } from '../integration/index.js';
+import type { WorkflowDefinition } from '../workflow/index.js';
+import type { RuntimeInitialization, RuntimeInitializer } from './initialize.js';
+import type { RuntimeIntegrations } from './integrations.js';
+import type { Runtime } from './runtime.js';
+type RuntimeInitializerValue = (...input: never[]) => RuntimeInitialization | Promise<RuntimeInitialization>;
+type AnyRuntimeInitializer<Schema extends schema.DomainSchema> = RuntimeInitializer<never, RuntimeInitialization, Schema>;
+type Same<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false;
+type ActionSchema<Value> = Value extends ActionDefinition<infer Schema, infer _Address, infer _Services> ? Schema : never;
+type WorkflowSchema<Value> = Value extends WorkflowDefinition<infer Schema, infer _Address, infer _Services> ? Schema : never;
+type RecipeIntegrations<Value> = Value extends ActionDefinition<infer _Schema, infer _Address, infer Definitions> ? Definitions : Value extends WorkflowDefinition<infer _Schema, infer _Address, infer Definitions> ? Definitions : never;
+type AdmitsRecipeSchema<Schema extends schema.DomainSchema, Actions extends readonly unknown[], Workflows extends readonly unknown[]> = [Actions[number] | Workflows[number]] extends [never] ? unknown : Same<ActionSchema<Actions[number]> | WorkflowSchema<Workflows[number]>, Schema> extends true ? unknown : never;
+type InitializationOf<Initialize extends RuntimeInitializerValue> = Awaited<ReturnType<Initialize>>;
+type AdmitsRecipeIntegrations<Definitions extends RuntimeIntegrations, Recipe> = RecipeIntegrations<Recipe> extends infer Required extends RuntimeIntegrations ? Exclude<keyof Required, keyof Definitions> extends never ? Required extends Pick<Definitions, Extract<keyof Required, keyof Definitions>> ? true : false : false : false;
+type AdmitsIntegrations<Definitions extends RuntimeIntegrations, Actions extends readonly unknown[], Workflows extends readonly unknown[]> = [Actions[number] | Workflows[number]] extends [never] ? unknown : false extends AdmitsRecipeIntegrations<Definitions, Actions[number] | Workflows[number]> ? never : unknown;
+type AdmitsProviders<Integrations extends RuntimeIntegrations, Initialize extends RuntimeInitializerValue> = Same<InitializationOf<Initialize>['providers'], Providers<Integrations>> extends true ? unknown : never;
+export interface RuntimeInput<Integrations extends RuntimeIntegrations, Initialize extends RuntimeInitializerValue, Actions extends readonly unknown[], Workflows extends readonly unknown[]> {
+    readonly integrations: Integrations;
+    readonly initialize: Initialize;
+    readonly actions: Actions;
+    readonly workflows: Workflows;
+}
+/** Define one inert Runtime declaration; realization requires an exact loaded DSL Domain. */
+export declare function defineRuntime<Schema extends schema.DomainSchema>(): <const Integrations extends RuntimeIntegrations, Initialize extends AnyRuntimeInitializer<Schema>, const Actions extends readonly unknown[], const Workflows extends readonly unknown[]>(input: RuntimeInput<Integrations, Initialize, Actions, Workflows> & AdmitsRecipeSchema<Schema, Actions, Workflows> & AdmitsIntegrations<Integrations, Actions, Workflows> & AdmitsProviders<Integrations, Initialize>) => Runtime<Schema, Integrations, Initialize, Actions, Workflows>;
+export declare function isRuntime(input: unknown): input is Runtime;
+export {};

package/dist/application/runtime/define.js

@@ -0,0 +1,49 @@
+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 !== 4 ||
+            !keys.every((key) => key === 'integrations' ||
+                key === 'initialize' ||
+                key === 'actions' ||
+                key === 'workflows')) {
+            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.actions) || input.actions.some((action) => !isAction(action))) {
+            throw new TypeError('Runtime actions must contain only admitted Actions.');
+        }
+        if (!Array.isArray(input.workflows) ||
+            input.workflows.some((workflow) => !isWorkflow(workflow))) {
+            throw new TypeError('Runtime workflows must contain only admitted Workflows.');
+        }
+        const runtime = Object.freeze({
+            kind: 'runtime',
+            integrations: admitIntegrations(input.integrations),
+            initialize: input.initialize,
+            actions: Object.freeze([...input.actions]),
+            workflows: Object.freeze([...input.workflows]),
+        });
+        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, actions, and workflows.');
+}

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, 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,32 @@
+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>, Actions extends readonly unknown[] = readonly unknown[], Workflows extends readonly unknown[] = readonly unknown[]> {
+    readonly kind: 'runtime';
+    readonly integrations: Integrations;
+    readonly initialize: Initialize;
+    readonly actions: Actions;
+    readonly workflows: Workflows;
+    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 actions: unknown;
+    readonly workflows: unknown;
+}): RuntimeRegistry;
+export {};

package/dist/application/runtime/runtime.js

@@ -0,0 +1,28 @@
+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);
+    const actions = admitActions(callables, input.actions);
+    const workflows = admitWorkflows(callables, input.workflows);
+    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/define.d.ts

@@ -0,0 +1,6 @@
+import type { StateMachine } from './machine.js';
+import type { StateName, TransitionMap } from './relation.js';
+export declare function defineStateMachine<const Transitions extends TransitionMap>(input: Readonly<{
+    initial: StateName<Transitions>;
+    transitions: Transitions;
+}>): StateMachine<Transitions>;

package/dist/application/state/define.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { relation } from './relation.js';
+export function defineStateMachine(input) {
+    const admitted = relation(input);
+    const states = admitted.states;
+    const events = admitted.events;
+    const transitions = states.flatMap((from) => Object.entries(admitted.transitions[from]).map(([event, to]) => Object.freeze({ from, event, to })));
+    const illegalTransitions = states.flatMap((from) => events
+        .filter((event) => !Object.hasOwn(admitted.transitions[from], event))
+        .map((event) => Object.freeze({ from, event })));
+    const terminalStates = states.filter((state) => Object.keys(admitted.transitions[state]).length === 0);
+    const schema = z.enum(states);
+    return Object.freeze({
+        initial: admitted.initial,
+        schema,
+        states: Object.freeze(states),
+        events: Object.freeze(events),
+        terminalStates: Object.freeze(terminalStates),
+        transitions: Object.freeze(transitions),
+        illegalTransitions: Object.freeze(illegalTransitions),
+        can(state, event) {
+            return Object.hasOwn(admitted.transitions[state] ?? {}, event);
+        },
+        transition(state, event) {
+            const target = admitted.transitions[state]?.[event];
+            if (target === undefined)
+                throw new TypeError(`Illegal transition: ${state} + ${event}.`);
+            return target;
+        },
+    });
+}

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

@@ -0,0 +1,4 @@
+export { defineStateMachine } from './define.js';
+export type { EventOf, StateMachine, StateOf, TransitionOf } from './machine.js';
+export type { EventName, StateName, TransitionMap } from './relation.js';
+export type { IllegalTransitionCase, TransitionCase } from './transition.js';

package/dist/application/state/index.js

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

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

@@ -0,0 +1,24 @@
+import type { z } from 'zod';
+import type { EventName, StateName, TransitionMap } from './relation.js';
+import type { IllegalTransitionCase, TransitionCase } from './transition.js';
+export interface StateMachine<Transitions extends TransitionMap> {
+    readonly initial: StateName<Transitions>;
+    readonly schema: z.ZodType<StateName<Transitions>>;
+    readonly states: readonly StateName<Transitions>[];
+    readonly events: readonly EventName<Transitions>[];
+    readonly terminalStates: readonly StateName<Transitions>[];
+    readonly transitions: readonly TransitionCase<Transitions>[];
+    readonly illegalTransitions: readonly IllegalTransitionCase<Transitions>[];
+    can<State extends StateName<Transitions>>(state: State, event: EventName<Transitions>): event is Extract<keyof Transitions[State], string>;
+    transition<State extends StateName<Transitions>, Event extends Extract<keyof Transitions[State], string>>(state: State, event: Event): Extract<Transitions[State][Event], string>;
+    transition(state: StateName<Transitions>, event: EventName<Transitions>): StateName<Transitions>;
+}
+export type StateOf<Machine extends {
+    readonly states: readonly string[];
+}> = Machine['states'][number];
+export type EventOf<Machine extends {
+    readonly events: readonly string[];
+}> = Machine['events'][number];
+export type TransitionOf<Machine extends {
+    readonly transitions: readonly unknown[];
+}> = Machine['transitions'][number];

package/dist/application/state/machine.js

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

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

@@ -0,0 +1,12 @@
+export type TransitionMap = Readonly<Record<string, Readonly<Record<string, string>>>>;
+export type StateName<Transitions extends TransitionMap> = Extract<keyof Transitions, string>;
+export type EventName<Transitions extends TransitionMap> = Extract<{
+    [State in StateName<Transitions>]: keyof Transitions[State];
+}[StateName<Transitions>], string>;
+export interface StateRelation {
+    readonly initial: string;
+    readonly transitions: Readonly<Record<string, Readonly<Record<string, string>>>>;
+    readonly states: readonly string[];
+    readonly events: readonly string[];
+}
+export declare function relation(input: unknown): StateRelation;

package/dist/application/state/relation.js

@@ -0,0 +1,47 @@
+export function relation(input) {
+    if (!isRecord(input) || !exactKeys(input, ['initial', 'transitions']))
+        invalid();
+    const initial = input.initial;
+    const authored = input.transitions;
+    if (typeof initial !== 'string' || initial.length === 0 || !isRecord(authored))
+        invalid();
+    const states = Object.keys(authored);
+    if (states.length === 0 || !states.includes(initial))
+        invalid();
+    const stateSet = new Set(states);
+    const events = new Set();
+    const transitions = {};
+    for (const state of states) {
+        const outgoing = authored[state];
+        if (!isRecord(outgoing))
+            throw new TypeError(`State ${state} transitions must be an object.`);
+        const accepted = {};
+        for (const [event, target] of Object.entries(outgoing)) {
+            if (event.length === 0 || typeof target !== 'string' || !stateSet.has(target)) {
+                throw new TypeError(`State ${state} has an invalid ${event || '<empty>'} transition.`);
+            }
+            events.add(event);
+            accepted[event] = target;
+        }
+        transitions[state] = Object.freeze(accepted);
+    }
+    return Object.freeze({
+        initial,
+        transitions: Object.freeze(transitions),
+        states: Object.freeze(states),
+        events: Object.freeze([...events].sort(compareText)),
+    });
+}
+function invalid() {
+    throw new TypeError('State machine requires an initial state in one non-empty transition relation.');
+}
+function isRecord(input) {
+    return input !== null && typeof input === 'object' && !Array.isArray(input);
+}
+function exactKeys(input, expected) {
+    const keys = Reflect.ownKeys(input);
+    return keys.length === expected.length && keys.every((key) => expected.includes(String(key)));
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

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

@@ -0,0 +1,16 @@
+import type { EventName, StateName, TransitionMap } from './relation.js';
+export type TransitionCase<Transitions extends TransitionMap> = {
+    [State in StateName<Transitions>]: {
+        [Event in Extract<keyof Transitions[State], string>]: Readonly<{
+            from: State;
+            event: Event;
+            to: Extract<Transitions[State][Event], string>;
+        }>;
+    }[Extract<keyof Transitions[State], string>];
+}[StateName<Transitions>];
+export type IllegalTransitionCase<Transitions extends TransitionMap> = {
+    [State in StateName<Transitions>]: Readonly<{
+        from: State;
+        event: Exclude<EventName<Transitions>, keyof Transitions[State]>;
+    }>;
+}[StateName<Transitions>];

package/dist/application/state/transition.js

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

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.');
+}