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

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, generatedMaterial, restoreBuild, restoreGeneratedBuild, type BuildMaterial, type GeneratedBuildMaterial, } 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, generatedMaterial, restoreBuild, restoreGeneratedBuild, } from './material.js';
+export * as frontend from './frontend/index.js';

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

@@ -0,0 +1,42 @@
+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;
+}
+declare const GENERATED_BUILD_MATERIAL: unique symbol;
+/** Exact Build material embedded by an Astrale execution-code generator. */
+export interface GeneratedBuildMaterial {
+    readonly format: 'astrale.sdk.generated-build-material';
+    readonly version: 1;
+    readonly material: BuildMaterial;
+    readonly digest: Build['schema']['bundle']['ref']['digest'];
+    readonly [GENERATED_BUILD_MATERIAL]: 'generated-build-material';
+}
+/** Detach the provider-neutral, runtime-free material embedded into generated execution code. */
+export declare function material(build: Build): BuildMaterial;
+/** Produce opaque material for execution code from one admitted Build. */
+export declare function generatedMaterial(build: Build): GeneratedBuildMaterial;
+/** Re-admit detached provider-neutral Build material against the exact Runtime value. */
+export declare function restoreBuild<RuntimeValue extends Runtime>(input: BuildMaterial, runtime: RuntimeValue): Build<DomainSchema, RuntimeValue>;
+/**
+ * Bind material embedded by generated release code without repeating its external admission.
+ * Build generators must call {@link generatedMaterial} before embedding the exact envelope;
+ * decoded files, network values, and caller-provided JSON must continue through
+ * {@link restoreBuild}.
+ */
+export declare function restoreGeneratedBuild<RuntimeValue extends Runtime>(input: GeneratedBuildMaterial, runtime: RuntimeValue): Build<DomainSchema, RuntimeValue>;
+export {};

package/dist/deployment/build/material.js

@@ -0,0 +1,201 @@
+import * as bundle from '@astrale-os/kernel-dsl/v1/bundle/transport';
+import { load as loadGeneratedSchema } from '@astrale-os/kernel-dsl/v1/compiled/generated';
+import { load as loadCompiledSchema } from '@astrale-os/kernel-dsl/v1/compiled/loader';
+import { revision } from '@astrale-os/kernel-dsl/v1/schema/revision';
+import { equal } from '@astrale-os/kernel-dsl/value';
+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 * as routes from '@astrale-os/kernel-protocol/routes';
+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.');
+    if (!isRuntime(build.runtime))
+        throw new TypeError('Build Runtime is not admitted.');
+    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 }),
+    });
+}
+/** Produce opaque material for execution code from one admitted Build. */
+export function generatedMaterial(build) {
+    const value = deepFreeze(material(build));
+    return Object.freeze({
+        format: 'astrale.sdk.generated-build-material',
+        version: 1,
+        material: value,
+        digest: digestOf(value),
+    });
+}
+/** Re-admit detached provider-neutral Build material against the exact Runtime value. */
+export function restoreBuild(input, runtime) {
+    assertMaterialEnvelope(input, runtime);
+    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 ||
+        identified.size !== input.schema.bundle.ref.size ||
+        decoded.root.origin !== input.schema.compiled.root.origin ||
+        revision(decoded.root) !== input.schema.compiled.root.revision) {
+        invalid();
+    }
+    const registry = bindRuntime(domain, runtime, input.callables);
+    const requirements = admitRequirements(input.requirements);
+    validateRequirements(decoded.root, decoded.closure, requirements);
+    const plan = admitRoutePlan(input.routes, domain);
+    const compiled = deepFreeze(input.schema.compiled);
+    const bundleRef = deepFreeze(input.schema.bundle.ref);
+    const frontend = input.frontend === undefined ? undefined : deepFreeze(input.frontend);
+    const detached = new Uint8Array(bytes);
+    const build = Object.freeze({
+        kind: 'build',
+        schema: Object.freeze({
+            compiled,
+            bundle: Object.freeze({
+                ref: bundleRef,
+                bytes: () => new Uint8Array(detached),
+            }),
+        }),
+        runtime,
+        callables: Object.freeze([...input.callables]),
+        requirements,
+        routes: plan,
+        ...(frontend === undefined ? {} : { frontend }),
+    });
+    return admitBuild(build, { domain, registry });
+}
+/**
+ * Bind material embedded by generated release code without repeating its external admission.
+ * Build generators must call {@link generatedMaterial} before embedding the exact envelope;
+ * decoded files, network values, and caller-provided JSON must continue through
+ * {@link restoreBuild}.
+ */
+export function restoreGeneratedBuild(input, runtime) {
+    const generated = acceptGeneratedMaterial(input, runtime);
+    const material = generated.material;
+    const domain = loadGeneratedSchema(material.schema.compiled);
+    const registry = bindRuntime(domain, runtime, material.callables);
+    const detached = Uint8Array.from(material.schema.bundle.bytes);
+    const build = Object.freeze({
+        kind: 'build',
+        schema: Object.freeze({
+            compiled: material.schema.compiled,
+            bundle: Object.freeze({
+                ref: material.schema.bundle.ref,
+                bytes: () => new Uint8Array(detached),
+            }),
+        }),
+        runtime,
+        callables: Object.freeze([...material.callables]),
+        requirements: material.requirements,
+        routes: material.routes,
+        ...(material.frontend === undefined ? {} : { frontend: material.frontend }),
+    });
+    return admitBuild(build, { domain, registry });
+}
+function acceptGeneratedMaterial(input, runtime) {
+    const format = input?.format;
+    const version = input?.version;
+    const material = input?.material;
+    const digest = input?.digest;
+    if (input === null ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        format !== 'astrale.sdk.generated-build-material' ||
+        version !== 1 ||
+        Reflect.ownKeys(input).some((key) => key !== 'format' && key !== 'version' && key !== 'material' && key !== 'digest') ||
+        digestOf(material) !== digest) {
+        invalid();
+    }
+    assertMaterialEnvelope(material, runtime);
+    const accepted = deepFreeze({ material });
+    deepFreeze(input);
+    return accepted;
+}
+function digestOf(input) {
+    try {
+        return artifact.identify(new TextEncoder().encode(JSON.stringify(input)), 'application/vnd.astrale.sdk.build-material+json').digest;
+    }
+    catch {
+        invalid();
+    }
+}
+function assertMaterialEnvelope(input, runtime) {
+    if (!isRuntime(runtime))
+        throw new TypeError('Build 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();
+    }
+}
+function bindRuntime(domain, runtime, expected) {
+    const registry = admitRuntimeRegistry(domain, runtime);
+    const callables = registry.implementations.map(({ callable }) => callable.key).sort();
+    if (callables.length !== expected.length ||
+        callables.some((key, index) => key !== expected[index])) {
+        throw new TypeError('Generated Runtime differs from Build material.');
+    }
+    return registry;
+}
+function admitRoutePlan(input, domain) {
+    if (input.origin !== domain.origin ||
+        input.revision !== domain.revision ||
+        !Array.isArray(input.entries)) {
+        invalid();
+    }
+    const declarations = input.entries.map((entry) => {
+        if (entry === null || typeof entry !== 'object' || Array.isArray(entry))
+            invalid();
+        const { target, auth: _auth, output: _output, default: isDefault, ...declaration } = entry;
+        return {
+            ...declaration,
+            ...(isDefault ? { default: true } : {}),
+            ...(target?.kind === 'method' && target.dispatch === 'instance'
+                ? { receiver: target.receiver }
+                : {}),
+        };
+    });
+    const admitted = routes.compile({ domain, routes: declarations });
+    if (!equal(admitted, input))
+        invalid();
+    return admitted;
+}
+function deepFreeze(input, seen = new WeakSet()) {
+    if (input !== null && typeof input === 'object' && !seen.has(input)) {
+        seen.add(input);
+        for (const value of Object.values(input))
+            deepFreeze(value, seen);
+        if (!Object.isFrozen(input))
+            Object.freeze(input);
+    }
+    return input;
+}
+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,20 @@
+import type { ApplicationIdentity } from '../application/index.js';
+import type { Adapter } from './adapter/index.js';
+import type { RuntimeReference } from './runtime/index.js';
+type CanonicalAdapter<Value> = Value extends Adapter<infer _Parameters> ? Value : never;
+/** @deprecated Declare Application and Environments directly in defineProject(). */
+export interface DeploymentInput<ApplicationValue extends ApplicationIdentity, AdapterValue extends object> {
+    readonly application: ApplicationValue;
+    readonly entrypoint: RuntimeReference;
+    readonly adapter: CanonicalAdapter<AdapterValue>;
+}
+/** @deprecated Legacy aggregate retained only so tooling can issue an exact migration diagnostic. */
+export interface LegacyDeployment<ApplicationValue extends ApplicationIdentity = ApplicationIdentity, AdapterValue extends object = object> {
+    readonly application: ApplicationValue;
+    readonly entrypoint: RuntimeReference;
+    readonly adapter: AdapterValue;
+}
+/** @deprecated Declare Application and Environments directly in defineProject(). */
+export declare function deploy<const ApplicationValue extends ApplicationIdentity, const AdapterValue extends object>(input: DeploymentInput<ApplicationValue, AdapterValue>): LegacyDeployment<ApplicationValue, AdapterValue>;
+export declare function isLegacyDeployment(input: unknown): input is LegacyDeployment;
+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 legacyDeployments = new WeakSet();
+/** @deprecated Declare Application and Environments directly in defineProject(). */
+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 });
+    legacyDeployments.add(deployment);
+    return deployment;
+}
+export function isLegacyDeployment(input) {
+    return input !== null && typeof input === 'object' && legacyDeployments.has(input);
+}
+function invalid() {
+    throw new TypeError('Deployment must contain exactly application, entrypoint, and adapter.');
+}

package/dist/deployment/deployment.d.ts

@@ -0,0 +1,9 @@
+import type { Adapter } from './adapter/index.js';
+export interface Deployment<Parameters extends object = object> {
+    readonly kind: 'deployment';
+    readonly adapter: Adapter<Parameters>;
+    readonly parameters: Parameters;
+}
+/** Internal adapter binding boundary used by public provider packages. */
+export declare function captureDeployment<const Parameters extends object>(adapter: Adapter<Parameters>, parameters: Parameters): Deployment<Parameters>;
+export declare function isDeployment(input: unknown): input is Deployment;

package/dist/deployment/deployment.js

@@ -0,0 +1,10 @@
+const deployments = new WeakSet();
+/** Internal adapter binding boundary used by public provider packages. */
+export function captureDeployment(adapter, parameters) {
+    const value = Object.freeze({ kind: 'deployment', adapter, parameters });
+    deployments.add(value);
+    return value;
+}
+export function isDeployment(input) {
+    return input !== null && typeof input === 'object' && deployments.has(input);
+}

package/dist/deployment/index.d.ts

@@ -1,7 +1,14 @@
-export { bindCallables, createDeployment } from './artifact/index.js';
-export type { CreateDeploymentInput, Deployment, DeploymentRouteTable, DeploymentValidator, HttpRouteDeclaration, } from './artifact/index.js';
-export { deployCheck, fetchPublication } from './check/index.js';
-export type { DeployCheckOptions, DeployFetch, PublicationCheckOptions } 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, defineDeployment, isAdapter } from './adapter/index.js';
+export type { Adapter, AdapterEnvironmentContext, AdapterInput, AddressingPlan, ArtifactFile, ArtifactSource, DeployContext, DeploymentPhase, DeploymentProgress, DeployResult, FailedDeployResult, MutationKnowledge, PreparedArtifact, PreparedArtifactFile, PrepareContext, ReadyDeployResult, InstallationTarget, } from './adapter/index.js';
+export { compile, isBuild } from './build/index.js';
+export type { Build, BuildBundle, BuildSchema } from './build/index.js';
+export { deploy } from './deploy.js';
+export type { DeploymentInput, LegacyDeployment } from './deploy.js';
+export { isDeployment } from './deployment.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,7 @@
-export { bindCallables, createDeployment } from './artifact/index.js';
-export { deployCheck, fetchPublication } from './check/index.js';
-export { defineAdapter, deploy } from './provider/index.js';
-//# sourceMappingURL=index.js.map
+export { defineAdapter, defineDeployment, isAdapter } from './adapter/index.js';
+export { compile, isBuild } from './build/index.js';
+export { deploy } from './deploy.js';
+export { isDeployment } from './deployment.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 } 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 } from './invocation.js';

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

@@ -0,0 +1,2 @@
+/** Stable callable endpoint independent of Schema and provider deployment versions. */
+export declare function invocationPath(): string;

package/dist/deployment/release/invocation.js

@@ -0,0 +1,5 @@
+const INVOCATION_PATH = '/invoke';
+/** Stable callable endpoint independent of Schema and provider deployment versions. */
+export function invocationPath() {
+    return INVOCATION_PATH;
+}

package/dist/deployment/release/publication/callables.d.ts

@@ -0,0 +1,4 @@
+import * as publication from '@astrale-os/kernel-protocol/publication';
+import type { Build } from '../../build/index.js';
+import type { Addressing } from '../addressing.js';
+export declare function callables(build: Build, addressing: Addressing): readonly publication.CallableBinding[];