@astrale-os/sdk 0.5.0-beta.8 → 0.5.0-beta.80

package/dist/application/requirements/requirement.d.ts

@@ -0,0 +1,17 @@
+import type { AuthorityOperation } from '../../platform/schema/index.js';
+import type { ClassRef, Key } from '../../platform/schema/index.js';
+import type { ClassOperation } from './classes.js';
+export interface ClassRequirement {
+    readonly class: ClassRef;
+    readonly operations: readonly [ClassOperation, ...ClassOperation[]];
+}
+export interface AdministrationRequirements {
+    readonly grant?: readonly [AuthorityOperation, ...AuthorityOperation[]];
+    readonly revoke?: readonly [AuthorityOperation, ...AuthorityOperation[]];
+}
+/** Canonical author intent; dependency-closure validation belongs to Build compilation. */
+export interface Requirements {
+    readonly callables: readonly Key.Callable[];
+    readonly classes: readonly ClassRequirement[];
+    readonly administration?: AdministrationRequirements;
+}

package/dist/application/requirements/requirement.js

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

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

@@ -0,0 +1,5 @@
+import type { publication } from '@astrale-os/kernel-protocol';
+import type { RuntimeRegistry } from '../runtime/index.js';
+import type { Routes } from './collection.js';
+/** Lower recipe identities to canonical callable keys after Runtime admission. */
+export declare function admit(input: Routes | undefined, registry: RuntimeRegistry): readonly publication.HttpRouteDeclaration[];

package/dist/application/routes/admission.js

@@ -0,0 +1,15 @@
+import { isRoutes } from './collection.js';
+/** Lower recipe identities to canonical callable keys after Runtime admission. */
+export function admit(input, registry) {
+    if (input === undefined)
+        return Object.freeze([]);
+    if (!isRoutes(input))
+        throw new TypeError('Application routes are not admitted.');
+    return Object.freeze(input.entries.map(({ target, ...declaration }) => {
+        const implementation = registry.implementations.find(({ definition }) => definition === target);
+        if (implementation === undefined) {
+            throw new TypeError(`Route ${declaration.name} targets a recipe outside the Runtime.`);
+        }
+        return Object.freeze({ ...declaration, callable: implementation.callable.key });
+    }));
+}

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

@@ -0,0 +1,8 @@
+import type { Route } from './route.js';
+export interface Routes<Entries extends readonly Route[] = readonly Route[]> {
+    readonly entries: Entries;
+}
+export declare function routes<const Entries extends readonly Route[]>(entries: Entries): Routes<Entries>;
+export declare function isRoutes(input: unknown): input is Routes;
+export declare function captureRoute<RouteValue extends Route>(route: RouteValue): RouteValue;
+export declare function isRoute(input: unknown): input is Route;

package/dist/application/routes/collection.js

@@ -0,0 +1,23 @@
+const admittedCollections = new WeakSet();
+export function routes(entries) {
+    if (!Array.isArray(entries) || entries.some((entry) => !isRoute(entry))) {
+        throw new TypeError('Routes must contain only values created by route().');
+    }
+    const names = entries.map(({ name }) => name);
+    if (new Set(names).size !== names.length)
+        throw new TypeError('Route names must be unique.');
+    const collection = Object.freeze({ entries: Object.freeze([...entries]) });
+    admittedCollections.add(collection);
+    return collection;
+}
+export function isRoutes(input) {
+    return input !== null && typeof input === 'object' && admittedCollections.has(input);
+}
+const admittedRoutes = new WeakSet();
+export function captureRoute(route) {
+    admittedRoutes.add(route);
+    return route;
+}
+export function isRoute(input) {
+    return input !== null && typeof input === 'object' && admittedRoutes.has(input);
+}

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

@@ -0,0 +1,9 @@
+import type { Route, RouteInput, RouteTarget } from './route.js';
+export { admit } from './admission.js';
+export { isRoute, isRoutes, routes, type Routes } from './collection.js';
+export type { Route, RouteInput, RouteTarget } from './route.js';
+type Recipe = RouteTarget & {
+    readonly run: (...input: never[]) => unknown;
+};
+/** Define one HTTP route without exposing DSL Function or Method topology. */
+export declare function route<const Target extends Recipe>(target: Target, input: RouteInput): Route<Target>;

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, 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,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/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;