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

package/dist/deployment/build/compile.js

@@ -0,0 +1,80 @@
+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);
+}
+function compileRequirements(domain, input, sourceBundle) {
+    for (const key of input?.callables ?? []) {
+        requireDirectDependency(domain, key, 'Callable');
+        if (domain.callable(key) === undefined) {
+            throw new TypeError(`Callable 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.');
+        }
+    }
+    const candidate = publication.admitRequirements({
+        capabilities: {
+            ...(input === undefined || input.callables.length === 0
+                ? {}
+                : { functions: input.callables }),
+            ...(input === undefined || input.classes.length === 0 ? {} : { classes: input.classes }),
+            ...(input?.administration === undefined ? {} : { admin: input.administration }),
+        },
+    });
+    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 || !domain.dependencies.some((entry) => entry.origin === origin)) {
+        throw new TypeError(`${label} requirement must target an exact direct dependency.`);
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { Frontend, FrontendSource } from '../../../application/view/index.js';
+import type { FrontendHandshake } 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;
+}
+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,28 @@
+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,
+        });
+    });
+    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,
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { Digest } from '@astrale-os/kernel-protocol/artifact';
+import type { FrontendCompilation } from './compilation.js';
+import type { FrontendFile } from './files.js';
+export declare function digest(frontend: FrontendCompilation, files: readonly FrontendFile[]): Digest;

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

@@ -0,0 +1,23 @@
+import { identify } from '@astrale-os/kernel-protocol/artifact';
+const MEDIA_TYPE = 'application/vnd.astrale.frontend-material+octet-stream;v=1';
+export function digest(frontend, files) {
+    const encoder = new TextEncoder();
+    const chunks = [
+        encoder.encode(JSON.stringify({
+            source: frontend.source,
+            routes: frontend.routes,
+            entrypoint: frontend.entrypoint,
+        })),
+    ];
+    for (const file of files) {
+        const bytes = file.bytes();
+        chunks.push(encoder.encode(`\0${file.path}\0${file.mediaType ?? ''}\0${bytes.byteLength}\0`), bytes);
+    }
+    const material = new Uint8Array(chunks.reduce((size, chunk) => size + chunk.byteLength, 0));
+    let offset = 0;
+    for (const chunk of chunks) {
+        material.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return identify(material, MEDIA_TYPE).digest;
+}

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

@@ -0,0 +1,13 @@
+import type { FrontendCompilation } from './compilation.js';
+export interface FrontendFileSource {
+    readonly path: string;
+    readonly content: Uint8Array;
+    readonly mediaType?: string;
+}
+export interface FrontendFile {
+    readonly path: string;
+    readonly mediaType?: string;
+    bytes(): Uint8Array;
+}
+/** Detach materialized browser files and prove every local View document exists. */
+export declare function files(frontend: FrontendCompilation, input: readonly FrontendFileSource[]): readonly FrontendFile[];

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

@@ -0,0 +1,61 @@
+/** Detach materialized browser files and prove every local View document exists. */
+export function files(frontend, input) {
+    if (!Array.isArray(input))
+        throw new TypeError('Frontend files must be an array.');
+    if (frontend.source.kind === 'external' && input.length > 0) {
+        throw new TypeError('External Frontend cannot contain local files.');
+    }
+    const paths = new Set();
+    const admitted = input.map((file) => {
+        if (file === null || typeof file !== 'object' || Array.isArray(file))
+            invalid();
+        if (Reflect.ownKeys(file).some((key) => key !== 'path' && key !== 'content' && key !== 'mediaType') ||
+            !(file.content instanceof Uint8Array)) {
+            invalid();
+        }
+        const path = filePath(file.path);
+        if (paths.has(path))
+            throw new TypeError(`Frontend file ${path} is duplicated.`);
+        paths.add(path);
+        const mediaType = acceptMediaType(file.mediaType);
+        const content = new Uint8Array(file.content);
+        return Object.freeze({
+            path,
+            ...(mediaType === undefined ? {} : { mediaType }),
+            bytes: () => new Uint8Array(content),
+        });
+    });
+    if (frontend.source.kind === 'vite') {
+        for (const route of frontend.routes) {
+            if (!paths.has(route.document)) {
+                throw new TypeError(`Frontend View document ${route.document} is absent.`);
+            }
+        }
+    }
+    return Object.freeze(admitted.sort((left, right) => compare(left.path, right.path)));
+}
+function filePath(input) {
+    if (typeof input !== 'string' ||
+        input.length === 0 ||
+        input.startsWith('/') ||
+        input.includes('\\') ||
+        input.split('/').some((segment) => segment === '' || segment === '.' || segment === '..')) {
+        invalid();
+    }
+    return input;
+}
+function acceptMediaType(input) {
+    if (input === undefined)
+        return undefined;
+    if (typeof input !== 'string' ||
+        !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u.test(input)) {
+        invalid();
+    }
+    return input.toLowerCase();
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function invalid() {
+    throw new TypeError('Frontend file is invalid.');
+}

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

@@ -0,0 +1,6 @@
+export { compileFrontend } from './compilation.js';
+export type { CompiledFrontendRoute, FrontendCompilation } from './compilation.js';
+export { digest } from './digest.js';
+export { files } from './files.js';
+export type { FrontendFile, FrontendFileSource } from './files.js';
+export { provenance, type FrontendProvenance } from './provenance.js';

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

@@ -0,0 +1,4 @@
+export { compileFrontend } from './compilation.js';
+export { digest } from './digest.js';
+export { files } from './files.js';
+export { provenance } from './provenance.js';

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

@@ -0,0 +1,7 @@
+import type { FrontendSource } from '../../../application/view/index.js';
+export interface FrontendProvenance {
+    readonly adapter: string;
+    readonly source: FrontendSource['kind'];
+    readonly build?: string;
+}
+export declare function provenance(adapter: string, source: FrontendSource['kind'], build?: string): FrontendProvenance;

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

@@ -0,0 +1,12 @@
+export function provenance(adapter, source, build) {
+    if (typeof adapter !== 'string' || adapter.length === 0 || adapter.trim() !== adapter)
+        invalid();
+    if (source !== 'vite' && source !== 'external')
+        invalid();
+    if (build !== undefined && (build.length === 0 || build.trim() !== build))
+        invalid();
+    return Object.freeze({ adapter, source, ...(build === undefined ? {} : { build }) });
+}
+function invalid() {
+    throw new TypeError('Frontend provenance is invalid.');
+}

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

@@ -0,0 +1,6 @@
+export { isBuild } from './admission.js';
+export { compile } from './compile.js';
+export { material, restoreBuild, type BuildMaterial } from './material.js';
+export type { Build } from './build.js';
+export * as frontend from './frontend/index.js';
+export type { BuildBundle, BuildSchema } from './schema.js';

package/dist/deployment/build/index.js

@@ -0,0 +1,4 @@
+export { isBuild } from './admission.js';
+export { compile } from './compile.js';
+export { material, restoreBuild } from './material.js';
+export * as frontend from './frontend/index.js';

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

@@ -0,0 +1,23 @@
+import type { DomainSchema } from '@astrale-os/kernel-dsl/v1/schema';
+import type { Runtime } from '../../application/runtime/index.js';
+import type { Build } from './build.js';
+import type { FrontendCompilation } from './frontend/index.js';
+export interface BuildMaterial {
+    readonly format: 'astrale.sdk.build-material';
+    readonly version: 1;
+    readonly schema: {
+        readonly compiled: Build['schema']['compiled'];
+        readonly bundle: {
+            readonly ref: Build['schema']['bundle']['ref'];
+            readonly bytes: readonly number[];
+        };
+    };
+    readonly callables: Build['callables'];
+    readonly requirements: Build['requirements'];
+    readonly routes: Build['routes'];
+    readonly frontend?: FrontendCompilation;
+}
+/** Detach the provider-neutral, runtime-free material embedded into generated execution code. */
+export declare function material(build: Build): BuildMaterial;
+/** Re-admit generated Build material and bind it to the exact imported Runtime value. */
+export declare function restoreBuild<RuntimeValue extends Runtime>(input: BuildMaterial, runtime: RuntimeValue): Build<DomainSchema, RuntimeValue>;

package/dist/deployment/build/material.js

@@ -0,0 +1,94 @@
+import * as bundle from '@astrale-os/kernel-dsl/v1/bundle/transport';
+import { load as loadCompiledSchema } from '@astrale-os/kernel-dsl/v1/compiled/loader';
+import { revision } from '@astrale-os/kernel-dsl/v1/schema/revision';
+import * as artifact from '@astrale-os/kernel-protocol/artifact';
+import { BUNDLE_MEDIA_TYPE } from '@astrale-os/kernel-protocol/publication/bundle';
+import { admitRequirements, validateRequirements, } from '@astrale-os/kernel-protocol/publication/requirements';
+import { admitRuntimeRegistry, isRuntime } from '../../application/runtime/index.js';
+import { admitBuild, isBuild } from './admission.js';
+/** Detach the provider-neutral, runtime-free material embedded into generated execution code. */
+export function material(build) {
+    if (!isBuild(build))
+        throw new TypeError('Build material requires an admitted Build.');
+    return Object.freeze({
+        format: 'astrale.sdk.build-material',
+        version: 1,
+        schema: Object.freeze({
+            compiled: build.schema.compiled,
+            bundle: Object.freeze({
+                ref: build.schema.bundle.ref,
+                bytes: Object.freeze([...build.schema.bundle.bytes()]),
+            }),
+        }),
+        callables: build.callables,
+        requirements: build.requirements,
+        routes: build.routes,
+        ...(build.frontend === undefined ? {} : { frontend: build.frontend }),
+    });
+}
+/** Re-admit generated Build material and bind it to the exact imported Runtime value. */
+export function restoreBuild(input, runtime) {
+    if (!isRuntime(runtime))
+        throw new TypeError('Generated Runtime is not admitted.');
+    if (input === null ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        input.format !== 'astrale.sdk.build-material' ||
+        input.version !== 1 ||
+        Reflect.ownKeys(input).some((key) => key !== 'format' &&
+            key !== 'version' &&
+            key !== 'schema' &&
+            key !== 'callables' &&
+            key !== 'requirements' &&
+            key !== 'routes' &&
+            key !== 'frontend')) {
+        invalid();
+    }
+    const domain = loadCompiledSchema(input.schema.compiled);
+    const bytes = Uint8Array.from(input.schema.bundle.bytes);
+    const decoded = bundle.decode(bytes);
+    const identified = artifact.identify(bytes, BUNDLE_MEDIA_TYPE);
+    if (identified.digest !== input.schema.bundle.ref.digest ||
+        identified.mediaType !== input.schema.bundle.ref.mediaType ||
+        decoded.root.origin !== input.schema.compiled.root.origin ||
+        revision(decoded.root) !== input.schema.compiled.root.revision) {
+        invalid();
+    }
+    const registry = admitRuntimeRegistry(domain, runtime);
+    const callables = registry.implementations.map(({ callable }) => callable.key).sort();
+    if (callables.length !== input.callables.length ||
+        callables.some((key, index) => key !== input.callables[index])) {
+        throw new TypeError('Generated Runtime differs from Build material.');
+    }
+    const requirements = admitRequirements(input.requirements);
+    validateRequirements(decoded.root, decoded.closure, requirements);
+    if (input.routes.origin !== domain.origin ||
+        input.routes.revision !== domain.revision ||
+        !Array.isArray(input.routes.entries)) {
+        invalid();
+    }
+    const detached = new Uint8Array(bytes);
+    const build = Object.freeze({
+        kind: 'build',
+        schema: Object.freeze({
+            compiled: input.schema.compiled,
+            bundle: Object.freeze({
+                ref: input.schema.bundle.ref,
+                bytes: () => new Uint8Array(detached),
+            }),
+        }),
+        runtime,
+        callables: Object.freeze([...input.callables]),
+        requirements,
+        routes: Object.freeze({
+            origin: input.routes.origin,
+            revision: input.routes.revision,
+            entries: Object.freeze([...input.routes.entries]),
+        }),
+        ...(input.frontend === undefined ? {} : { frontend: input.frontend }),
+    });
+    return admitBuild(build);
+}
+function invalid() {
+    throw new TypeError('Generated Build material is invalid.');
+}

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

@@ -0,0 +1,10 @@
+import type { publication } from '@astrale-os/kernel-protocol';
+import type { schema } from '../../platform/schema/index.js';
+export interface BuildBundle {
+    readonly ref: publication.BundleDescriptor['ref'];
+    bytes(): Uint8Array;
+}
+export interface BuildSchema<Source extends schema.DomainSchema = schema.DomainSchema> {
+    readonly compiled: schema.CompiledSchema<schema.DomainOf<Source>>;
+    readonly bundle: BuildBundle;
+}

package/dist/deployment/build/schema.js

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

package/dist/deployment/deploy.d.ts

@@ -0,0 +1,15 @@
+import type { Application } from '../application/index.js';
+import type { Adapter } from './adapter/index.js';
+import type { Deployment } from './deployment.js';
+import type { RuntimeReference } from './runtime/index.js';
+type CanonicalApplication<Value> = Value extends Application<infer _Schema, infer _Runtime, infer _Frontend, infer _Routes, infer _Requirements> ? Value : never;
+type CanonicalAdapter<Value> = Value extends Adapter<infer _Parameters> ? Value : never;
+export interface DeploymentInput<ApplicationValue extends object, AdapterValue extends object> {
+    readonly application: CanonicalApplication<ApplicationValue>;
+    readonly entrypoint: RuntimeReference;
+    readonly adapter: CanonicalAdapter<AdapterValue>;
+}
+/** Capture one inert Application, Runtime module reference, and provider Adapter declaration. */
+export declare function deploy<const ApplicationValue extends object, const AdapterValue extends object>(input: DeploymentInput<ApplicationValue, AdapterValue>): Deployment<ApplicationValue, AdapterValue>;
+export declare function isDeployment(input: unknown): input is Deployment;
+export {};

package/dist/deployment/deploy.js

@@ -0,0 +1,31 @@
+import { isApplication } from '../application/index.js';
+import { isAdapter } from './adapter/index.js';
+import { isRuntimeReference } from './runtime/index.js';
+const admittedDeployments = new WeakSet();
+/** Capture one inert Application, Runtime module reference, and provider Adapter declaration. */
+export function deploy(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    const keys = Reflect.ownKeys(input);
+    if (keys.length !== 3 ||
+        keys.some((key) => key !== 'application' && key !== 'entrypoint' && key !== 'adapter')) {
+        invalid();
+    }
+    if (!isApplication(input.application)) {
+        throw new TypeError('Deployment Application is not admitted.');
+    }
+    if (!isRuntimeReference(input.entrypoint)) {
+        throw new TypeError('Deployment entrypoint must be created by runtime(path).');
+    }
+    if (!isAdapter(input.adapter))
+        throw new TypeError('Deployment Adapter is not admitted.');
+    const deployment = Object.freeze({ ...input });
+    admittedDeployments.add(deployment);
+    return deployment;
+}
+export function isDeployment(input) {
+    return input !== null && typeof input === 'object' && admittedDeployments.has(input);
+}
+function invalid() {
+    throw new TypeError('Deployment must contain exactly application, entrypoint, and adapter.');
+}

package/dist/deployment/deployment.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimeReference } from './runtime/index.js';
+export interface Deployment<ApplicationValue extends object = object, AdapterValue extends object = object> {
+    readonly application: ApplicationValue;
+    readonly entrypoint: RuntimeReference;
+    readonly adapter: AdapterValue;
+}

package/dist/deployment/deployment.js

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

package/dist/deployment/index.d.ts

@@ -1,7 +1,13 @@
-export { bindCallables, createDeployment } from './artifact/index.js';
-export type { CreateDeploymentInput, Deployment } from './artifact/index.js';
-export { deployCheck } from './check/index.js';
-export type { DeployCheckOptions } from './check/index.js';
-export { defineAdapter, deploy } from './provider/index.js';
-export type { AdapterSpec, BuildCtx, DeployConfig, DeployCtx, DeployResult, DomainAdapter, WatchCtx, WatchHandle, } from './provider/index.js';
-//# sourceMappingURL=index.d.ts.map
+export { defineAdapter, isAdapter } from './adapter/index.js';
+export type { Adapter, AdapterInput, AddressingPlan, ArtifactFile, ArtifactSource, DeployContext, DeploymentPhase, DeploymentProgress, DeployResult, FailedDeployResult, MutationKnowledge, PreparedArtifact, PreparedArtifactFile, PrepareContext, ReadyDeployResult, WatchContext, WatchHandle, } from './adapter/index.js';
+export { compile, isBuild } from './build/index.js';
+export type { Build, BuildBundle, BuildSchema } from './build/index.js';
+export { deploy, isDeployment } from './deploy.js';
+export type { DeploymentInput } from './deploy.js';
+export type { Deployment } from './deployment.js';
+export { addressing, assemble, isAddressing, isRelease } from './release/index.js';
+export type { Addressing, Release } from './release/index.js';
+export { admit as admitRuntime, resolve as resolveRuntime, runtime } from './runtime/index.js';
+export type { ResolvedRuntimeReference, RuntimeModuleLoader, RuntimeReference, } from './runtime/index.js';
+export { verifyDeployment, verifyPreflight, verifyReadiness } from './verify/index.js';
+export type { PreflightInput } from './verify/index.js';

package/dist/deployment/index.js

@@ -1,4 +1,6 @@
-export { bindCallables, createDeployment } from './artifact/index.js';
-export { deployCheck } from './check/index.js';
-export { defineAdapter, deploy } from './provider/index.js';
-//# sourceMappingURL=index.js.map
+export { defineAdapter, isAdapter } from './adapter/index.js';
+export { compile, isBuild } from './build/index.js';
+export { deploy, isDeployment } from './deploy.js';
+export { addressing, assemble, isAddressing, isRelease } from './release/index.js';
+export { admit as admitRuntime, resolve as resolveRuntime, runtime } from './runtime/index.js';
+export { verifyDeployment, verifyPreflight, verifyReadiness } from './verify/index.js';

package/dist/deployment/release/addressing.d.ts

@@ -0,0 +1,7 @@
+import type { IssuerId } from '../../platform/auth/index.js';
+/** Intended serving identity, independent of how a provider obtains it. */
+export interface Addressing {
+    readonly issuer: IssuerId;
+}
+export declare function addressing(input: string): Addressing;
+export declare function isAddressing(input: unknown): input is Addressing;

package/dist/deployment/release/addressing.js

@@ -0,0 +1,27 @@
+import { issuer } from '../../platform/auth/index.js';
+const admittedAddressing = new WeakSet();
+export function addressing(input) {
+    let admitted;
+    let url;
+    try {
+        admitted = issuer.accept(input);
+        url = new URL(admitted);
+    }
+    catch (cause) {
+        throw new TypeError('Addressing issuer must be an absolute HTTP(S) issuer.', { cause });
+    }
+    if ((url.protocol !== 'https:' && url.protocol !== 'http:') ||
+        url.username !== '' ||
+        url.password !== '' ||
+        url.pathname !== '/' ||
+        url.search !== '' ||
+        url.hash !== '') {
+        throw new TypeError('Addressing issuer must be an origin-only absolute HTTP(S) issuer.');
+    }
+    const value = Object.freeze({ issuer: admitted });
+    admittedAddressing.add(value);
+    return value;
+}
+export function isAddressing(input) {
+    return input !== null && typeof input === 'object' && admittedAddressing.has(input);
+}

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

@@ -0,0 +1,3 @@
+import type { Release } from './release.js';
+export declare function capture<ReleaseValue extends Release>(release: ReleaseValue): ReleaseValue;
+export declare function isRelease(input: unknown): input is Release;

package/dist/deployment/release/admission.js

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

package/dist/deployment/release/assemble.d.ts

@@ -0,0 +1,5 @@
+import type { Build } from '../build/build.js';
+import type { Addressing } from './addressing.js';
+import type { Release } from './release.js';
+/** Purely assemble one complete current serving contract without a provider effect. */
+export declare function assemble<const BuildValue extends Build>(build: BuildValue, addressing: Addressing): Release<BuildValue>;

package/dist/deployment/release/assemble.js

@@ -0,0 +1,20 @@
+import { isBuild } from '../build/admission.js';
+import { isAddressing } from './addressing.js';
+import { capture } from './admission.js';
+import { seal } from './publication/index.js';
+/** Purely assemble one complete current serving contract without a provider effect. */
+export function assemble(build, addressing) {
+    if (!isBuild(build))
+        throw new TypeError('Release assembly requires an admitted Build.');
+    if (!isAddressing(addressing)) {
+        throw new TypeError('Release assembly requires admitted Addressing.');
+    }
+    const sealed = seal(build, addressing);
+    return capture(Object.freeze({
+        kind: 'release',
+        build,
+        addressing,
+        publication: sealed.publication,
+        routes: sealed.routes,
+    }));
+}

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

@@ -0,0 +1,5 @@
+export { assemble } from './assemble.js';
+export { capture, isRelease } from './admission.js';
+export { addressing, isAddressing, type Addressing } from './addressing.js';
+export { invocationPath, releaseUnavailable, requestedRevision } from './invocation.js';
+export type { Release } from './release.js';

package/dist/deployment/release/index.js

@@ -0,0 +1,4 @@
+export { assemble } from './assemble.js';
+export { capture, isRelease } from './admission.js';
+export { addressing, isAddressing } from './addressing.js';
+export { invocationPath, releaseUnavailable, requestedRevision } from './invocation.js';

package/dist/deployment/release/invocation.d.ts

@@ -0,0 +1,7 @@
+import type { Revision } from '../../platform/schema/index.js';
+/** Stable invocation path for one exact Schema revision. */
+export declare function invocationPath(revision: Revision): string;
+/** Read an exact revision endpoint; unrelated paths are not release requests. */
+export declare function requestedRevision(pathname: string): Revision | undefined;
+/** Reserved response for an exact Schema revision that is no longer available. */
+export declare function releaseUnavailable(): Response;