@astrale-os/sdk 0.5.0-beta.22 → 0.5.0-beta.24

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

@@ -54,7 +54,7 @@ type SelfOf<Callable> = Callable extends ResolvedMethod<unknown, unknown, false>
 };
 /** Exact single-step Action context derived from one resolved callable. */
 export type ActionContext<Callable extends ResolvedCallable, DomainValue extends Domain = Domain, Definitions extends Integrations = Readonly<Record<never, never>>> = {
-    /** Exact loaded Domain for the Build being executed. */
+    /** Exact admitted Domain retained by the Build being executed. */
     readonly domain: DomainValue;
     readonly input: CallableInputOf<Callable>;
     readonly integrations: IntegrationClients<Definitions>;

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

@@ -1,4 +1,12 @@
+import type { RuntimeRegistry } from '../../application/runtime/index.js';
+import type { Domain } from '../../platform/schema/index.js';
 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;
+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

@@ -1,9 +1,15 @@
-const admittedBuilds = new WeakSet();
-/** Retain package ownership of one compiled or restored Build value. */
-export function admitBuild(build) {
-    admittedBuilds.add(build);
+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/compile.js

@@ -38,7 +38,7 @@ export function compile(application) {
         routes: plan,
         ...(frontend === undefined ? {} : { frontend }),
     });
-    return admitBuild(build);
+    return admitBuild(build, { domain, registry });
 }
 function compileRequirements(domain, input, sourceBundle) {
     for (const key of input?.callables ?? []) {

package/dist/deployment/build/material.js

@@ -1,9 +1,11 @@
 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 { 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. */
@@ -50,6 +52,7 @@ export function restoreBuild(input, runtime) {
     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();
@@ -62,32 +65,60 @@ export function restoreBuild(input, runtime) {
     }
     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 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: input.schema.compiled,
+            compiled,
             bundle: Object.freeze({
-                ref: input.schema.bundle.ref,
+                ref: bundleRef,
                 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 }),
+        routes: plan,
+        ...(frontend === undefined ? {} : { frontend }),
+    });
+    return admitBuild(build, { domain, 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 }
+                : {}),
+        };
     });
-    return admitBuild(build);
+    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/release/publication/seal.js

@@ -1,6 +1,6 @@
-import { load as loadCompiledSchema } from '@astrale-os/kernel-dsl/v1/compiled/loader';
 import * as publication from '@astrale-os/kernel-protocol/publication';
 import * as protocolRoutes from '@astrale-os/kernel-protocol/routes';
+import { evidenceOf } from '../../build/admission.js';
 import { callables } from './callables.js';
 import { manifest } from './manifest.js';
 import { requirements } from './requirements.js';
@@ -32,7 +32,7 @@ export function seal(build, addressing) {
         delivery: publication.placeDelivery({ path: DELIVERY_PATH, authentication: { kind: 'public' } }, addressing.issuer, new URL(BUNDLE_PATH, addressing.issuer).href),
         routes: routes(build, addressing),
     });
-    const domain = loadCompiledSchema(build.schema.compiled);
+    const { domain } = evidenceOf(build);
     return Object.freeze({
         publication: sealed,
         routes: protocolRoutes.bind(build.routes, sealed, domain),

package/dist/deployment/verify/preflight/publication.js

@@ -1,5 +1,5 @@
-import { load as loadCompiledSchema } from '@astrale-os/kernel-dsl/v1/compiled/loader';
 import { publication as protocolPublication, routes } from '@astrale-os/kernel-protocol';
+import { evidenceOf } from '../../build/admission.js';
 import { assemble } from '../../release/index.js';
 /** Verify locally assemblable Publication evidence before any provider mutation. */
 export function publication(artifact) {
@@ -8,7 +8,7 @@ export function publication(artifact) {
     const release = assemble(artifact.build, artifact.addressing.addressing);
     const admitted = protocolPublication.accept(release.publication);
     protocolPublication.verifyBundleBytes(admitted, artifact.build.schema.bundle.bytes());
-    const domain = loadCompiledSchema(artifact.build.schema.compiled);
+    const { domain } = evidenceOf(artifact.build);
     routes.verifyTable(release.routes, admitted, domain);
     return release;
 }

package/dist/execution/runtime/load.d.ts

@@ -7,5 +7,5 @@ export interface LoadedRuntime<BuildValue extends Build = Build> {
     readonly domain: Domain;
     readonly registry: RuntimeRegistry;
 }
-/** Load the compiled Domain and re-admit its exact Runtime registry at execution startup. */
+/** Load one execution Runtime from the exact evidence retained by its admitted Build. */
 export declare function load<const BuildValue extends Build>(release: Release<BuildValue>): LoadedRuntime<BuildValue>;

package/dist/execution/runtime/load.js

@@ -1,17 +1,10 @@
-import { load as loadCompiledSchema } from '@astrale-os/kernel-dsl/v1/compiled/loader';
-import { admitRuntimeRegistry } from '../../application/runtime/index.js';
+import { evidenceOf } from '../../deployment/build/admission.js';
 import { isRelease } from '../../deployment/release/admission.js';
 import { capture } from './admission.js';
-/** Load the compiled Domain and re-admit its exact Runtime registry at execution startup. */
+/** Load one execution Runtime from the exact evidence retained by its admitted Build. */
 export function load(release) {
     if (!isRelease(release))
         throw new TypeError('Runtime loading requires an admitted Release.');
-    const domain = loadCompiledSchema(release.build.schema.compiled);
-    const registry = admitRuntimeRegistry(domain, release.build.runtime);
-    const actual = registry.implementations.map(({ callable }) => callable.key).sort();
-    if (actual.length !== release.build.callables.length ||
-        actual.some((key, index) => key !== release.build.callables[index])) {
-        throw new TypeError('Runtime registry differs from its compiled Build callable set.');
-    }
+    const { domain, registry } = evidenceOf(release.build);
     return capture(Object.freeze({ release, domain, registry }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/sdk",
-  "version": "0.5.0-beta.22",
+  "version": "0.5.0-beta.24",
   "description": "Schema-first SDK for defining, composing, and deploying Astrale domains",
   "keywords": [
     "astrale",