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

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

@@ -0,0 +1,55 @@
+import * as value from '../../../platform/value/index.js';
+import { acceptStepId } from '../step/index.js';
+/** Process-local runner for tests and explicitly non-durable embeddings. */
+export function createInlineWorkflowRunner() {
+    async function run(workflow, context) {
+        const execution = createInlineStep(context.execution.signal);
+        const complete = Object.freeze({ ...context, step: execution.step });
+        try {
+            return await workflow.run(complete);
+        }
+        finally {
+            execution.close();
+        }
+    }
+    return Object.freeze({ run });
+}
+function createInlineStep(signal) {
+    const started = new Set();
+    let accepting = true;
+    const step = Object.freeze({
+        run(id, execute) {
+            let execution;
+            let accepted;
+            try {
+                if (!accepting)
+                    throw new TypeError('Workflow execution no longer accepts Steps.');
+                accepted = acceptStepId(id);
+                signal.throwIfAborted();
+                if (started.has(accepted)) {
+                    throw new TypeError(`Workflow Step ${accepted} occurs more than once.`);
+                }
+            }
+            catch (cause) {
+                execution = Promise.reject(cause);
+                return execution;
+            }
+            started.add(accepted);
+            execution = (async () => {
+                const output = await execute();
+                if (output === undefined)
+                    return output;
+                try {
+                    return value.accept(output);
+                }
+                catch (cause) {
+                    throw new TypeError(`Workflow Step ${accepted} output must be portable.`, {
+                        cause,
+                    });
+                }
+            })();
+            return execution;
+        },
+    });
+    return Object.freeze({ step, close: () => (accepting = false) });
+}

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

@@ -0,0 +1,10 @@
+import type { Domain, schema } from '../../../platform/schema/index.js';
+import type { ActionOutputOf, ResolvedCallable, ResolvedDomainOf } from '../../action/index.js';
+import type { DeclaredErrors, NoDeclaredErrors } from '../../error/index.js';
+import type { Integrations } from '../../integration/index.js';
+import type { WorkflowContext } from '../context.js';
+import type { CallableAtWorkflowAddress, WorkflowAddress, WorkflowDefinition } from '../workflow.js';
+export type WorkflowExecutionContext<Callable extends ResolvedCallable, Definitions extends Integrations, DomainValue extends Domain = Domain, Errors extends DeclaredErrors = NoDeclaredErrors> = Omit<WorkflowContext<Callable, DomainValue, Definitions, Errors>, 'step'>;
+export interface WorkflowRunner {
+    run<Schema extends schema.DomainSchema, Address extends WorkflowAddress<Schema>, Definitions extends Integrations, Errors extends DeclaredErrors, Callable extends CallableAtWorkflowAddress<Schema, Address> = CallableAtWorkflowAddress<Schema, Address>>(workflow: WorkflowDefinition<Schema, Address, Definitions, Errors>, context: WorkflowExecutionContext<Callable, Definitions, ResolvedDomainOf<Schema>, Errors>): Promise<ActionOutputOf<Callable>>;
+}

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

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

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

@@ -0,0 +1,2 @@
+export type { WorkflowStep } from './step.js';
+export { acceptStepId } from './run.js';

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

@@ -0,0 +1 @@
+export { acceptStepId } from './run.js';

package/dist/application/workflow/step/run.d.ts

@@ -0,0 +1,2 @@
+/** Admit one stable Workflow Step identifier. */
+export declare function acceptStepId(input: string): string;

package/dist/application/workflow/step/run.js

@@ -0,0 +1,10 @@
+/** Admit one stable Workflow Step identifier. */
+export function acceptStepId(input) {
+    if (typeof input !== 'string' ||
+        input.length === 0 ||
+        input.length > 128 ||
+        input.trim() !== input) {
+        throw new TypeError(`Invalid Workflow Step id: ${JSON.stringify(input)}.`);
+    }
+    return input;
+}

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

@@ -0,0 +1,4 @@
+/** Durable operation boundary supplied by the selected Workflow runner. */
+export interface WorkflowStep {
+    run<Output>(id: string, execute: () => Output | Promise<Output>): Promise<Output>;
+}

package/dist/application/workflow/step/step.js

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

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

@@ -0,0 +1,23 @@
+import type { CallableOutputOf, Domain, schema } from '../../platform/schema/index.js';
+import type { ActionAddressOf, ActionOutputOf, CallableAtAddress, LocalCallable, ResolvedCallable, ResolvedDomainOf } from '../action/index.js';
+import type { DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
+import type { Integrations } from '../integration/index.js';
+import type { WorkflowContext } from './context.js';
+export type WorkflowCallable<Callable> = Callable extends ResolvedCallable ? Callable extends {
+    readonly auth: 'anonymous';
+} ? never : CallableOutputOf<Callable> extends {
+    readonly mode: 'value';
+} ? Callable : never : never;
+export type WorkflowAddress<Schema extends schema.DomainSchema> = ActionAddressOf<WorkflowCallable<LocalCallable<ResolvedDomainOf<Schema>>>>;
+export type CallableAtWorkflowAddress<Schema extends schema.DomainSchema, Address extends WorkflowAddress<Schema>> = WorkflowCallable<Extract<CallableAtAddress<Schema, Address>, ResolvedCallable>>;
+export type Workflow<Callable extends ResolvedCallable, Definitions extends Integrations = Readonly<Record<never, never>>, DomainValue extends Domain = Domain, Errors extends DeclaredErrors = NoDeclaredErrors> = (context: WorkflowContext<Callable, DomainValue, Definitions, Errors>) => Promise<ActionOutputOf<Callable>>;
+declare const WORKFLOW_SCHEMA: unique symbol;
+/** Sealed multi-step Workflow awaiting canonical callable association by Runtime admission. */
+export interface WorkflowDefinition<Schema extends schema.DomainSchema = schema.DomainSchema, Address extends WorkflowAddress<Schema> = WorkflowAddress<Schema>, Definitions extends Integrations = Readonly<Record<never, never>>, Errors extends DeclaredErrors = NoDeclaredErrors> {
+    readonly kind: 'workflow';
+    readonly address: Address;
+    readonly run: Workflow<CallableAtWorkflowAddress<Schema, Address>, Definitions, ResolvedDomainOf<Schema>, Errors>;
+    /** Invariant type-only Schema witness; absent from emitted JavaScript. */
+    readonly [WORKFLOW_SCHEMA]: (schema: Schema) => Schema;
+}
+export {};

package/dist/application/workflow/workflow.js

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

package/dist/deployment/adapter/adapter.d.ts

@@ -0,0 +1,27 @@
+import type { DeployContext, DeployResult } from './deploy/index.js';
+import type { ArtifactSource, PrepareContext } from './prepare/index.js';
+export interface InstallationTarget {
+    readonly instance: string;
+    readonly identity?: string;
+}
+export interface AdapterEnvironmentContext {
+    readonly environment: string;
+    readonly installation?: InstallationTarget;
+}
+export interface Adapter<Parameters extends object = object> {
+    readonly kind: 'adapter';
+    readonly name: string;
+    readonly version: string;
+    admit?(parameters: Parameters, context: AdapterEnvironmentContext): void;
+    prepare(parameters: Parameters, context: PrepareContext): Promise<ArtifactSource>;
+    deploy(parameters: Parameters, context: DeployContext): Promise<DeployResult>;
+    readonly secretsFile?: (parameters: Parameters) => string | undefined;
+}
+export interface AdapterInput<Parameters extends object> {
+    readonly name: string;
+    readonly version: string;
+    admit?(parameters: Parameters, context: AdapterEnvironmentContext): void;
+    prepare(parameters: Parameters, context: PrepareContext): Promise<ArtifactSource>;
+    deploy(parameters: Parameters, context: DeployContext): Promise<DeployResult>;
+    readonly secretsFile?: (parameters: Parameters) => string | undefined;
+}

package/dist/deployment/adapter/adapter.js

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

package/dist/deployment/adapter/define.d.ts

@@ -0,0 +1,7 @@
+import type { Deployment } from '../deployment.js';
+import type { Adapter, AdapterInput } from './adapter.js';
+/** Capture one receiver-bound provider adapter. */
+export declare function defineAdapter<Parameters extends object>(input: AdapterInput<Parameters>): Adapter<Parameters>;
+/** Bind one provider adapter to the parameters of one Project Environment. */
+export declare function defineDeployment<const Parameters extends object>(adapter: Adapter<Parameters>, parameters: Parameters): Deployment<Parameters>;
+export declare function isAdapter(input: unknown): input is Adapter;

package/dist/deployment/adapter/define.js

@@ -0,0 +1,66 @@
+import { captureDeployment } from '../deployment.js';
+const admittedAdapters = new WeakSet();
+/** Capture one receiver-bound provider adapter. */
+export function defineAdapter(input) {
+    const value = record(input, 'Adapter definition');
+    exact(value, ['name', 'version', 'prepare', 'deploy'], ['admit', 'secretsFile']);
+    const name = stableName(input.name);
+    const version = stableName(input.version);
+    const receiver = Object.freeze({ ...input });
+    const admit = optional(receiver, 'admit');
+    const prepare = capture(receiver, 'prepare');
+    const deploy = capture(receiver, 'deploy');
+    const secretsFile = optional(receiver, 'secretsFile');
+    const adapter = Object.freeze({
+        kind: 'adapter',
+        name,
+        version,
+        ...(admit === undefined ? {} : { admit }),
+        prepare,
+        deploy,
+        ...(secretsFile === undefined ? {} : { secretsFile }),
+    });
+    admittedAdapters.add(adapter);
+    return adapter;
+}
+/** Bind one provider adapter to the parameters of one Project Environment. */
+export function defineDeployment(adapter, parameters) {
+    if (!isAdapter(adapter))
+        throw new TypeError('Deployment Adapter is not admitted.');
+    if (parameters === null || typeof parameters !== 'object' || Array.isArray(parameters)) {
+        throw new TypeError('Deployment parameters must be an object.');
+    }
+    return captureDeployment(adapter, Object.freeze({ ...parameters }));
+}
+export function isAdapter(input) {
+    return input !== null && typeof input === 'object' && admittedAdapters.has(input);
+}
+function stableName(input) {
+    if (typeof input !== 'string' || input.length === 0 || input.trim() !== input) {
+        throw new TypeError('Adapter name must be a non-empty stable string.');
+    }
+    return input;
+}
+function record(input, label) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError(`${label} must be an object.`);
+    }
+    return input;
+}
+function exact(input, required, optional) {
+    const allowed = new Set([...required, ...optional]);
+    if (required.some((key) => !Object.hasOwn(input, key)) ||
+        Reflect.ownKeys(input).some((key) => !allowed.has(key))) {
+        throw new TypeError('Adapter definition contains missing or unknown fields.');
+    }
+}
+function capture(receiver, key) {
+    const method = receiver[key];
+    if (typeof method !== 'function') {
+        throw new TypeError(`Adapter ${String(key)} operation is invalid.`);
+    }
+    return method.bind(receiver);
+}
+function optional(receiver, key) {
+    return receiver[key] === undefined ? undefined : capture(receiver, key);
+}

package/dist/deployment/adapter/deploy/context.d.ts

@@ -0,0 +1,15 @@
+import type { InstallationTarget } from '../adapter.js';
+import type { PreparedArtifact } from '../prepare/index.js';
+export interface DeployContext {
+    readonly projectDir: string;
+    readonly environment: string;
+    readonly installation?: InstallationTarget;
+    /** Optional command-scoped identity override (`--as`). */
+    readonly identity?: string;
+    /** Optional command-scoped credential; trusted adapters must neither retain nor disclose it. */
+    readonly credential?: string;
+    readonly secrets: Readonly<Record<string, string>>;
+    readonly artifact: PreparedArtifact;
+    /** Parent-owned lifecycle cancellation shared by every provider process/effect. */
+    readonly signal: AbortSignal;
+}

package/dist/deployment/adapter/deploy/context.js

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

package/dist/deployment/adapter/deploy/index.d.ts

@@ -0,0 +1,2 @@
+export type { DeployContext } from './context.js';
+export type { AppliedProviderDeployment, DeploymentPhase, DeploymentProgress, DeployResult, FailedDeployResult, MutationKnowledge, ProviderDeploymentEvidence, ReadyDeployResult, } from './result.js';

package/dist/deployment/adapter/deploy/index.js

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

package/dist/deployment/adapter/deploy/result.d.ts

@@ -0,0 +1,50 @@
+import type { Digest } from '@astrale-os/kernel-protocol/artifact';
+import type { Addressing, Release } from '../../release/index.js';
+export type DeploymentPhase = 'prerequisite' | 'provider' | 'addressing' | 'release' | 'configuration' | 'installation' | 'readiness';
+export type MutationKnowledge<Evidence = unknown> = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'partial';
+    readonly evidence?: Evidence;
+} | {
+    readonly kind: 'applied';
+    readonly evidence: Evidence;
+} | {
+    readonly kind: 'unknown';
+};
+export interface ProviderDeploymentEvidence {
+    readonly provider: string;
+    readonly deployment: string;
+    readonly artifact: Digest;
+    readonly issuer?: Addressing['issuer'];
+    /** Optional provider-side check before promotion; distinct from public readiness. */
+    readonly preflight?: 'passed' | 'unavailable';
+}
+export type AppliedProviderDeployment = {
+    readonly kind: 'applied';
+    readonly evidence: ProviderDeploymentEvidence & {
+        readonly issuer: Addressing['issuer'];
+    };
+};
+export interface DeploymentProgress {
+    readonly prerequisite: MutationKnowledge;
+    readonly provider: MutationKnowledge<ProviderDeploymentEvidence>;
+    readonly configuration: MutationKnowledge;
+    readonly installation: MutationKnowledge;
+}
+export interface ReadyDeployResult {
+    readonly status: 'ready';
+    readonly phase: 'complete';
+    readonly progress: DeploymentProgress & {
+        readonly provider: AppliedProviderDeployment;
+    };
+    readonly release: Release;
+}
+export interface FailedDeployResult {
+    readonly status: 'failed';
+    readonly phase: DeploymentPhase;
+    readonly progress: DeploymentProgress;
+    readonly error: Error;
+    readonly release?: Release;
+}
+export type DeployResult = ReadyDeployResult | FailedDeployResult;

package/dist/deployment/adapter/deploy/result.js

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

package/dist/deployment/adapter/index.d.ts

@@ -0,0 +1,4 @@
+export type { Adapter, AdapterEnvironmentContext, AdapterInput, InstallationTarget, } from './adapter.js';
+export { defineAdapter, defineDeployment, isAdapter } from './define.js';
+export type * from './prepare/index.js';
+export type * from './deploy/index.js';

package/dist/deployment/adapter/index.js

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

package/dist/deployment/adapter/prepare/artifact.d.ts

@@ -0,0 +1,33 @@
+import type { Digest } from '@astrale-os/kernel-protocol/artifact';
+import type { Build } from '../../build/index.js';
+import type { Addressing } from '../../release/index.js';
+export interface ArtifactFile {
+    readonly path: string;
+    readonly content: Uint8Array;
+}
+export interface PreparedArtifactFile {
+    readonly path: string;
+    bytes(): Uint8Array;
+}
+export type AddressingPlan = {
+    readonly kind: 'configured';
+    readonly addressing: Addressing;
+} | {
+    readonly kind: 'provider-assigned';
+    readonly claim: string;
+};
+/** Untrusted provider-specific preparation output admitted by verify/preflight. */
+export interface ArtifactSource {
+    readonly entrypoint: string;
+    readonly files: readonly ArtifactFile[];
+    readonly addressing: AddressingPlan;
+}
+/** Exact detached input supplied to every provider deployment effect. */
+export interface PreparedArtifact<BuildValue extends Build = Build> {
+    readonly kind: 'prepared-artifact';
+    readonly build: BuildValue;
+    readonly digest: Digest;
+    readonly entrypoint: string;
+    readonly files: readonly PreparedArtifactFile[];
+    readonly addressing: AddressingPlan;
+}

package/dist/deployment/adapter/prepare/artifact.js

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

package/dist/deployment/adapter/prepare/context.d.ts

@@ -0,0 +1,23 @@
+import type { Build } from '../../build/index.js';
+import type { ResolvedRuntimeReference } from '../../runtime/index.js';
+import type { InstallationTarget } from '../adapter.js';
+export interface PrepareContext<BuildValue extends Build = Build> {
+    readonly projectDir: string;
+    readonly environment: string;
+    readonly installation?: InstallationTarget;
+    /**
+     * Preparation purpose. Remote development and one-shot deployment both
+     * prepare complete release artifacts. Omitted by older custom callers means
+     * release for compatibility during the beta migration.
+     */
+    readonly mode?: 'release';
+    /**
+     * Optional preparation-input observer used by tooling that must rebuild when
+     * an adapter reads authored paths outside the Application/Runtime module graph.
+     */
+    readonly recordSource?: (path: string) => void;
+    /** Parent-owned lifecycle cancellation shared by every preparation process/effect. */
+    readonly signal: AbortSignal;
+    readonly build: BuildValue;
+    readonly runtime: ResolvedRuntimeReference;
+}

package/dist/deployment/adapter/prepare/context.js

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

package/dist/deployment/adapter/prepare/index.d.ts

@@ -0,0 +1,2 @@
+export type { PrepareContext } from './context.js';
+export type { AddressingPlan, ArtifactFile, ArtifactSource, PreparedArtifact, PreparedArtifactFile, } from './artifact.js';

package/dist/deployment/adapter/prepare/index.js

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

package/dist/deployment/authoring.d.ts

@@ -0,0 +1,5 @@
+export { deploy } from './deploy.js';
+export type { DeploymentInput, LegacyDeployment } from './deploy.js';
+export type { Deployment } from './deployment.js';
+export { runtime } from './runtime/index.js';
+export type { RuntimeReference } from './runtime/index.js';

package/dist/deployment/authoring.js

@@ -0,0 +1,2 @@
+export { deploy } from './deploy.js';
+export { runtime } from './runtime/index.js';

package/dist/deployment/build/admission.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeRegistry } from '../../application/runtime/index.js';
+import type { Domain } from '../../platform/schema/index.js';
+import type { Build } from './build.js';
+interface BuildEvidence {
+    readonly domain: Domain;
+    readonly registry: RuntimeRegistry;
+}
+/** Retain package ownership and realization evidence for one admitted Build. */
+export declare function admitBuild<Value extends Build>(build: Value, evidence: BuildEvidence): Value;
+export declare function isBuild(input: unknown): input is Build;
+export declare function evidenceOf(build: Build): BuildEvidence;
+export {};

package/dist/deployment/build/admission.js

@@ -0,0 +1,15 @@
+const admittedBuilds = new WeakMap();
+/** Retain package ownership and realization evidence for one admitted Build. */
+export function admitBuild(build, evidence) {
+    admittedBuilds.set(build, Object.freeze({ domain: evidence.domain, registry: evidence.registry }));
+    return build;
+}
+export function isBuild(input) {
+    return input !== null && typeof input === 'object' && admittedBuilds.has(input);
+}
+export function evidenceOf(build) {
+    const evidence = admittedBuilds.get(build);
+    if (evidence === undefined)
+        throw new TypeError('Build is not admitted.');
+    return evidence;
+}

package/dist/deployment/build/build.d.ts

@@ -0,0 +1,13 @@
+import type { publication, routes } from '@astrale-os/kernel-protocol';
+import type { Key, schema } from '../../platform/schema/index.js';
+import type { FrontendCompilation } from './frontend/index.js';
+import type { BuildSchema } from './schema.js';
+export interface Build<Schema extends schema.DomainSchema = schema.DomainSchema, RuntimeValue extends object = object> {
+    readonly kind: 'build';
+    readonly schema: BuildSchema<Schema>;
+    readonly runtime: RuntimeValue;
+    readonly callables: readonly Key.Callable[];
+    readonly requirements: publication.PublicationRequirements;
+    readonly routes: routes.Plan;
+    readonly frontend?: FrontendCompilation;
+}

package/dist/deployment/build/build.js

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

package/dist/deployment/build/compile.d.ts

@@ -0,0 +1,9 @@
+import type { Application } from '../../application/index.js';
+import type { Requirements } from '../../application/requirements/index.js';
+import type { Routes } from '../../application/routes/index.js';
+import type { Runtime } from '../../application/runtime/index.js';
+import type { Frontend as ApplicationFrontend } from '../../application/view/index.js';
+import type { schema } from '../../platform/schema/index.js';
+import type { Build } from './build.js';
+/** Compile one inert Application into provider-neutral, dependency-closed material. */
+export declare function compile<const Schema extends schema.DomainSchema, const RuntimeValue extends Runtime<Schema>, const Frontend extends ApplicationFrontend<Schema> | undefined, const RouteCollection extends Routes | undefined, const RequirementSet extends Requirements | undefined>(application: Application<Schema, RuntimeValue, Frontend, RouteCollection, RequirementSet>): Build<Schema, RuntimeValue>;

package/dist/deployment/build/compile.js

@@ -0,0 +1,114 @@
+import { artifact as artifactProtocol, publication, routes } from '@astrale-os/kernel-protocol';
+import { isApplication } from '../../application/index.js';
+import { admit as admitRoutes } from '../../application/routes/index.js';
+import { admitRuntimeRegistry } from '../../application/runtime/index.js';
+import { bundle, Key } from '../../platform/schema/index.js';
+import { schema as schemaApi } from '../../platform/schema/index.js';
+import { admitBuild } from './admission.js';
+import { compileFrontend } from './frontend/index.js';
+/** Compile one inert Application into provider-neutral, dependency-closed material. */
+export function compile(application) {
+    if (!isApplication(application)) {
+        throw new TypeError('Build compilation requires an admitted Application.');
+    }
+    const domain = schemaApi.resolve(application.schema);
+    const registry = admitRuntimeRegistry(domain, application.runtime);
+    const sourceBundle = bundle.create(application.schema);
+    const bytes = bundle.encode(sourceBundle);
+    const bundleBytes = new Uint8Array(bytes);
+    const compiled = schemaApi.compile(application.schema);
+    const requirements = compileRequirements(domain, application.requirements, sourceBundle);
+    const frontend = compileFrontend(application.frontend, domain);
+    const plan = routes.compile({
+        domain,
+        routes: admitRoutes(application.routes, registry),
+    });
+    const build = Object.freeze({
+        kind: 'build',
+        schema: Object.freeze({
+            compiled,
+            bundle: Object.freeze({
+                ref: artifactProtocol.identify(bundleBytes, publication.BUNDLE_MEDIA_TYPE),
+                bytes: () => new Uint8Array(bundleBytes),
+            }),
+        }),
+        runtime: application.runtime,
+        callables: Object.freeze(registry.implementations.map(({ callable }) => callable.key).sort()),
+        requirements,
+        routes: plan,
+        ...(frontend === undefined ? {} : { frontend }),
+    });
+    return admitBuild(build, { domain, registry });
+}
+function compileRequirements(domain, input, sourceBundle) {
+    for (const key of input?.functions ?? []) {
+        requireDirectDependency(domain, key, 'Function');
+        if (domain.callable(key) === undefined) {
+            throw new TypeError(`Function requirement ${key} is absent from the dependency closure.`);
+        }
+    }
+    for (const requirement of input?.classes ?? []) {
+        const key = Key.of(requirement.class);
+        requireDirectDependency(domain, key, 'Class');
+        if (domain.definition(requirement.class) === undefined) {
+            throw new TypeError('Class requirement is absent from the dependency closure.');
+        }
+    }
+    for (const requirement of input?.core ?? []) {
+        const subject = domain.core.nodes[requirement.subject.name];
+        if (requirement.subject.origin !== domain.origin || subject === undefined) {
+            throw new TypeError('Core capability subject must name one local Core Node.');
+        }
+        for (const key of requirement.functions) {
+            if (Key.origin(key) !== domain.origin) {
+                requireDirectDependency(domain, key, 'Core capability Function');
+            }
+            if (domain.callable(key) === undefined) {
+                throw new TypeError(`Core capability Function ${key} is absent from the dependency closure.`);
+            }
+        }
+        for (const classRequirement of requirement.classes) {
+            const key = Key.of(classRequirement.class);
+            if (classRequirement.class.origin !== domain.origin) {
+                requireDirectDependency(domain, key, 'Core capability Class');
+            }
+            if (domain.definition(classRequirement.class) === undefined) {
+                throw new TypeError('Core capability Class is absent from the dependency closure.');
+            }
+        }
+    }
+    const candidate = publication.admitRequirements({
+        capabilities: {
+            ...(input === undefined || input.functions.length === 0
+                ? {}
+                : { functions: input.functions }),
+            ...(input === undefined || input.classes.length === 0 ? {} : { classes: input.classes }),
+            ...(input?.authority === undefined ? {} : { authority: input.authority }),
+            ...(input === undefined || input.core.length === 0
+                ? {}
+                : {
+                    core: input.core.map((requirement) => ({
+                        subject: requirement.subject,
+                        ...(requirement.functions.length === 0 ? {} : { functions: requirement.functions }),
+                        ...(requirement.classes.length === 0 ? {} : { classes: requirement.classes }),
+                        ...(requirement.authority === undefined ? {} : { authority: requirement.authority }),
+                    })),
+                }),
+        },
+    });
+    publication.validateRequirements(sourceBundle.root, sourceBundle.closure, candidate);
+    return candidate;
+}
+function requireDirectDependency(domain, key, label) {
+    let origin;
+    try {
+        origin = Key.origin(Key(key));
+    }
+    catch {
+        throw new TypeError(`${label} requirement is invalid.`);
+    }
+    if (origin === domain.origin ||
+        !Object.values(domain.dependencies).some((dependency) => dependency.origin === origin)) {
+        throw new TypeError(`${label} requirement must target an exact direct dependency.`);
+    }
+}

package/dist/deployment/build/frontend/compilation.d.ts

@@ -0,0 +1,18 @@
+import type { Frontend, FrontendSource } from '../../../application/view/index.js';
+import type { FrontendHandshake, IframeRequirements } from '../../../application/view/index.js';
+import type { Key, ViewRef } from '../../../platform/schema/index.js';
+import type { Domain } from '../../../platform/schema/index.js';
+export interface CompiledFrontendRoute {
+    readonly view: Key.View;
+    readonly path: string;
+    readonly document: string;
+    readonly handshake: FrontendHandshake;
+    readonly iframe?: IframeRequirements;
+}
+export interface FrontendCompilation {
+    readonly source: FrontendSource;
+    readonly routes: readonly CompiledFrontendRoute[];
+    readonly entrypoint: ViewRef;
+}
+/** Lower exact authored View names to canonical DSL references without placing URLs. */
+export declare function compileFrontend(frontend: Frontend | undefined, domain: Domain): FrontendCompilation | undefined;

package/dist/deployment/build/frontend/compilation.js

@@ -0,0 +1,29 @@
+import { isFrontend } from '../../../application/view/index.js';
+/** Lower exact authored View names to canonical DSL references without placing URLs. */
+export function compileFrontend(frontend, domain) {
+    if (frontend === undefined)
+        return undefined;
+    if (!isFrontend(frontend) || frontend.schema.origin !== domain.origin) {
+        throw new TypeError('Build Frontend differs from its exact Schema Domain.');
+    }
+    const routes = Object.entries(frontend.routes).map(([name, route]) => {
+        const view = domain.views[name];
+        if (view === undefined)
+            throw new TypeError(`Frontend View ${name} is absent from its Domain.`);
+        return Object.freeze({
+            view: view.key,
+            path: route.path,
+            document: route.document,
+            handshake: route.handshake,
+            ...(route.iframe === undefined ? {} : { iframe: route.iframe }),
+        });
+    });
+    const entrypoint = domain.views[frontend.entrypoint];
+    if (entrypoint === undefined)
+        throw new TypeError('Frontend entrypoint is absent from its Domain.');
+    return Object.freeze({
+        source: frontend.source,
+        routes: Object.freeze(routes),
+        entrypoint: entrypoint.ref,
+    });
+}