@astrale-os/sdk 0.5.0-beta.2 → 0.5.0-beta.21

package/dist/application/view/source.js

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

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

@@ -0,0 +1,3 @@
+export { defineWorkflow } from './define.js';
+export type { WorkflowContext } from './context.js';
+export type { Workflow, WorkflowAddress, WorkflowDefinition } from './workflow.js';

package/dist/application/workflow/authoring.js

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

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

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

package/dist/application/workflow/context.js

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

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

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

package/dist/application/workflow/define.js

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

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

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

package/dist/application/workflow/index.js

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

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

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

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

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

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

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

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,9 @@
+import type { Domain, schema } from '../../../platform/schema/index.js';
+import type { ActionOutputOf, ResolvedCallable, ResolvedDomainOf } from '../../action/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> = Omit<WorkflowContext<Callable, DomainValue, Definitions>, 'step'>;
+export interface WorkflowRunner {
+    run<Schema extends schema.DomainSchema, Address extends WorkflowAddress<Schema>, Definitions extends Integrations, Callable extends CallableAtWorkflowAddress<Schema, Address> = CallableAtWorkflowAddress<Schema, Address>>(workflow: WorkflowDefinition<Schema, Address, Definitions>, context: WorkflowExecutionContext<Callable, Definitions, ResolvedDomainOf<Schema>>): 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,22 @@
+import type { CallableOutputOf, Domain, schema } from '../../platform/schema/index.js';
+import type { ActionAddressOf, ActionOutputOf, CallableAtAddress, LocalCallable, ResolvedCallable, ResolvedDomainOf } from '../action/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> = (context: WorkflowContext<Callable, DomainValue, Definitions>) => 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>>> {
+    readonly kind: 'workflow';
+    readonly address: Address;
+    readonly run: Workflow<CallableAtWorkflowAddress<Schema, Address>, Definitions, ResolvedDomainOf<Schema>>;
+    /** 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,22 @@
+import type { DeployContext, DeployResult } from './deploy/index.js';
+import type { ArtifactSource, PrepareContext } from './prepare/index.js';
+import type { WatchContext, WatchHandle } from './watch/index.js';
+export interface Adapter<Parameters = unknown> {
+    readonly kind: 'adapter';
+    readonly name: string;
+    readonly version: string;
+    parameters(environment: string): Parameters;
+    prepare(parameters: Parameters, context: PrepareContext): Promise<ArtifactSource>;
+    watch(parameters: Parameters, context: WatchContext): Promise<WatchHandle>;
+    deploy(parameters: Parameters, context: DeployContext): Promise<DeployResult>;
+    readonly secretsFile?: (parameters: Parameters) => string | undefined;
+}
+export interface AdapterInput<Parameters> {
+    readonly name: string;
+    readonly version: string;
+    readonly environments: Readonly<Record<string, Parameters>>;
+    prepare(parameters: Parameters, context: PrepareContext): Promise<ArtifactSource>;
+    watch(parameters: Parameters, context: WatchContext): Promise<WatchHandle>;
+    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,4 @@
+import type { Adapter, AdapterInput } from './adapter.js';
+/** Capture one receiver-bound provider adapter and its environment parameters. */
+export declare function defineAdapter<Parameters>(input: AdapterInput<Parameters>): Adapter<Parameters>;
+export declare function isAdapter(input: unknown): input is Adapter;

package/dist/deployment/adapter/define.js

@@ -0,0 +1,68 @@
+const admittedAdapters = new WeakSet();
+/** Capture one receiver-bound provider adapter and its environment parameters. */
+export function defineAdapter(input) {
+    const value = record(input, 'Adapter definition');
+    exact(value, ['name', 'version', 'environments', 'prepare', 'watch', 'deploy'], ['secretsFile']);
+    const name = stableName(input.name);
+    const version = stableName(input.version);
+    const environments = record(input.environments, 'Adapter environments');
+    if (Reflect.ownKeys(environments).some((key) => typeof key !== 'string')) {
+        throw new TypeError('Adapter environment names must be strings.');
+    }
+    const capturedEnvironments = Object.freeze({ ...environments });
+    const names = Object.keys(capturedEnvironments).sort();
+    const receiver = Object.freeze({ ...input, environments: capturedEnvironments });
+    const prepare = capture(receiver, 'prepare');
+    const watch = capture(receiver, 'watch');
+    const deploy = capture(receiver, 'deploy');
+    const secretsFile = optional(receiver, 'secretsFile');
+    const adapter = Object.freeze({
+        kind: 'adapter',
+        name,
+        version,
+        parameters(environment) {
+            if (Object.hasOwn(capturedEnvironments, environment)) {
+                return capturedEnvironments[environment];
+            }
+            throw new TypeError(`Adapter ${name} has no environment ${environment}; known environments: ${names.length === 0 ? '(none)' : names.join(', ')}.`);
+        },
+        prepare,
+        watch,
+        deploy,
+        ...(secretsFile === undefined ? {} : { secretsFile }),
+    });
+    admittedAdapters.add(adapter);
+    return adapter;
+}
+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,7 @@
+import type { PreparedArtifact } from '../prepare/index.js';
+export interface DeployContext {
+    readonly projectDir: string;
+    readonly environment: string;
+    readonly secrets: Readonly<Record<string, string>>;
+    readonly artifact: PreparedArtifact;
+}

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,48 @@
+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'];
+}
+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,5 @@
+export type { Adapter, AdapterInput } from './adapter.js';
+export { defineAdapter, isAdapter } from './define.js';
+export type * from './prepare/index.js';
+export type * from './watch/index.js';
+export type * from './deploy/index.js';

package/dist/deployment/adapter/index.js

@@ -0,0 +1 @@
+export { defineAdapter, 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,8 @@
+import type { Build } from '../../build/index.js';
+import type { ResolvedRuntimeReference } from '../../runtime/index.js';
+export interface PrepareContext<BuildValue extends Build = Build> {
+    readonly projectDir: string;
+    readonly environment: string;
+    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/adapter/watch/context.d.ts

@@ -0,0 +1,8 @@
+import type { PreparedArtifact } from '../prepare/index.js';
+export interface WatchContext {
+    readonly projectDir: string;
+    readonly environment: string;
+    readonly secrets: Readonly<Record<string, string>>;
+    readonly artifact: PreparedArtifact;
+    onReload(): void;
+}

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

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

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

@@ -0,0 +1,5 @@
+export interface WatchHandle {
+    readonly url: string;
+    readonly localUrl?: string;
+    stop(): Promise<void>;
+}

package/dist/deployment/adapter/watch/handle.js

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

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

@@ -0,0 +1,2 @@
+export type { WatchContext } from './context.js';
+export type { WatchHandle } from './handle.js';

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

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

package/dist/deployment/authoring.d.ts

@@ -0,0 +1,5 @@
+export { deploy } from './deploy.js';
+export type { DeploymentInput } 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,4 @@
+import type { Build } from './build.js';
+/** Retain package ownership of one compiled or restored Build value. */
+export declare function admitBuild<Value extends Build>(build: Value): Value;
+export declare function isBuild(input: unknown): input is Build;

package/dist/deployment/build/admission.js

@@ -0,0 +1,9 @@
+const admittedBuilds = new WeakSet();
+/** Retain package ownership of one compiled or restored Build value. */
+export function admitBuild(build) {
+    admittedBuilds.add(build);
+    return build;
+}
+export function isBuild(input) {
+    return input !== null && typeof input === 'object' && admittedBuilds.has(input);
+}

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