@astrale-os/sdk 0.5.0-beta.16 → 0.5.0-beta.18

package/README.md

@@ -23,7 +23,7 @@ npm install @astrale-os/sdk@beta
 npx -y create-astrale-domain@beta my-domain --yes
 ```
 
-See [the release lifecycle](docs/release.md) for package-cohort versioning, verification, and stable
+See [the release lifecycle](docs/release.md) for package-set versioning, verification, and stable
 promotion.
 
 ## Development

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

@@ -1,5 +1,6 @@
 import type { Domain, ResolvedMethod, schema } from '../../platform/schema/index.js';
-import type { ActionContext, ActionServices, ResolvedCallable } from './context.js';
+import type { Integrations } from '../integration/index.js';
+import type { ActionContext, ResolvedCallable } from './context.js';
 import type { ActionOutputOf } from './output.js';
 export type Values<Value> = Value[keyof Value];
 type MethodValues<Class> = Class extends {
@@ -16,25 +17,24 @@ type MethodValues<Class> = Class extends {
 } ? Values<Instance> | Values<Static> : never;
 type Executable<Callable> = Callable extends ResolvedMethod<unknown, unknown, boolean, infer Inheritance> ? Inheritance extends 'abstract' ? never : Callable : Callable;
 /** Every root-owned callable implementation contract, independent of Function or Method topology. */
-export type LocalCallable<Work extends Domain> = Extract<Values<Work['functions']>, ResolvedCallable> | Extract<Executable<MethodValues<Values<Work['classes']>>>, ResolvedCallable>;
+export type LocalCallable<DomainValue extends Domain> = Extract<Values<DomainValue['functions']>, ResolvedCallable> | Extract<Executable<MethodValues<Values<DomainValue['classes']>>>, ResolvedCallable>;
 export type ActionAddressOf<Callable> = Callable extends {
     readonly key: `${string}:function.${infer Name}`;
 } ? Name : Callable extends {
     readonly key: `${string}:class.${infer Owner}.method.${infer Name}`;
 } ? `${Owner}.${Name}` : never;
-export type WorkOf<Schema extends schema.DomainSchema> = Extract<schema.DomainOf<Schema>, Domain>;
+export type ResolvedDomainOf<Schema extends schema.DomainSchema> = Extract<schema.DomainOf<Schema>, Domain>;
 /** SDK Action address derived mechanically from the canonical local callable key. */
-export type ActionAddress<Schema extends schema.DomainSchema> = ActionAddressOf<LocalCallable<WorkOf<Schema>>>;
-export type CallableAtAddress<Schema extends schema.DomainSchema, Address extends string> = LocalCallable<WorkOf<Schema>> extends infer Callable ? Callable extends unknown ? ActionAddressOf<Callable> extends Address ? Callable : never : never : never;
-export type Action<Callable extends ResolvedCallable, Services extends ActionServices = ActionServices, Work extends Domain = Domain> = (context: ActionContext<Callable, Services, Work>) => Promise<ActionOutputOf<Callable>>;
+export type ActionAddress<Schema extends schema.DomainSchema> = ActionAddressOf<LocalCallable<ResolvedDomainOf<Schema>>>;
+export type CallableAtAddress<Schema extends schema.DomainSchema, Address extends string> = LocalCallable<ResolvedDomainOf<Schema>> extends infer Callable ? Callable extends unknown ? ActionAddressOf<Callable> extends Address ? Callable : never : never : never;
+export type Action<Callable extends ResolvedCallable, Definitions extends Integrations = Readonly<Record<never, never>>, DomainValue extends Domain = Domain> = (context: ActionContext<Callable, DomainValue, Definitions>) => Promise<ActionOutputOf<Callable>>;
 declare const ACTION_SCHEMA: unique symbol;
 /** Sealed standalone Action awaiting canonical callable association by Runtime admission. */
-export interface ActionDefinition<Schema extends schema.DomainSchema = schema.DomainSchema, Address extends string = string, Callable extends ResolvedCallable = ResolvedCallable, Services extends ActionServices = ActionServices> {
+export interface ActionDefinition<Schema extends schema.DomainSchema = schema.DomainSchema, Address extends ActionAddress<Schema> = ActionAddress<Schema>, Definitions extends Integrations = Readonly<Record<never, never>>> {
     readonly kind: 'action';
     readonly address: Address;
-    readonly run: Action<Callable, Services, WorkOf<Schema>>;
+    readonly run: Action<Extract<CallableAtAddress<Schema, Address>, ResolvedCallable>, Definitions, ResolvedDomainOf<Schema>>;
     /** Invariant type-only Schema witness; absent from emitted JavaScript. */
     readonly [ACTION_SCHEMA]: (schema: Schema) => Schema;
 }
 export {};
-//# sourceMappingURL=action.d.ts.map

package/dist/application/action/action.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=action.js.map

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

@@ -1,5 +1,4 @@
 export { defineAction } from './define.js';
 export type { Action, ActionDefinition } from './action.js';
-export type { ActionContext, ActionExecution, ActionServices, Caller } from './context.js';
+export type { ActionContext, ActionExecution, Caller } from './context.js';
 export type { ActionOutputOf } from './output.js';
-//# sourceMappingURL=authoring.d.ts.map

package/dist/application/action/authoring.js

@@ -1,2 +1 @@
 export { defineAction } from './define.js';
-//# sourceMappingURL=authoring.js.map

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

@@ -2,6 +2,9 @@ import type { AuthenticationEvidence, Grant, IdentityId } from '../../platform/a
 import type { BoundClientSession } from '../../platform/client/session/index.js';
 import type { NodeId } from '../../platform/graph/node/index.js';
 import type { CallableInputOf, Domain, ResolvedFunction, ResolvedMethod } from '../../platform/schema/index.js';
+import type { IntegrationClients, Integrations } from '../integration/index.js';
+import type { MutationExecutor } from '../mutation/index.js';
+import type { QueryExecutor } from '../query/index.js';
 export type ResolvedCallable = ResolvedFunction | ResolvedMethod;
 /** Bearer-free caller evidence established before an Action or Workflow runs. */
 export interface AuthenticatedCaller {
@@ -14,11 +17,6 @@ export interface AnonymousCaller {
     readonly kind: 'anonymous';
 }
 export type Caller = AuthenticatedCaller | AnonymousCaller;
-/** Runtime-initialized values available to authored behavior. */
-export interface ActionServices<Deps = Readonly<Record<never, never>>, Integrations = Readonly<Record<never, never>>> {
-    readonly deps: Deps;
-    readonly integrations: Integrations;
-}
 /** One invocation lifetime, retained without exposing Server implementation details. */
 export interface ActionExecution {
     readonly signal: AbortSignal;
@@ -36,12 +34,18 @@ type AuthorityOf<Callable> = Callable extends {
 } ? {
     readonly caller: AnonymousCaller;
     readonly client: null;
+    readonly query?: never;
+    readonly mutate?: never;
 } | {
     readonly caller: AuthenticatedCaller;
     readonly client: BoundClientSession;
+    readonly query: QueryExecutor;
+    readonly mutate: MutationExecutor;
 } : {
     readonly caller: AuthenticatedCaller;
     readonly client: BoundClientSession;
+    readonly query: QueryExecutor;
+    readonly mutate: MutationExecutor;
 };
 type SelfOf<Callable> = Callable extends ResolvedMethod<unknown, unknown, false> ? {
     readonly self: NodeId;
@@ -49,13 +53,11 @@ type SelfOf<Callable> = Callable extends ResolvedMethod<unknown, unknown, false>
     readonly self?: never;
 };
 /** Exact single-step Action context derived from one resolved callable. */
-export type ActionContext<Callable extends ResolvedCallable, Services extends ActionServices = ActionServices, Work extends Domain = Domain> = Readonly<{
+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. */
-    readonly work: Work;
+    readonly domain: DomainValue;
     readonly input: CallableInputOf<Callable>;
-    readonly deps: Services['deps'];
-    readonly integrations: Services['integrations'];
+    readonly integrations: IntegrationClients<Definitions>;
     readonly execution: ActionExecution;
-} & AuthorityOf<Callable> & SelfOf<Callable>>;
+} & AuthorityOf<Callable> & SelfOf<Callable>;
 export {};
-//# sourceMappingURL=context.d.ts.map

package/dist/application/action/context.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=context.js.map

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

@@ -1,8 +1,8 @@
 import type { schema } from '../../platform/schema/index.js';
-import type { Action, ActionAddress, ActionDefinition, CallableAtAddress, WorkOf } from './action.js';
-import type { ActionServices, ResolvedCallable } from './context.js';
+import type { Integrations } from '../integration/index.js';
+import type { Action, ActionAddress, ActionDefinition, CallableAtAddress, ResolvedDomainOf } from './action.js';
+import type { ResolvedCallable } from './context.js';
 /** Define one simple single-step implementation by its SDK Action address. */
-export declare function defineAction<Schema extends schema.DomainSchema, Services extends ActionServices = ActionServices>(): <const Address extends ActionAddress<Schema>>(address: Address, run: Action<Extract<CallableAtAddress<Schema, Address>, ResolvedCallable>, Services, WorkOf<Schema>>) => ActionDefinition<Schema, Address, Extract<CallableAtAddress<Schema, Address>, ResolvedCallable>, Services>;
+export declare function defineAction<Schema extends schema.DomainSchema, Definitions extends Integrations = Readonly<Record<never, never>>>(): <const Address extends ActionAddress<Schema>>(address: Address, run: Action<Extract<CallableAtAddress<Schema, Address>, ResolvedCallable>, Definitions, ResolvedDomainOf<Schema>>) => ActionDefinition<Schema, Address, Definitions>;
 /** True only for an Action produced by defineAction in this SDK package root. */
 export declare function isAction(input: unknown): input is ActionDefinition;
-//# sourceMappingURL=define.d.ts.map

package/dist/application/action/define.js

@@ -27,4 +27,3 @@ function acceptActionAddress(input) {
 function invalidAddress(input) {
     throw new TypeError(`Invalid Action address: ${JSON.stringify(input)}.`);
 }
-//# sourceMappingURL=define.js.map

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

@@ -1,5 +1,4 @@
 export { defineAction, isAction } from './define.js';
-export type { Action, ActionAddress, ActionAddressOf, ActionDefinition, CallableAtAddress, LocalCallable, WorkOf, } from './action.js';
-export type { ActionContext, ActionExecution, ActionServices, AnonymousCaller, AuthenticatedCaller, Caller, ResolvedCallable, } from './context.js';
+export type { Action, ActionAddress, ActionAddressOf, ActionDefinition, CallableAtAddress, LocalCallable, ResolvedDomainOf, } from './action.js';
+export type { ActionContext, ActionExecution, AnonymousCaller, AuthenticatedCaller, Caller, ResolvedCallable, } from './context.js';
 export type { ActionBinary, ActionOutputOf } from './output.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/application/action/index.js

@@ -1,2 +1 @@
 export { defineAction, isAction } from './define.js';
-//# sourceMappingURL=index.js.map

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

@@ -4,4 +4,3 @@ import type { ResolvedCallable } from './context.js';
 /** Logical output authored for the callable's exact value, stream, or binary mode. */
 export type ActionOutputOf<Callable extends ResolvedCallable> = CallableResultOf<Callable, BinaryResult>;
 export type { BinaryResult as ActionBinary };
-//# sourceMappingURL=output.d.ts.map

package/dist/application/action/output.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=output.js.map

package/dist/application/application.d.ts

@@ -21,4 +21,3 @@ export type RuntimeOfApplication<Value> = Value extends {
 } ? Extract<RuntimeValue, Runtime> : never;
 export type SchemaOfRuntime<Value> = RuntimeSchemaOf<Value>;
 export {};
-//# sourceMappingURL=application.d.ts.map

package/dist/application/application.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=application.js.map

package/dist/application/define.d.ts

@@ -14,4 +14,3 @@ export interface ApplicationInput<Schema extends schema.DomainSchema, RuntimeVal
 /** Capture one inert authored Application without resolving, compiling, loading, or deploying it. */
 export declare function defineApplication<const Schema extends schema.DomainSchema, const RuntimeValue extends Runtime<Schema>, const FrontendValue extends Frontend<Schema> | undefined = undefined, const RoutesValue extends Routes | undefined = undefined, const RequirementsValue extends Requirements | undefined = undefined>(input: ApplicationInput<Schema, RuntimeValue, FrontendValue, RoutesValue, RequirementsValue>): Application<Schema, RuntimeValue, FrontendValue, RoutesValue, RequirementsValue>;
 export declare function isApplication(input: unknown): input is Application;
-//# sourceMappingURL=define.d.ts.map

package/dist/application/define.js

@@ -38,4 +38,3 @@ export function isApplication(input) {
 function invalid() {
     throw new TypeError('Application definition may contain only schema, runtime, frontend, routes, and requirements.');
 }
-//# sourceMappingURL=define.js.map

package/dist/application/index.d.ts

@@ -7,4 +7,3 @@ export type { Route, RouteInput, RouteTarget, Routes } from './routes/index.js';
 export { defineFrontend, external, vite } from './view/index.js';
 export type { Frontend, FrontendInput, FrontendSource } from './view/index.js';
 export type { Application, RuntimeOfApplication, SchemaOfApplication, SchemaOfRuntime, } from './application.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/application/index.js

@@ -2,4 +2,3 @@ export { defineApplication, isApplication } from './define.js';
 export { requirements } from './requirements/index.js';
 export { route, routes } from './routes/index.js';
 export { defineFrontend, external, vite } from './view/index.js';
-//# sourceMappingURL=index.js.map

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

@@ -7,4 +7,3 @@ export interface AdmittedProvider {
 }
 /** Admit exact Provider coverage and Integration identity before any invocation. */
 export declare function admitProviders<Definitions extends Integrations>(integrations: Definitions, providers: Providers<Definitions>): readonly AdmittedProvider[];
-//# sourceMappingURL=admission.d.ts.map

package/dist/application/integration/admission.js

@@ -19,4 +19,3 @@ export function admitProviders(integrations, providers) {
         return Object.freeze({ name, binding });
     }));
 }
-//# sourceMappingURL=admission.js.map

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

@@ -21,4 +21,3 @@ export interface IntegrationClientFactory<Definitions extends Integrations> {
 /** Bind exact Providers once, then create invocation-scoped Integration clients. */
 export declare function bindProviders<Definitions extends Integrations>(integrations: Definitions, providers: Providers<Definitions>): IntegrationClientFactory<Definitions>;
 export declare function createIntegrationClients<Definitions extends Integrations>(integrations: Definitions, providers: Providers<Definitions>, owner: IntegrationInvocationOwner): IntegrationClients<Definitions>;
-//# sourceMappingURL=client.d.ts.map

package/dist/application/integration/client.js

@@ -96,4 +96,3 @@ function admitCoordinates(input) {
 function invalidCoordinates() {
     throw new TypeError('Integration call coordinates are invalid.');
 }
-//# sourceMappingURL=client.js.map

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

@@ -22,4 +22,3 @@ export declare function admitIntegrations<Definitions extends Integrations>(inpu
 export declare function requireIntegration(input: unknown): RuntimeDefinition;
 export declare function requireProvider(input: unknown): ProviderBinding;
 export {};
-//# sourceMappingURL=define.d.ts.map

package/dist/application/integration/define.js

@@ -99,4 +99,3 @@ function exactKeys(input, expected, label) {
         throw new TypeError(`${label} must contain exactly: ${expected.join(', ') || '(none)'}.`);
     }
 }
-//# sourceMappingURL=define.js.map

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

@@ -5,4 +5,3 @@ export type { DefineIntegration, ProviderBinding } from './define.js';
 export type { IntegrationClient, IntegrationClients, IntegrationDefinition, Integrations, } from './integration.js';
 export type { IntegrationExecution, IntegrationInput, IntegrationOperation, IntegrationOperations, IntegrationOutput, IntegrationReplay, IntegrationReplayDecision, } from './operation.js';
 export type { Provider, ProviderImplementation, Providers } from './provider.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/application/integration/index.js

@@ -1,3 +1,2 @@
 export { createIntegrationClients, bindProviders } from './client.js';
 export { admitIntegrations, defineIntegration, defineProvider, requireIntegration, requireProvider, } from './define.js';
-//# sourceMappingURL=index.js.map

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

@@ -17,4 +17,3 @@ export type IntegrationClients<Definitions extends Integrations> = Readonly<{
     [Name in keyof Definitions]: IntegrationClient<Definitions[Name]>;
 }>;
 export {};
-//# sourceMappingURL=integration.d.ts.map

package/dist/application/integration/integration.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=integration.js.map

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

@@ -30,4 +30,3 @@ export type IntegrationOutput<Operation> = Operation extends {
     readonly [INTEGRATION_OPERATION]: (input: never) => infer Output;
 } ? Output : never;
 export {};
-//# sourceMappingURL=operation.d.ts.map

package/dist/application/integration/operation.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=operation.js.map

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

@@ -12,4 +12,3 @@ export type Providers<Definitions extends Integrations> = Readonly<{
     [Name in keyof Definitions]: Provider<Definitions[Name]>;
 }>;
 export {};
-//# sourceMappingURL=provider.d.ts.map

package/dist/application/integration/provider.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=provider.js.map

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

@@ -1,4 +1,3 @@
 import type { IntegrationOperation, IntegrationReplayDecision } from './operation.js';
 export declare function resolveReplay(operation: IntegrationOperation<never, unknown>, input: unknown): IntegrationReplayDecision;
 export declare function acceptReplay(input: unknown): IntegrationReplayDecision;
-//# sourceMappingURL=replay.d.ts.map

package/dist/application/integration/replay.js

@@ -35,4 +35,3 @@ function exactKeys(input, expected) {
 function invalid() {
     throw new TypeError('Integration replay decision is invalid.');
 }
-//# sourceMappingURL=replay.js.map

package/dist/application/mutation/authoring/builder.d.ts

@@ -1,5 +1,4 @@
 import type { EdgeSlug } from '@astrale-os/kernel-core/graph/edge';
-import type { LocalBinding } from '@astrale-os/kernel-core/graph/graph';
 import type { MutationBuilder } from '@astrale-os/kernel-core/graph/mutate';
 import type { QueryEdgeAST, QueryNodeAST } from '@astrale-os/kernel-core/graph/query';
 import type { ResolvedClass } from '../../../platform/schema/index.js';
@@ -20,7 +19,7 @@ export interface RichMutationBuilder {
         query<Query extends QueryNodeAST | QueryEdgeAST>(input: QueryPrecondition<Query>): RichMutationBuilder;
     };
     createNode<Class extends ResolvedClass<'node'>>(input: {
-        readonly as: LocalBinding;
+        readonly as: string;
         readonly class: Class;
         readonly props?: RichPropertyInput<Class>;
     }): CreatedNode<Class>;
@@ -52,4 +51,3 @@ export interface EdgeSelector<Class extends ResolvedClass<'edge'>> {
     readonly class: Class;
 }
 export declare function richMutationBuilder(core: MutationBuilder): RichMutationBuilder;
-//# sourceMappingURL=builder.d.ts.map

package/dist/application/mutation/authoring/builder.js

@@ -1,3 +1,4 @@
+import { LocalBinding } from '@astrale-os/kernel-core/graph/graph';
 import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { endpoint, existingEndpoint } from './endpoint.js';
 import { precondition } from './precondition.js';
@@ -31,7 +32,7 @@ export function richMutationBuilder(core) {
         expect: expectation,
         createNode(input) {
             const created = core.createNode({
-                as: input.as,
+                as: LocalBinding(input.as),
                 class: classKey(input.class),
                 ...(input.props === undefined ? {} : { props: properties(input.class, input.props) }),
             });
@@ -94,4 +95,3 @@ export function richMutationBuilder(core) {
 function classKey(selected) {
     return ClassKey(selected.key);
 }
-//# sourceMappingURL=builder.js.map

package/dist/application/mutation/authoring/endpoint.d.ts

@@ -14,4 +14,3 @@ export declare function endpoint(input: MutationEndpoint): NodeTarget | {
     readonly created: LocalBinding;
 };
 export declare function existingEndpoint(input: ExistingEndpoint): NodeTarget;
-//# sourceMappingURL=endpoint.d.ts.map

package/dist/application/mutation/authoring/endpoint.js

@@ -11,4 +11,3 @@ export function existingEndpoint(input) {
 function isCreated(input) {
     return typeof input === 'object' && input !== null && 'created' in input;
 }
-//# sourceMappingURL=endpoint.js.map

package/dist/application/mutation/authoring/index.d.ts

@@ -2,4 +2,3 @@ export { richMutationBuilder, type EdgeSelector, type RichMutationBuilder } from
 export type { CreatedNode, ExistingEndpoint, MutationEndpoint } from './endpoint.js';
 export type { RichPropertyConditions, RichPropertyDelta, RichPropertyInput, RichPropertyName, } from './properties.js';
 export type { QueryPrecondition } from './precondition.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/application/mutation/authoring/index.js

@@ -1,2 +1 @@
 export { richMutationBuilder } from './builder.js';
-//# sourceMappingURL=index.js.map

package/dist/application/mutation/authoring/precondition.d.ts

@@ -5,4 +5,3 @@ export interface QueryPrecondition<Query extends QueryNodeAST | QueryEdgeAST> {
     readonly equals: QuerySelectionFor<QueryResultFor<Query>>;
 }
 export declare function precondition<Query extends QueryNodeAST | QueryEdgeAST>(core: MutationBuilder, input: QueryPrecondition<Query>): void;
-//# sourceMappingURL=precondition.d.ts.map

package/dist/application/mutation/authoring/precondition.js

@@ -6,4 +6,3 @@ export function precondition(core, input) {
         core.expect.query({ query: input.query, equals: input.equals });
     }
 }
-//# sourceMappingURL=precondition.js.map

package/dist/application/mutation/authoring/properties.d.ts

@@ -12,11 +12,10 @@ export interface RichPropertyDelta<Class> {
 }
 export declare function properties<Class extends ResolvedClass>(selected: Class, input: RichPropertyInput<Class>): MutationPropsInput;
 export declare function conditions<Class extends ResolvedClass>(selected: Class, input: RichPropertyConditions<Class>): Readonly<{
-    equals?: Readonly<Record<`${string}:class.${string}.property.${string}`, import("@astrale-os/kernel-dsl/value").Value>> | undefined;
+    equals?: Readonly<Record<`${string}:class.${string}.property.${string}`, import("../../../platform/schema/index.js").Value>> | undefined;
     absent?: readonly `${string}:class.${string}.property.${string}`[] | undefined;
 }>;
 export declare function delta<Class extends ResolvedClass>(selected: Class, input: RichPropertyDelta<Class>): Readonly<{
-    set: Readonly<Record<`${string}:class.${string}.property.${string}`, import("@astrale-os/kernel-dsl/value").Value>>;
+    set: Readonly<Record<`${string}:class.${string}.property.${string}`, import("../../../platform/schema/index.js").Value>>;
     unset: readonly `${string}:class.${string}.property.${string}`[];
 }>;
-//# sourceMappingURL=properties.d.ts.map

package/dist/application/mutation/authoring/properties.js

@@ -25,4 +25,3 @@ function property(selected, name) {
     }
     return value;
 }
-//# sourceMappingURL=properties.js.map

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

@@ -1,4 +1,3 @@
 import type { MutationResult } from '@astrale-os/kernel-core/graph/mutate';
 import type { Mutation } from './mutation.js';
 export declare function defineMutation<Input, Output = MutationResult>(definition: Mutation<Input, Output>): Mutation<Input, Output>;
-//# sourceMappingURL=define.d.ts.map

package/dist/application/mutation/define.js

@@ -15,4 +15,3 @@ export function defineMutation(definition) {
 function invalid() {
     throw new TypeError('Mutation definition is invalid.');
 }
-//# sourceMappingURL=define.js.map

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

@@ -4,4 +4,3 @@ export interface MutationClient {
     mutate(ast: ReturnType<typeof MutationAST.build>): Promise<MutationResult>;
 }
 export declare function executeMutation<Input, Output>(client: MutationClient, definition: Mutation<Input, Output>, input: Input): Promise<Output>;
-//# sourceMappingURL=execute.d.ts.map

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

@@ -17,4 +17,3 @@ export async function executeMutation(client, definition, input) {
         throw cause;
     }
 }
-//# sourceMappingURL=execute.js.map

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

@@ -0,0 +1,8 @@
+import type { Mutation } from '../mutation.js';
+import type { MutationClient } from './execute.js';
+/** Invocation-bound executor for authored Mutation definitions. */
+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;

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

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

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

@@ -1,2 +1,2 @@
 export { executeMutation, type MutationClient } from './execute.js';
-//# sourceMappingURL=index.d.ts.map
+export type { MutationExecutor } from './executor.js';

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

@@ -1,2 +1 @@
 export { executeMutation } from './execute.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,4 +1,3 @@
 import type { MutationResult } from '@astrale-os/kernel-core/graph/mutate';
 import type { Mutation } from '../mutation.js';
 export declare function projectMutation<Input, Output>(definition: Mutation<Input, Output>, result: MutationResult, input: Input): Output;
-//# sourceMappingURL=projection.d.ts.map

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

@@ -1,4 +1,3 @@
 export function projectMutation(definition, result, input) {
     return (definition.project === undefined ? result : definition.project(result, input));
 }
-//# sourceMappingURL=projection.js.map

package/dist/application/mutation/failure.d.ts

@@ -3,4 +3,3 @@ export interface MutationFailure extends Error {
     readonly outcomeKnown: boolean;
 }
 export declare function mutationFailure(input: unknown): MutationFailure | undefined;
-//# sourceMappingURL=failure.d.ts.map

package/dist/application/mutation/failure.js

@@ -26,4 +26,3 @@ function nestedCode(input) {
         ? Reflect.get(input, 'code')
         : undefined;
 }
-//# sourceMappingURL=failure.js.map

package/dist/application/mutation/index.d.ts

@@ -1,8 +1,7 @@
 export { defineMutation } from './define.js';
-export { executeMutation, type MutationClient } from './execution/index.js';
+export { executeMutation, type MutationClient, type MutationExecutor } from './execution/index.js';
 export type { MutationFailure } from './failure.js';
 export type { Mutation, MutationInputOf, MutationOutputOf } from './mutation.js';
 export type { CreatedNode, EdgeSelector, ExistingEndpoint, MutationEndpoint, QueryPrecondition, RichMutationBuilder, RichPropertyConditions, RichPropertyDelta, RichPropertyInput, RichPropertyName, } from './authoring/index.js';
 /** Canonical low-level Mutation documents remain available as the explicit escape hatch. */
 export * from '@astrale-os/kernel-core/graph/mutate';
-//# sourceMappingURL=index.d.ts.map

package/dist/application/mutation/index.js

@@ -2,4 +2,3 @@ export { defineMutation } from './define.js';
 export { executeMutation } from './execution/index.js';
 /** Canonical low-level Mutation documents remain available as the explicit escape hatch. */
 export * from '@astrale-os/kernel-core/graph/mutate';
-//# sourceMappingURL=index.js.map

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

@@ -14,4 +14,3 @@ export interface Mutation<Input, Output = MutationResult> {
 export type MutationInputOf<Value> = Value extends Mutation<infer Input, infer _Output> ? Input : never;
 export type MutationOutputOf<Value> = Value extends Mutation<infer _Input, infer Output> ? Output : never;
 export {};
-//# sourceMappingURL=mutation.d.ts.map

package/dist/application/mutation/mutation.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=mutation.js.map

package/dist/application/query/composite/builder.d.ts

@@ -37,4 +37,3 @@ export declare function inspectPlan(plan: InternalPlan): Readonly<{
 export declare function referencesIn(input: unknown, found?: PlanReference[]): readonly PlanReference[];
 export declare function resolveInput(input: unknown, execute: (plan: InternalPlan) => Promise<unknown>): Promise<unknown>;
 export {};
-//# sourceMappingURL=builder.d.ts.map

package/dist/application/query/composite/builder.js

@@ -167,4 +167,3 @@ function isPlainRecord(input) {
 function invalid(message) {
     throw new QueryCompositionError('QUERY_COMPOSITION_INVALID', message);
 }
-//# sourceMappingURL=builder.js.map

package/dist/application/query/composite/errors.d.ts

@@ -5,4 +5,3 @@ export declare class QueryCompositionError extends Error implements QueryFailure
     readonly name = "QueryCompositionError";
     constructor(code: QueryCompositionErrorCode, message: string);
 }
-//# sourceMappingURL=errors.d.ts.map

package/dist/application/query/composite/errors.js

@@ -6,4 +6,3 @@ export class QueryCompositionError extends Error {
         this.code = code;
     }
 }
-//# sourceMappingURL=errors.js.map

package/dist/application/query/composite/index.d.ts

@@ -2,4 +2,3 @@ export { createQueryComposition, type QueryCompositionSession } from './builder.
 export { QueryCompositionError, type QueryCompositionErrorCode } from './errors.js';
 export { analyzeQueryPlan, executeQueryPlan, type QueryPlanAnalysis } from './plan.js';
 export type { CompositeQuery, ProjectedCompositeQuery, QueryComposition, QueryPlan, QueryPlanInput, QueryPlanOutput, QueryPlanValue, RawCompositeQuery, } from './query.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/application/query/composite/index.js

@@ -1,4 +1,3 @@
 export { createQueryComposition } from './builder.js';
 export { QueryCompositionError } from './errors.js';
 export { analyzeQueryPlan, executeQueryPlan } from './plan.js';
-//# sourceMappingURL=index.js.map

package/dist/application/query/composite/plan.d.ts

@@ -6,4 +6,3 @@ export interface QueryPlanAnalysis {
 }
 export declare function analyzeQueryPlan(plan: InternalPlan): QueryPlanAnalysis;
 export declare function executeQueryPlan(plan: InternalPlan, run: (definition: SingleQuery<unknown, unknown>, input: unknown) => Promise<unknown>): Promise<unknown>;
-//# sourceMappingURL=plan.d.ts.map

package/dist/application/query/composite/plan.js

@@ -54,4 +54,3 @@ export async function executeQueryPlan(plan, run) {
 function invalid(message) {
     throw new QueryCompositionError('QUERY_COMPOSITION_INVALID', message);
 }
-//# sourceMappingURL=plan.js.map

package/dist/application/query/composite/query.d.ts

@@ -32,4 +32,3 @@ export interface ProjectedCompositeQuery<Input, Composed, Output> extends Compos
 }
 export type CompositeQuery<Input, Composed, Output = Composed> = RawCompositeQuery<Input, Composed> | ProjectedCompositeQuery<Input, Composed, Output>;
 export {};
-//# sourceMappingURL=query.d.ts.map

package/dist/application/query/composite/query.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=query.js.map

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

@@ -22,4 +22,3 @@ export declare function defineQuery<Input, Output, Ast extends QueryAST>(definit
 export declare function defineCompositeQuery<Input, Output>(definition: Omit<RawCompositeQuery<Input, Output>, 'kind'>): RawCompositeQuery<Input, Output>;
 export declare function defineCompositeQuery<Input, Composed, Output>(definition: Omit<ProjectedCompositeQuery<Input, Composed, Output>, 'kind'>): ProjectedCompositeQuery<Input, Composed, Output>;
 export {};
-//# sourceMappingURL=define.d.ts.map

package/dist/application/query/define.js

@@ -73,4 +73,3 @@ function pageOf(input) {
 function invalid() {
     throw new TypeError('Query definition is invalid.');
 }
-//# sourceMappingURL=define.js.map

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

@@ -9,4 +9,3 @@ export interface QueryClient {
 }
 export declare function executeQuery<Input, Output>(client: QueryClient, definition: QueryDefinition<Input, Output>, input: Input): Promise<Output>;
 export type ExecutableCompositeQuery = CompositeQuery<unknown, unknown, unknown>;
-//# sourceMappingURL=execute.d.ts.map