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

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/compile.js

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

package/dist/tooling/cli/arguments.js

@@ -3,16 +3,8 @@ export function parseArgs(argv) {
     const [command, ...rest] = argv;
     const watch = rest.includes('--watch');
     const fix = rest.includes('--fix');
-    const publish = rest.includes('--publish');
-    const installByDefault = rest.includes('--install-by-default');
-    const dryRun = rest.includes('--dry-run');
-    const schemaOnly = rest.includes('--schema');
-    const skipSchema = rest.includes('--skip-schema');
     let port;
     let host;
-    let name;
-    let publicUrl;
-    let otp;
     let format;
     let environment;
     const cleaned = [];
@@ -37,24 +29,6 @@ export function parseArgs(argv) {
         else if (argument.startsWith('--host=')) {
             host = normalizeHost(argument.slice('--host='.length));
         }
-        else if (argument === '--name') {
-            name = requiredValue('--name', rest[++index]);
-        }
-        else if (argument.startsWith('--name=')) {
-            name = requiredValue('--name', argument.slice('--name='.length));
-        }
-        else if (argument === '--public-url') {
-            publicUrl = requiredValue('--public-url', rest[++index]);
-        }
-        else if (argument.startsWith('--public-url=')) {
-            publicUrl = requiredValue('--public-url', argument.slice('--public-url='.length));
-        }
-        else if (argument === '--otp') {
-            otp = requiredValue('--otp', rest[++index]);
-        }
-        else if (argument.startsWith('--otp=')) {
-            otp = requiredValue('--otp', argument.slice('--otp='.length));
-        }
         else if (argument === '--format') {
             format = lintFormat(rest[++index]);
         }
@@ -67,13 +41,7 @@ export function parseArgs(argv) {
         else if (argument.startsWith('--environment=')) {
             environment = requiredValue('--environment', argument.slice('--environment='.length));
         }
-        else if (argument === '--watch' ||
-            argument === '--fix' ||
-            argument === '--publish' ||
-            argument === '--install-by-default' ||
-            argument === '--dry-run' ||
-            argument === '--schema' ||
-            argument === '--skip-schema') {
+        else if (argument === '--watch' || argument === '--fix') {
             continue;
         }
         else if (argument.startsWith('-')) {
@@ -83,53 +51,24 @@ export function parseArgs(argv) {
             cleaned.push(argument);
         }
     }
-    if (dryRun && command !== 'publish') {
-        throw new Error('`--dry-run` is only valid for `publish`.');
-    }
-    if (otp !== undefined && !['publish', 'deploy', 'prod'].includes(command ?? '')) {
-        throw new Error('`--otp` is only valid for the publish / deploy commands.');
-    }
-    if (schemaOnly && command !== 'publish') {
-        throw new Error('`--schema` is only valid for `publish`.');
-    }
-    if (schemaOnly && skipSchema) {
-        throw new Error('`--schema` (schema only) and `--skip-schema` (catalog only) are mutually exclusive.');
-    }
     if (fix && command !== 'lint')
         throw new Error('`--fix` is only valid for `lint`.');
     if (format !== undefined && command !== 'lint') {
         throw new Error('`--format` is only valid for `lint`.');
     }
-    if (watch && !['dev', 'deploy', 'prod'].includes(command ?? '')) {
+    if (watch && !['dev', 'deploy'].includes(command ?? '')) {
         throw new Error('`--watch` is only valid for the dev / deploy commands.');
     }
     if ((port !== undefined || host !== undefined) && command !== 'dev') {
         throw new Error('`--port` and `--host` are only valid for `dev`.');
     }
-    if (publish && !['deploy', 'prod'].includes(command ?? '')) {
-        throw new Error('`--publish` is only valid for the deploy commands.');
-    }
-    if (publicUrl !== undefined && command !== 'publish') {
-        throw new Error('`--public-url` is only valid for `publish`.');
-    }
-    if (environment !== undefined && !['dev', 'deploy', 'publish'].includes(command ?? '')) {
-        throw new Error('`--environment` is only valid for dev, deploy, or publish.');
-    }
-    if ((name !== undefined || installByDefault || skipSchema || otp !== undefined) &&
-        command !== 'publish' &&
-        !(['deploy', 'prod'].includes(command ?? '') && publish)) {
-        throw new Error('Publish options require `publish` or a deploy command with `--publish`.');
+    if (environment !== undefined && !['dev', 'deploy'].includes(command ?? '')) {
+        throw new Error('`--environment` is only valid for dev or deploy.');
     }
     const positionals = cleaned.filter((argument) => !argument.startsWith('-'));
     if (environment !== undefined && positionals.length > 0) {
         throw new Error('Choose either a positional environment or `--environment`, not both.');
     }
-    const publication = {
-        ...(name !== undefined ? { name } : {}),
-        ...(installByDefault ? { installByDefault } : {}),
-        ...(otp !== undefined ? { otp } : {}),
-        ...(skipSchema ? { skipSchema } : {}),
-    };
     switch (command) {
         case 'dev':
             if (positionals.length > 1)
@@ -141,16 +80,6 @@ export function parseArgs(argv) {
                 ...(port !== undefined ? { port } : {}),
                 ...(host !== undefined ? { host } : {}),
             };
-        case 'prod':
-            if (positionals.length > 0)
-                throw new Error('`prod` does not accept an environment.');
-            return {
-                command: 'deploy',
-                env: 'prod',
-                watch,
-                ...(publish ? { publish } : {}),
-                ...publication,
-            };
         case 'deploy': {
             if (positionals.length > 1)
                 throw new Error('`deploy` accepts exactly one environment.');
@@ -161,22 +90,8 @@ export function parseArgs(argv) {
                 command: 'deploy',
                 env,
                 watch,
-                ...(publish ? { publish } : {}),
-                ...publication,
             };
         }
-        case 'publish':
-            if (positionals.length > 1)
-                throw new Error('`publish` accepts at most one environment.');
-            return {
-                command: 'publish',
-                env: environment ?? positionals[0] ?? 'prod',
-                watch: false,
-                ...publication,
-                ...(publicUrl !== undefined ? { publicUrl } : {}),
-                ...(dryRun ? { dryRun } : {}),
-                ...(schemaOnly ? { schemaOnly } : {}),
-            };
         case 'build':
             if (positionals.length > 0)
                 throw new Error('`build` does not accept positional arguments.');

package/dist/tooling/cli/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * `@astrale-os/sdk/cli` — the `astrale-domain` CLI
- * (dev | build | deploy | publish | lint) and its explicit dotenv boundary.
+ * (dev | build | deploy | lint | package) and its explicit dotenv boundary.
  *
  * Node-only: the CLI imports `node:fs`/`node:module`/`node:url` and runs under
  * Bun (it imports the project's `astrale.config.ts` directly). This subpath is

package/dist/tooling/cli/index.js

@@ -1,6 +1,6 @@
 /**
  * `@astrale-os/sdk/cli` — the `astrale-domain` CLI
- * (dev | build | deploy | publish | lint) and its explicit dotenv boundary.
+ * (dev | build | deploy | lint | package) and its explicit dotenv boundary.
  *
  * Node-only: the CLI imports `node:fs`/`node:module`/`node:url` and runs under
  * Bun (it imports the project's `astrale.config.ts` directly). This subpath is

package/dist/tooling/cli/log.d.ts

@@ -1,4 +1,4 @@
-/** CLI output helpers + ANSI colours, shared by run.ts and publish.ts. */
+/** CLI output helpers and ANSI colours for the one project command owner. */
 export declare const GREEN = "\u001B[32m";
 export declare const DIM = "\u001B[2m";
 export declare const BOLD = "\u001B[1m";

package/dist/tooling/cli/log.js

@@ -1,4 +1,4 @@
-/** CLI output helpers + ANSI colours, shared by run.ts and publish.ts. */
+/** CLI output helpers and ANSI colours for the one project command owner. */
 export const GREEN = '\x1b[32m';
 export const DIM = '\x1b[2m';
 export const BOLD = '\x1b[1m';

package/dist/tooling/cli/orchestrate.js

@@ -7,7 +7,6 @@ import { parseArgs } from './arguments.js';
 import { BunRequiredError } from './bun.js';
 import { loadDeclaredSecrets } from './dotenv.js';
 import { error, info } from './log.js';
-import { publishSchema, runRelease, runReleaseAfterDeploy } from './publish.js';
 const CONFIG_NAMES = ['astrale.config.ts', 'astrale.config.js', 'astrale.config.mjs'];
 export async function run(argv) {
     if (argv.includes('--help') || argv.includes('-h')) {
@@ -29,13 +28,6 @@ export async function run(argv) {
         info(`Packaged ${result.declarations} public declarations (${result.replacements} references normalized).`);
         return 0;
     }
-    if (parsed.command === 'publish' && parsed.schemaOnly) {
-        return publishSchema({
-            projectDir: process.cwd(),
-            dryRun: parsed.dryRun ?? false,
-            ...(parsed.otp === undefined ? {} : { otp: parsed.otp }),
-        });
-    }
     if (!process.versions.bun) {
         throw new BunRequiredError();
     }
@@ -46,18 +38,6 @@ export async function run(argv) {
         return 1;
     }
     const deployment = await loadDeployment(configPath);
-    if (parsed.command === 'publish') {
-        return runRelease({
-            projectDir,
-            origin: deployment.application.schema.origin,
-            skipSchema: parsed.skipSchema ?? false,
-            dryRun: parsed.dryRun ?? false,
-            ...(parsed.name === undefined ? {} : { name: parsed.name }),
-            ...(parsed.publicUrl === undefined ? {} : { publicUrl: parsed.publicUrl }),
-            ...(parsed.otp === undefined ? {} : { otp: parsed.otp }),
-            ...(parsed.installByDefault ? { installByDefault: true } : {}),
-        });
-    }
     const adapter = deployment.adapter;
     const build = compile(deployment.application);
     const resolved = await resolveRuntime(deployment.entrypoint, (path) => importModule(resolve(dirname(configPath), path)));
@@ -89,17 +69,7 @@ export async function run(argv) {
         return 1;
     }
     info(`Ready: ${result.release.addressing.issuer}`);
-    if (!parsed.publish)
-        return 0;
-    return runReleaseAfterDeploy({
-        projectDir,
-        origin: result.release.publication.origin,
-        deployedUrl: result.release.addressing.issuer,
-        skipSchema: parsed.skipSchema ?? false,
-        ...(parsed.name === undefined ? {} : { name: parsed.name }),
-        ...(parsed.otp === undefined ? {} : { otp: parsed.otp }),
-        ...(parsed.installByDefault ? { installByDefault: true } : {}),
-    });
+    return 0;
 }
 async function watch(adapter, parameters, artifact, secrets, parsed, projectDir) {
     const handle = await adapter.watch(parameters, {
@@ -202,5 +172,5 @@ function signals() {
 function usage(message) {
     if (message !== undefined)
         error(message);
-    process.stderr.write('Usage: astrale-domain <dev|build|deploy|publish|lint|package> [environment]\n');
+    process.stderr.write('Usage: astrale-domain <dev|build|deploy|lint|package> [environment]\n');
 }

package/dist/tooling/linter/implementations/source/global.js

@@ -571,21 +571,28 @@ export const globalRules = [
                     const dependencies = propertyExpression(object, 'dependencies');
                     if (!dependencies)
                         continue;
-                    if (!ts.isArrayLiteralExpression(dependencies)) {
-                        evidence.push(ambiguity(file, dependencies, 'Schema dependencies are not a static array.'));
+                    if (!ts.isObjectLiteralExpression(dependencies)) {
+                        evidence.push(ambiguity(file, dependencies, 'Schema dependencies are not a static object.'));
                         continue;
                     }
-                    for (const element of dependencies.elements) {
+                    for (const property of dependencies.properties) {
+                        const element = ts.isPropertyAssignment(property)
+                            ? property.initializer
+                            : ts.isShorthandPropertyAssignment(property)
+                                ? property.name
+                                : undefined;
+                        if (element === undefined) {
+                            evidence.push(ambiguity(file, property, 'Schema dependency is not one statically aliased Domain facade.'));
+                            continue;
+                        }
                         const symbol = importedSymbol(file, unwrap(element));
-                        if ((symbol?.module === '@astrale-os/kernel-core/schema' ||
-                            symbol?.module === '@astrale-os/sdk/schema/kernel') &&
-                            symbol.name === 'KernelSchema') {
+                        if (symbol?.module === '@astrale-os/sdk/schema' && symbol.name === 'KernelSchema') {
                             continue;
                         }
                         if (symbol && isForeignDomain(symbol.module))
                             dependencyPackages.add(packageRoot(symbol.module));
                         else
-                            evidence.push(ambiguity(file, element, 'Schema dependency cannot be mapped to one foreign Domain facade.'));
+                            evidence.push(ambiguity(file, property, 'Schema dependency cannot be mapped to one foreign Domain facade.'));
                     }
                 }
             }