@astrale-os/sdk 0.5.0-beta.23 → 0.5.0-beta.25

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/application/integration/client.d.ts

@@ -1,3 +1,4 @@
+import type { BoundClientSession } from '../../platform/client/session/index.js';
 import type { IntegrationClients, Integrations } from './integration.js';
 import type { IntegrationReplayDecision } from './operation.js';
 import type { Providers } from './provider.js';
@@ -5,6 +6,7 @@ export interface IntegrationCallCoordinates {
     readonly callId: string;
     readonly signal: AbortSignal;
     readonly deadline: number;
+    readonly invoke?: BoundClientSession['invoke'];
 }
 export interface IntegrationAttempt<Output> {
     readonly integration: string;

package/dist/application/integration/client.js

@@ -78,19 +78,21 @@ function admitCoordinates(input) {
     if (input === null || typeof input !== 'object' || Array.isArray(input))
         invalidCoordinates();
     const keys = Reflect.ownKeys(input);
-    if (keys.length !== 3 ||
-        !keys.every((key) => key === 'callId' || key === 'signal' || key === 'deadline') ||
+    if ((keys.length !== 3 && keys.length !== 4) ||
+        !keys.every((key) => key === 'callId' || key === 'signal' || key === 'deadline' || key === 'invoke') ||
         typeof input.callId !== 'string' ||
         input.callId.length === 0 ||
         input.callId.trim() !== input.callId ||
         !(input.signal instanceof AbortSignal) ||
-        !Number.isFinite(input.deadline)) {
+        !Number.isFinite(input.deadline) ||
+        (input.invoke !== undefined && typeof input.invoke !== 'function')) {
         invalidCoordinates();
     }
     return Object.freeze({
         callId: input.callId,
         signal: input.signal,
         deadline: input.deadline,
+        ...(input.invoke === undefined ? {} : { invoke: input.invoke }),
     });
 }
 function invalidCoordinates() {

package/dist/application/integration/operation.d.ts

@@ -1,3 +1,4 @@
+import type { BoundClientSession } from '../../platform/client/session/index.js';
 declare const INTEGRATION_OPERATION: unique symbol;
 export type IntegrationReplayDecision = {
     readonly kind: 'safe';
@@ -17,6 +18,8 @@ export interface IntegrationExecution {
     readonly signal: AbortSignal;
     readonly deadline: number;
     readonly idempotencyKey?: string;
+    /** Exact caller-bound invocation capability; absent for an anonymous invocation. */
+    readonly invoke?: BoundClientSession['invoke'];
 }
 export interface IntegrationOperation<Input = unknown, Output = unknown> {
     readonly replay: IntegrationReplay<Input>;

package/dist/application/mutation/execution/execute.d.ts

@@ -1,6 +1,8 @@
-import { MutationAST, type MutationResult } from '@astrale-os/kernel-core/graph/mutate';
+import type { GraphApi } from '../../../platform/client/index.js';
+import type { Domain } from '../../../platform/schema/index.js';
 import type { Mutation } from '../mutation.js';
-export interface MutationClient {
-    mutate(ast: ReturnType<typeof MutationAST.build>): Promise<MutationResult>;
-}
+/** Canonical caller-scoped graph capability required by Mutation execution. */
+export type MutationClient = Pick<GraphApi, 'mutate'>;
 export declare function executeMutation<Input, Output>(client: MutationClient, definition: Mutation<Input, Output>, input: Input): Promise<Output>;
+/** Private Runtime binding; public callers use executeMutation with an explicit Client. */
+export declare function executeMutationWithExpected<Input, Output>(client: MutationClient, definition: Mutation<Input, Output>, input: Input, expected?: Domain['closure']): Promise<Output>;

package/dist/application/mutation/execution/execute.js

@@ -3,12 +3,17 @@ import { richMutationBuilder } from '../authoring/index.js';
 import { mutationFailure } from '../failure.js';
 import { projectMutation } from './projection.js';
 export async function executeMutation(client, definition, input) {
+    return executeMutationWithExpected(client, definition, input);
+}
+/** Private Runtime binding; public callers use executeMutation with an explicit Client. */
+export async function executeMutationWithExpected(client, definition, input, expected) {
     if (client === null || typeof client !== 'object' || typeof client.mutate !== 'function') {
         throw new TypeError('Mutation execution requires a Client mutate capability.');
     }
     try {
         const ast = MutationAST.build((builder) => definition.change(richMutationBuilder(builder), input));
-        return projectMutation(definition, await client.mutate(ast), input);
+        const result = await client.mutate(ast, expected === undefined ? undefined : { expected });
+        return projectMutation(definition, result, input);
     }
     catch (cause) {
         const expected = mutationFailure(cause);

package/dist/application/mutation/execution/executor.d.ts

@@ -1,3 +1,4 @@
+import type { Domain } from '../../../platform/schema/index.js';
 import type { Mutation } from '../mutation.js';
 import type { MutationClient } from './execute.js';
 /** Invocation-bound executor for authored Mutation definitions. */
@@ -5,4 +6,4 @@ export interface MutationExecutor {
     <Input, Output>(definition: Mutation<Input, Output>, input: Input): Promise<Output>;
 }
 /** Private Runtime binding; public consumers use executeMutation(client, definition, input). */
-export declare function bindMutation(client: MutationClient): MutationExecutor;
+export declare function bindMutation(client: MutationClient, expected: Domain['closure']): MutationExecutor;

package/dist/application/mutation/execution/executor.js

@@ -1,5 +1,5 @@
-import { executeMutation } from './execute.js';
+import { executeMutationWithExpected } from './execute.js';
 /** Private Runtime binding; public consumers use executeMutation(client, definition, input). */
-export function bindMutation(client) {
-    return (definition, input) => executeMutation(client, definition, input);
+export function bindMutation(client, expected) {
+    return (definition, input) => executeMutationWithExpected(client, definition, input, expected);
 }

package/dist/application/query/execution/execute.d.ts

@@ -1,11 +1,7 @@
-import type { QueryPageRequest, QueryResponse } from '@astrale-os/kernel-client/graph';
-import type { QueryAST, QueryResultFor } from '@astrale-os/kernel-core/graph/query';
+import type { GraphApi } from '../../../platform/client/index.js';
 import type { CompositeQuery } from '../composite/index.js';
 import type { QueryDefinition } from '../query.js';
-export interface QueryClient {
-    query<Ast extends QueryAST>(ast: Ast, options: {
-        readonly page: QueryPageRequest;
-    }): Promise<QueryResponse<QueryResultFor<Ast>>>;
-}
+/** Canonical caller-scoped graph capability required by Query execution. */
+export type QueryClient = Pick<GraphApi, 'query'>;
 export declare function executeQuery<Input, Output>(client: QueryClient, definition: QueryDefinition<Input, Output>, input: Input): Promise<Output>;
 export type ExecutableCompositeQuery = CompositeQuery<unknown, unknown, unknown>;

package/dist/application/query/execution/executor.d.ts

@@ -1,3 +1,4 @@
+import type { Domain } from '../../../platform/schema/index.js';
 import type { QueryDefinition } from '../query.js';
 import type { QueryClient } from './execute.js';
 /** Invocation-bound executor for authored Query definitions. */
@@ -5,4 +6,4 @@ export interface QueryExecutor {
     <Input, Output>(definition: QueryDefinition<Input, Output>, input: Input): Promise<Output>;
 }
 /** Private Runtime binding; public consumers use executeQuery(client, definition, input). */
-export declare function bindQuery(client: QueryClient): QueryExecutor;
+export declare function bindQuery(client: QueryClient, expected: Domain['closure']): QueryExecutor;

package/dist/application/query/execution/executor.js

@@ -1,5 +1,10 @@
 import { executeQuery } from './execute.js';
 /** Private Runtime binding; public consumers use executeQuery(client, definition, input). */
-export function bindQuery(client) {
-    return (definition, input) => executeQuery(client, definition, input);
+export function bindQuery(client, expected) {
+    const bound = Object.freeze({
+        query(ast, options) {
+            return client.query(ast, { ...options, expected });
+        },
+    });
+    return (definition, input) => executeQuery(bound, definition, input);
 }

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

@@ -1,5 +1,5 @@
 export { defineRuntime } from './define.js';
 export type { RuntimeInput } from './define.js';
-export type { RuntimeInitialization, RuntimeInitializer } from './initialize.js';
+export type { RuntimeInitialization, RuntimeInitializationContext, RuntimeInitializer, } from './initialize.js';
 export type { RuntimeIntegrations } from './integrations.js';
 export type { Runtime } from './runtime.js';

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

@@ -2,26 +2,27 @@ import type { schema } from '../../platform/schema/index.js';
 import type { ActionDefinition } from '../action/index.js';
 import type { Providers } from '../integration/index.js';
 import type { WorkflowDefinition } from '../workflow/index.js';
-import type { RuntimeInitializer } from './initialize.js';
+import type { RuntimeInitialization, RuntimeInitializer } from './initialize.js';
 import type { RuntimeIntegrations } from './integrations.js';
 import type { Runtime } from './runtime.js';
-type AnyRuntimeInitializer = RuntimeInitializer<never>;
+type RuntimeInitializerValue = (...input: never[]) => RuntimeInitialization | Promise<RuntimeInitialization>;
+type AnyRuntimeInitializer<Schema extends schema.DomainSchema> = RuntimeInitializer<never, RuntimeInitialization, Schema>;
 type Same<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false;
 type ActionSchema<Value> = Value extends ActionDefinition<infer Schema, infer _Address, infer _Services> ? Schema : never;
 type WorkflowSchema<Value> = Value extends WorkflowDefinition<infer Schema, infer _Address, infer _Services> ? Schema : never;
 type RecipeIntegrations<Value> = Value extends ActionDefinition<infer _Schema, infer _Address, infer Definitions> ? Definitions : Value extends WorkflowDefinition<infer _Schema, infer _Address, infer Definitions> ? Definitions : never;
 type AdmitsRecipeSchema<Schema extends schema.DomainSchema, Actions extends readonly unknown[], Workflows extends readonly unknown[]> = [Actions[number] | Workflows[number]] extends [never] ? unknown : Same<ActionSchema<Actions[number]> | WorkflowSchema<Workflows[number]>, Schema> extends true ? unknown : never;
-type InitializationOf<Initialize extends AnyRuntimeInitializer> = Awaited<ReturnType<Initialize>>;
+type InitializationOf<Initialize extends RuntimeInitializerValue> = Awaited<ReturnType<Initialize>>;
 type AdmitsRecipeIntegrations<Definitions extends RuntimeIntegrations, Recipe> = RecipeIntegrations<Recipe> extends infer Required extends RuntimeIntegrations ? Exclude<keyof Required, keyof Definitions> extends never ? Required extends Pick<Definitions, Extract<keyof Required, keyof Definitions>> ? true : false : false : false;
 type AdmitsIntegrations<Definitions extends RuntimeIntegrations, Actions extends readonly unknown[], Workflows extends readonly unknown[]> = [Actions[number] | Workflows[number]] extends [never] ? unknown : false extends AdmitsRecipeIntegrations<Definitions, Actions[number] | Workflows[number]> ? never : unknown;
-type AdmitsProviders<Integrations extends RuntimeIntegrations, Initialize extends AnyRuntimeInitializer> = Same<InitializationOf<Initialize>['providers'], Providers<Integrations>> extends true ? unknown : never;
-export interface RuntimeInput<Integrations extends RuntimeIntegrations, Initialize extends AnyRuntimeInitializer, Actions extends readonly unknown[], Workflows extends readonly unknown[]> {
+type AdmitsProviders<Integrations extends RuntimeIntegrations, Initialize extends RuntimeInitializerValue> = Same<InitializationOf<Initialize>['providers'], Providers<Integrations>> extends true ? unknown : never;
+export interface RuntimeInput<Integrations extends RuntimeIntegrations, Initialize extends RuntimeInitializerValue, Actions extends readonly unknown[], Workflows extends readonly unknown[]> {
     readonly integrations: Integrations;
     readonly initialize: Initialize;
     readonly actions: Actions;
     readonly workflows: Workflows;
 }
 /** Define one inert Runtime declaration; realization requires an exact loaded DSL Domain. */
-export declare function defineRuntime<Schema extends schema.DomainSchema>(): <const Integrations extends RuntimeIntegrations, Initialize extends AnyRuntimeInitializer, const Actions extends readonly unknown[], const Workflows extends readonly unknown[]>(input: RuntimeInput<Integrations, Initialize, Actions, Workflows> & AdmitsRecipeSchema<Schema, Actions, Workflows> & AdmitsIntegrations<Integrations, Actions, Workflows> & AdmitsProviders<Integrations, Initialize>) => Runtime<Schema, Integrations, Initialize, Actions, Workflows>;
+export declare function defineRuntime<Schema extends schema.DomainSchema>(): <const Integrations extends RuntimeIntegrations, Initialize extends AnyRuntimeInitializer<Schema>, const Actions extends readonly unknown[], const Workflows extends readonly unknown[]>(input: RuntimeInput<Integrations, Initialize, Actions, Workflows> & AdmitsRecipeSchema<Schema, Actions, Workflows> & AdmitsIntegrations<Integrations, Actions, Workflows> & AdmitsProviders<Integrations, Initialize>) => Runtime<Schema, Integrations, Initialize, Actions, Workflows>;
 export declare function isRuntime(input: unknown): input is Runtime;
 export {};

package/dist/application/runtime/initialize.d.ts

@@ -1,5 +1,10 @@
+import type { schema } from '../../platform/schema/index.js';
 /** Exact values created once from one adapter environment for a realized Runtime. */
 export interface RuntimeInitialization<ProviderValues = unknown> {
     readonly providers: ProviderValues;
 }
-export type RuntimeInitializer<Environment = unknown, Initialization extends RuntimeInitialization = RuntimeInitialization> = (environment: Environment) => Initialization | Promise<Initialization>;
+/** Exact loaded Domain available while Providers are constructed once. */
+export interface RuntimeInitializationContext<Schema extends schema.DomainSchema> {
+    readonly domain: schema.DomainOf<Schema>;
+}
+export type RuntimeInitializer<Environment = unknown, Initialization extends RuntimeInitialization = RuntimeInitialization, Schema extends schema.DomainSchema = schema.DomainSchema> = (environment: Environment, context: RuntimeInitializationContext<Schema>) => Initialization | Promise<Initialization>;

package/dist/application/runtime/runtime.d.ts

@@ -1,12 +1,12 @@
 import type { Domain, schema } from '../../platform/schema/index.js';
 import type { RuntimeAction } from './actions.js';
-import type { RuntimeInitializer } from './initialize.js';
+import type { RuntimeInitialization, RuntimeInitializer } from './initialize.js';
 import type { RuntimeIntegrations } from './integrations.js';
 import type { RuntimeWorkflow } from './workflows.js';
 export type RuntimeImplementation = RuntimeAction | RuntimeWorkflow;
 declare const RUNTIME_SCHEMA: unique symbol;
 /** Inert authored Runtime declaration; exact Domain association occurs during realization. */
-export interface Runtime<Schema extends schema.DomainSchema = schema.DomainSchema, Integrations extends RuntimeIntegrations = RuntimeIntegrations, Initialize extends RuntimeInitializer<never> = RuntimeInitializer<never>, Actions extends readonly unknown[] = readonly unknown[], Workflows extends readonly unknown[] = readonly unknown[]> {
+export interface Runtime<Schema extends schema.DomainSchema = schema.DomainSchema, Integrations extends RuntimeIntegrations = RuntimeIntegrations, Initialize extends RuntimeInitializer<never, RuntimeInitialization, Schema> = RuntimeInitializer<never, RuntimeInitialization, Schema>, Actions extends readonly unknown[] = readonly unknown[], Workflows extends readonly unknown[] = readonly unknown[]> {
     readonly kind: 'runtime';
     readonly integrations: Integrations;
     readonly initialize: Initialize;

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 ?? []) {
@@ -74,7 +74,8 @@ function requireDirectDependency(domain, key, label) {
     catch {
         throw new TypeError(`${label} requirement is invalid.`);
     }
-    if (origin === domain.origin || !domain.dependencies.some((entry) => entry.origin === origin)) {
+    if (origin === domain.origin ||
+        !Object.values(domain.dependencies).some((dependency) => dependency.origin === origin)) {
         throw new TypeError(`${label} requirement must target an exact direct dependency.`);
     }
 }

package/dist/deployment/build/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/invocation/dispatch/context.js

@@ -21,10 +21,10 @@ export function context(request, runtime, authentication, self) {
         ...(client === null
             ? {}
             : {
-                query: bindQuery(client),
-                mutate: bindMutation(client),
+                query: bindQuery(client, runtime.loaded.domain.closure),
+                mutate: bindMutation(client, runtime.loaded.domain.closure),
             }),
-        integrations: clients(runtime, request.context),
+        integrations: clients(runtime, request.context, client),
         execution,
         ...(self === undefined ? {} : { self }),
     });

package/dist/execution/invocation/integration/call.d.ts

@@ -1,4 +1,5 @@
 import type { InvocationContext } from '@astrale-os/kernel-server';
 import type { IntegrationInvocationOwner } from '../../../application/integration/index.js';
+import type { BoundClientSession } from '../../../platform/client/session/index.js';
 /** One invocation-owned logical Integration call sequence. */
-export declare function calls(context: InvocationContext): IntegrationInvocationOwner;
+export declare function calls(context: InvocationContext, client?: BoundClientSession | null): IntegrationInvocationOwner;

package/dist/execution/invocation/integration/call.js

@@ -1,7 +1,8 @@
 import { active } from '../lifecycle/index.js';
 /** One invocation-owned logical Integration call sequence. */
-export function calls(context) {
+export function calls(context, client = null) {
     const prefix = context.idempotencyKey ?? context.invocation;
+    const invoke = client?.invoke.bind(client);
     let sequence = 0;
     return Object.freeze({
         invoke(call) {
@@ -11,6 +12,7 @@ export function calls(context) {
                 callId: `${prefix}:${sequence}`,
                 signal: context.execution.signal,
                 deadline: context.execution.deadline,
+                ...(invoke === undefined ? {} : { invoke }),
             });
         },
     });

package/dist/execution/invocation/integration/clients.d.ts

@@ -1,4 +1,5 @@
 import type { InvocationContext } from '@astrale-os/kernel-server';
 import type { IntegrationClients, Integrations } from '../../../application/integration/index.js';
+import type { BoundClientSession } from '../../../platform/client/session/index.js';
 import type { InitializedRuntime } from '../../runtime/index.js';
-export declare function clients(runtime: InitializedRuntime, context: InvocationContext): IntegrationClients<Integrations>;
+export declare function clients(runtime: InitializedRuntime, context: InvocationContext, client: BoundClientSession | null): IntegrationClients<Integrations>;

package/dist/execution/invocation/integration/clients.js

@@ -1,4 +1,4 @@
 import { calls } from './call.js';
-export function clients(runtime, context) {
-    return runtime.clients(calls(context));
+export function clients(runtime, context, client) {
+    return runtime.clients(calls(context, client));
 }

package/dist/execution/runtime/initialize.js

@@ -7,7 +7,7 @@ export async function initialize(loaded, environment) {
         throw new TypeError('Runtime initialization requires an admitted loaded Runtime.');
     }
     const runtime = loaded.release.build.runtime;
-    const initialization = providers(await runtime.initialize(environment));
+    const initialization = providers(await runtime.initialize(environment, Object.freeze({ domain: loaded.domain })));
     const clients = integrations(runtime.integrations, initialization.providers);
     return Object.freeze({ loaded, initialization, clients });
 }

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/dist/tooling/cli/arguments.d.ts

@@ -1,20 +1,12 @@
 import type { LintReportFormat } from '../linter/index.js';
 export interface ParsedArgs {
-    readonly command: 'dev' | 'build' | 'deploy' | 'publish' | 'lint' | 'package';
+    readonly command: 'dev' | 'build' | 'deploy' | 'lint' | 'package';
     readonly env: string;
     readonly watch: boolean;
     readonly fix?: boolean;
     readonly format?: LintReportFormat;
-    readonly dryRun?: boolean;
-    readonly schemaOnly?: boolean;
-    readonly otp?: string;
-    readonly skipSchema?: boolean;
     readonly port?: number;
     readonly host?: string;
-    readonly publish?: boolean;
-    readonly name?: string;
-    readonly installByDefault?: boolean;
-    readonly publicUrl?: string;
 }
 /** Parse the frozen `astrale-domain` command grammar without performing effects. */
 export declare function parseArgs(argv: readonly string[]): ParsedArgs;