@astrale-os/kernel-client 0.6.0-beta.56 → 0.6.0-beta.58

package/dist/auth/credential.js

@@ -8,8 +8,8 @@ export function credentialApi(call) {
             return credential(await call(IDENTITY_MINT_PATH, input, options));
         },
         async delegate(principal, input, options) {
-            const target = Path.instanceMethod(Path.id(principal), identity.delegate.name).raw;
-            return credential(await call(target, input, options));
+            const target = Path.staticMethod(identityOwner, identity.delegate.name).raw;
+            return credential(await call(target, { ...input, principal }, options));
         },
     });
 }

package/dist/client/admission.d.ts

@@ -1,4 +1,7 @@
 import type { invocation as protocol } from '@astrale-os/kernel-protocol';
 import type { Call } from './request.js';
 /** Parent-private Call acceptance shared by Client and Client Session. */
-export declare function acceptCall(input: Call): protocol.Call;
+export declare function acceptCall(input: {
+    readonly target: Call['target'];
+    readonly input: unknown;
+}): protocol.Call;

package/dist/client/admission.js

@@ -1,3 +1,4 @@
+import { Target } from '@astrale-os/kernel-core/callable';
 import { Path } from '@astrale-os/kernel-core/path';
 import * as portable from '@astrale-os/kernel-dsl/value';
 /** Parent-private Call acceptance shared by Client and Client Session. */
@@ -5,7 +6,13 @@ export function acceptCall(input) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
         throw new TypeError('Client call must be an object.');
     }
-    return Object.freeze({ target: admitPath(input.target), input: admitInput(input.input) });
+    const target = input.target;
+    return Object.freeze({
+        target: typeof target === 'object' && target !== null && 'callable' in target
+            ? Target(target)
+            : admitPath(target),
+        input: admitInput(input.input),
+    });
 }
 function admitPath(input) {
     try {

package/dist/client/request.d.ts

@@ -1,10 +1,11 @@
+import type { Target } from '@astrale-os/kernel-core/callable';
 import type { PathLike } from '@astrale-os/kernel-core/path';
 import type * as protocol from '@astrale-os/kernel-protocol/invocation';
 import type { RequestOptions, TransportRequest } from '../transport/index.js';
 import type { Input } from './result.js';
 /** One portable call before Path canonicalization, correlation, and credential binding. */
 export interface Call {
-    readonly target: PathLike;
+    readonly target: PathLike | Target;
     readonly input: Input;
 }
 export interface ClientDispatchOptions extends RequestOptions {
@@ -21,6 +22,6 @@ export interface AdmittedRequest {
     readonly schema?: protocol.SchemaTarget;
     readonly options: RequestOptions;
 }
-export declare function call(target: PathLike, input: Input): Call;
+export declare function call(target: PathLike | Target, input: Input): Call;
 export declare function admitRequest(input: Call, options: ClientDispatchOptions | undefined, lifecycle: AbortSignal): AdmittedRequest;
 export declare function invocation(request: AdmittedRequest, credential?: string, trace?: protocol.Trace): TransportRequest;

package/dist/client/request.js

@@ -45,6 +45,9 @@ function admitRequestOptions(input) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
         throw new TypeError('Client request options must be an object.');
     }
+    if (Reflect.ownKeys(input).some((field) => !['signal', 'timeoutMs', 'idempotencyKey', 'delegate', 'routing', 'schema'].includes(String(field)))) {
+        throw new TypeError('Client request options contain unsupported fields.');
+    }
     if (input.timeoutMs !== undefined &&
         (!Number.isSafeInteger(input.timeoutMs) ||
             input.timeoutMs < 1 ||

package/dist/graph/domain/domain.typecheck.js

@@ -62,6 +62,7 @@ const source = Query.from({ nodes: [Work.classes.Resource] });
 const query = source.select({ kind: 'nodes', projection: { kind: 'value' } });
 const prototypeSource = Query.from({ nodes: [Work.classes.PrototypeMembers] });
 const prototypeQuery = prototypeSource.select({ kind: 'nodes', projection: { kind: 'value' } });
+// @ts-expect-error Concrete Method shortcuts are absent from a child-selected projection.
 const resourceAcceptsDocument = documentProjection;
 void resourceAcceptsDocument;
 const resourceReceiverAcceptsDocument = documentProjection;

package/dist/graph/domain/project.js

@@ -1,8 +1,14 @@
 import { MethodKey, PropertyKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { retainProjectedProvenance } from './provenance.js';
 export function projectNode(selected, node, provenance, call) {
+    const invoke = async (receiver, method, input) => {
+        if (receiver.class !== method.owner.key) {
+            throw new TypeError(`Method ${method.key} requires an exact ${method.owner.key} receiver.`);
+        }
+        return call(receiver, method, input);
+    };
     const property = propertyAccessor(selected, node.props);
-    const method = methodAccessor(selected, node, call);
+    const method = methodAccessor(selected, node, invoke);
     const value = {
         id: node.id,
         class: node.class,
@@ -11,7 +17,7 @@ export function projectNode(selected, node, provenance, call) {
         method,
     };
     installPropertyShortcuts(value, selected, node.props, NODE_RESERVED);
-    installMethodShortcuts(value, selected, node, call, NODE_RESERVED);
+    installMethodShortcuts(value, selected, node, invoke, NODE_RESERVED);
     const projected = Object.freeze(value);
     retainProjectedProvenance(projected, provenance);
     return projected;
@@ -41,7 +47,7 @@ function propertyAccessor(selected, props) {
 function methodAccessor(selected, node, call) {
     return (input) => {
         const method = resolveMethod(selected, input);
-        if (method.inheritance === 'abstract') {
+        if (!method.executable) {
             throw new TypeError(`Abstract Method ${method.key} cannot be invoked.`);
         }
         return (value) => call(node, method, value);
@@ -98,9 +104,7 @@ function installPropertyShortcuts(target, selected, props, reserved) {
 }
 function installMethodShortcuts(target, selected, node, call, reserved) {
     for (const member of selected.methods) {
-        if (member.inheritance === 'abstract' ||
-            reserved.has(member.name) ||
-            hasOwn(target, member.name))
+        if (!member.executable || reserved.has(member.name) || hasOwn(target, member.name))
             continue;
         if (named(selected.methods, member.name) !== member)
             continue;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { Target, targetPath } from '@astrale-os/kernel-core/callable';
 export { Client, call, type AuthenticatedClient, type Call, type ClientDispatchOptions, type ClientOptions, type Binary, type BinaryResponse, type Input, type RemoteCredential, type Result, type Stream, type StreamResult, type ValueResult, } from './client/index.js';
 export * from './errors/index.js';
 export { type RequestOptions, type MissControl, type StaleControl, type Transport, type TransportRequest, type TransportResult, } from './transport/index.js';

package/dist/index.js

@@ -1,3 +1,4 @@
+export { Target, targetPath } from '@astrale-os/kernel-core/callable';
 export { Client, call, } from './client/index.js';
 export * from './errors/index.js';
 export {} from './transport/index.js';

package/dist/session/bound.d.ts

@@ -14,7 +14,7 @@ export interface BoundSessionSource {
     readonly schema: SchemaApi;
     dispatch(call: Call, options?: SessionRequestOptions): Promise<Result>;
     call(call: Call, options?: SessionRequestOptions): Promise<Input>;
-    invoke<const Reference extends CallableReference>(reference: Reference, input: InputOfReference<Reference>, options?: SessionRequestOptions): Promise<OutputOfReference<Reference>>;
+    invoke<const Reference extends CallableReference<unknown>>(reference: Reference, input: InputOfReference<Reference>, options?: SessionRequestOptions): Promise<OutputOfReference<Reference>>;
     stream(call: Call, options?: SessionRequestOptions): Promise<Stream>;
     binary(call: Call, options?: SessionRequestOptions): Promise<Binary>;
     viewsFor(target: Parameters<ClientSession['viewsFor']>[0], options?: SessionControlOptions): Promise<ViewCatalog>;
@@ -36,7 +36,7 @@ export interface BoundClientSession extends GraphApi {
     readonly schema: SchemaApi;
     dispatch(call: Call, options?: SessionRequestOptions): Promise<Result>;
     call(call: Call, options?: SessionRequestOptions): Promise<Input>;
-    invoke<const Reference extends CallableReference>(reference: Reference, input: InputOfReference<Reference>, options?: SessionRequestOptions): Promise<OutputOfReference<Reference>>;
+    invoke<const Reference extends CallableReference<unknown>>(reference: Reference, input: InputOfReference<Reference>, options?: SessionRequestOptions): Promise<OutputOfReference<Reference>>;
     stream(call: Call, options?: SessionRequestOptions): Promise<Stream>;
     binary(call: Call, options?: SessionRequestOptions): Promise<Binary>;
     viewsFor: BoundSessionSource['viewsFor'];

package/dist/session/reference.d.ts

@@ -1,11 +1,11 @@
 import type { Path as PathValue, PathLike } from '@astrale-os/kernel-core/path';
-import type { CallableInputOf, CallableOutputOf, CallableResultOf, Domain, MethodInheritance, ResolvedFunction, ResolvedMethod } from '@astrale-os/kernel-dsl/v1';
+import type { CallableInputOf, CallableOutputOf, CallableResultOf, Domain, ResolvedFunction, ExecutableMethod } from '@astrale-os/kernel-dsl/v1';
 import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
 import { type Key as KeyType } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Binary, Input } from '../client/index.js';
 declare const REFERENCE_INPUT: unique symbol;
 declare const REFERENCE_OUTPUT: unique symbol;
-export interface CallableReference<InputValue extends Input = Input, Output = unknown> {
+export interface CallableReference<InputValue = Input, Output = unknown> {
     readonly origin: KeyType.Origin;
     readonly revision: Revision;
     readonly callable: KeyType.Callable;
@@ -14,23 +14,22 @@ export interface CallableReference<InputValue extends Input = Input, Output = un
     readonly [REFERENCE_INPUT]?: InputValue;
     readonly [REFERENCE_OUTPUT]?: Output;
 }
-export interface InstanceCallableReference<InputValue extends Input = Input, Output = unknown> {
+export interface InstanceCallableReference<InputValue = Input, Output = unknown> {
     (receiver: PathLike): CallableReference<InputValue, Output>;
     readonly origin: KeyType.Origin;
     readonly revision: Revision;
     readonly callable: KeyType.Callable;
     readonly outputMode: 'value' | 'stream' | 'binary';
 }
-export type InputOfReference<Reference extends CallableReference> = Reference extends CallableReference<infer InputValue, unknown> ? InputValue : never;
-export type OutputOfReference<Reference extends CallableReference> = Reference extends CallableReference<infer _Input, infer Output> ? Output : never;
-type ReferenceInput<Callable> = unknown extends CallableInputOf<Callable> ? Input : Extract<CallableInputOf<Callable>, Input>;
+export type InputOfReference<Reference extends CallableReference<unknown>> = Reference extends CallableReference<infer InputValue, unknown> ? InputValue : never;
+export type OutputOfReference<Reference extends CallableReference<unknown>> = Reference extends CallableReference<infer _Input, infer Output> ? Output : never;
+type ReferenceInput<Callable> = unknown extends CallableInputOf<Callable> ? Input : CallableInputOf<Callable>;
 type ReferenceOutput<Callable> = unknown extends CallableOutputOf<Callable> ? unknown : CallableResultOf<Callable, Binary>;
-type ExecutableMethodInheritance = Exclude<MethodInheritance, 'abstract'>;
-type ExecutableStaticMethod = ResolvedMethod<unknown, unknown, true, ExecutableMethodInheritance>;
-type ExecutableInstanceMethod = ResolvedMethod<unknown, unknown, false, ExecutableMethodInheritance>;
+type ExecutableStaticMethod = ExecutableMethod<unknown, unknown, true>;
+type ExecutableInstanceMethod = ExecutableMethod<unknown, unknown, false>;
 /** Project one exact resolved Function or static Method into a typed Client reference. */
 export declare function reference<const Callable extends ResolvedFunction | ExecutableStaticMethod>(domain: Pick<Domain, 'origin' | 'revision'>, callable: Callable): CallableReference<ReferenceInput<Callable>, ReferenceOutput<Callable>>;
 /** Project one exact resolved instance Method into a receiver-bound typed Client reference. */
 export declare function reference<const Callable extends ExecutableInstanceMethod>(domain: Pick<Domain, 'origin' | 'revision'>, callable: Callable): InstanceCallableReference<ReferenceInput<Callable>, ReferenceOutput<Callable>>;
-export declare function admitReference(input: CallableReference): CallableReference;
+export declare function admitReference(input: CallableReference<unknown>): CallableReference<unknown>;
 export {};

package/dist/session/reference.js

@@ -1,7 +1,9 @@
 import { Path } from '@astrale-os/kernel-core/path';
 import { callableAddress, Key, patterns, } from '@astrale-os/kernel-dsl/v1/addressing';
 export function reference(domain, callable) {
-    if ('owner' in callable && callable.inheritance === 'abstract')
+    if (Key.origin(callable.key) !== domain.origin)
+        invalid();
+    if ('owner' in callable && !callable.executable)
         invalid();
     const common = Object.freeze({
         origin: domain.origin,
@@ -12,7 +14,7 @@ export function reference(domain, callable) {
     if ('owner' in callable && !callable.static) {
         const bind = (receiver) => admitReference({
             ...common,
-            target: Path.instanceMethod(Path.from(receiver), callable.name),
+            target: Path.instanceMethod(Path.from(receiver), callable.key),
         });
         return Object.assign(bind, common);
     }
@@ -52,7 +54,7 @@ function matchesCallable(target, callable) {
         if (last?.kind !== 'method' || last.name !== coordinate.name)
             return false;
         if (last.dispatch === 'instance')
-            return true;
+            return last.class === Key.of(coordinate.owner);
         const owner = steps.at(-2);
         return (anchor.kind === 'domain' &&
             anchor.origin === Key.origin(callable) &&

package/dist/session/routing/cache.d.ts

@@ -1,6 +1,5 @@
 import { invocation } from '@astrale-os/kernel-protocol';
 import type { EffectiveAuth } from './auth.js';
-import type { SchemaExpectation } from './expectation.js';
 export interface LearnedRoute {
     readonly route: invocation.Route;
     readonly credential?: string;
@@ -27,7 +26,7 @@ export declare class RouteCache {
     private readonly keyTokens;
     private readonly store?;
     constructor(maximumAgeMs: number, maximumSize?: number, store?: SessionRouteStore);
-    key(source: string, call: invocation.Call, auth: EffectiveAuth, expected?: SchemaExpectation): Promise<string>;
+    key(source: string, call: invocation.Call, auth: EffectiveAuth): Promise<string>;
     get(key: string, sourceCredential?: string, now?: number): Promise<LearnedRoute | undefined>;
     learn(key: string, route: invocation.Route, credential: string | undefined, sourceCredential?: string, now?: number): Promise<LearnedRoute>;
     delete(key: string): void;

package/dist/session/routing/cache.js

@@ -14,16 +14,10 @@ export class RouteCache {
         this.store = store === undefined ? undefined : captureSessionRouteStore(store);
         this.restore();
     }
-    async key(source, call, auth, expected) {
+    async key(source, call, auth) {
         const credential = auth.credential === undefined ? 'anonymous' : await digestText(auth.credential);
         const delegate = auth.delegate === undefined ? 'anonymous' : await digestText(canonicalDelegate(auth.delegate));
-        return JSON.stringify([
-            source,
-            call.target,
-            credential,
-            delegate,
-            expected === undefined ? null : [expected.origin, expected.revision],
-        ]);
+        return JSON.stringify([source, call.target, credential, delegate]);
     }
     async get(key, sourceCredential, now = Date.now()) {
         const cached = this.entries.get(key);

package/dist/session/routing/dispatch.d.ts

@@ -1,11 +1,11 @@
 import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
-import type { Call, Result } from '../../client/index.js';
+import type { Result } from '../../client/index.js';
 import type { SessionOperation, SessionPolicy } from '../context/index.js';
 import type { SessionAuth } from './auth.js';
 import type { RouteCache } from './cache.js';
 import type { ClientPoolCapability } from './envelope.js';
-import type { SchemaExpectation } from './expectation.js';
 import type { SessionEnvelopeTransport, SessionRequestOptions } from './request.js';
+import { acceptCall } from '../../client/index.js';
 export interface SessionDispatcherOptions {
     readonly kernel: IssuerId;
     readonly sourceEndpoint: string;
@@ -20,7 +20,7 @@ export interface SessionDispatcherOptions {
 export declare class SessionDispatcher {
     private readonly state;
     constructor(state: SessionDispatcherOptions);
-    dispatch(input: Call, options: SessionRequestOptions, operation: SessionOperation, expected?: SchemaExpectation): Promise<Result>;
+    dispatch(input: Parameters<typeof acceptCall>[0], options: SessionRequestOptions, operation: SessionOperation): Promise<Result>;
     private dispatchSource;
     private followSource;
     private dispatchDestinationWithRecovery;

package/dist/session/routing/dispatch.js

@@ -1,3 +1,4 @@
+import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as invocationProtocol from '@astrale-os/kernel-protocol/invocation';
 import { acceptCall, dispatchTrace, isAdmittedMissError, isAdmittedStaleRouteError, } from '../../client/index.js';
 import { ClientError, ResponseError } from '../../errors/index.js';
@@ -9,25 +10,24 @@ export class SessionDispatcher {
     constructor(state) {
         this.state = state;
     }
-    async dispatch(input, options, operation, expected) {
+    async dispatch(input, options, operation) {
         this.state.requireOpen();
         const call = acceptCall(input);
         // Authority is resolved before warm lookup so changed credentials or delegation cannot reuse a
         // carrier minted for a different caller partition.
         const auth = await resolveAuth(this.state.auth, call, operation);
         const source = this.state.kernel;
-        const cacheKey = await this.state.cache.key(source, call, auth, expected);
+        const cacheKey = await this.state.cache.key(source, call, auth);
         const dispatch = Object.freeze({
             call,
             auth,
             source,
             cacheKey,
-            ...(expected === undefined ? {} : { expected }),
         });
         let learned = await this.state.cache.get(cacheKey, auth.credential);
         if (learned !== undefined) {
             try {
-                requireCachedRoute(learned, source, expected, this.state.envelopeTransport, this.state.websocketAvailable, this.state.policy);
+                requireCachedRoute(learned, source, call.target, this.state.envelopeTransport, this.state.websocketAvailable, this.state.policy);
             }
             catch {
                 this.state.cache.delete(cacheKey);
@@ -48,7 +48,6 @@ export class SessionDispatcher {
             ...sessionTransportOptions(operation, options.idempotencyKey),
             ...(state.auth.delegate === undefined ? {} : { delegate: state.auth.delegate }),
             ...(routing === undefined ? {} : { routing }),
-            ...(state.expected === undefined ? {} : { schema: { revision: state.expected.revision } }),
         }));
     }
     async followSource(result, state, options, operation) {
@@ -58,13 +57,13 @@ export class SessionDispatcher {
         if (redirect.route.via.issuer !== state.source) {
             throw new ClientError('Redirect issuer differs from the session-pinned source Kernel identity.');
         }
-        requireExpectedPublication(redirect.route, state.expected);
+        requireTargetPublication(redirect.route, state.call.target);
         const learned = await this.state.cache.learn(state.cacheKey, redirect.route, redirect.credential, state.auth.credential);
         return this.dispatchDestinationWithRecovery(learned, state, options, operation, redirect.trace);
     }
     async dispatchDestinationWithRecovery(learned, state, options, operation, trace) {
         try {
-            return await this.dispatchDestination(learned, state.call, options, operation, state.source, state.expected, trace);
+            return await this.dispatchDestination(learned, state.call, options, operation, state.source, trace);
         }
         catch (cause) {
             const stale = isAdmittedStaleRouteError(cause);
@@ -88,11 +87,11 @@ export class SessionDispatcher {
             return this.followSource(refreshed, state, options, operation);
         }
     }
-    async dispatchDestination(learned, call, options, operation, source, expected, trace) {
+    async dispatchDestination(learned, call, options, operation, source, trace) {
         if (learned.route.via.issuer !== source) {
             throw new ClientError('Learned route issuer differs from the session-pinned source Kernel.');
         }
-        requireExpectedPublication(learned.route, expected);
+        requireTargetPublication(learned.route, call.target);
         const envelope = selectEnvelope(learned.route.endpoint, this.state.envelopeTransport, this.state.websocketAvailable, this.state.pool, this.state.policy);
         const requestOptions = {
             ...sessionTransportOptions(operation, options.idempotencyKey),
@@ -107,11 +106,11 @@ export class SessionDispatcher {
         return result;
     }
 }
-function requireCachedRoute(learned, source, expected, envelopeTransport, websocketAvailable, policy) {
+function requireCachedRoute(learned, source, target, envelopeTransport, websocketAvailable, policy) {
     if (learned.route.via.issuer !== source) {
         throw new ClientError('Learned route issuer differs from the session-pinned source Kernel.');
     }
-    requireExpectedPublication(learned.route, expected);
+    requireTargetPublication(learned.route, target);
     selectEnvelopeTarget(learned.route.endpoint, envelopeTransport, websocketAvailable, policy);
 }
 function isRouteCompatibilityConflict(input) {
@@ -125,11 +124,12 @@ function isRouteCompatibilityConflict(input) {
     return (failure?.data.code === invocationProtocol.SCHEMA_REVISION_MISMATCH ||
         failure?.data.code === invocationProtocol.SERVICE_TRUST_REQUIRED);
 }
-function requireExpectedPublication(route, expected) {
-    if (expected === undefined)
+function requireTargetPublication(route, target) {
+    if (typeof target === 'string')
         return;
     const actual = route.via.publication;
-    if (actual.origin !== expected.origin || actual.revision !== expected.revision) {
+    if (actual.origin !== Key.origin(target.callable) ||
+        (target.revision !== undefined && actual.revision !== target.revision)) {
         throw new ClientError('Resolved route does not match the expected Schema revision.');
     }
 }

package/dist/session/routing/index.d.ts

@@ -1,5 +1,4 @@
 export { admitSessionAuth, resolveAuth, type Auth, type EffectiveAuth, type SessionAuth, } from './auth.js';
-export type { SchemaExpectation } from './expectation.js';
 export { RouteCache, type LearnedRoute, type PersistedRoute, type SessionRouteArtifact, type SessionRouteStore, } from './cache.js';
 export { requireResultKind, SessionDispatcher, type SessionDispatcherOptions } from './dispatch.js';
 export { type ClientPoolCapability, type EnvelopeSelection } from './envelope.js';

package/dist/session/session.d.ts

@@ -56,7 +56,7 @@ export declare class ClientSession {
     viewsFor(target: PathLike, options?: SessionControlOptions): Promise<ViewCatalog>;
     dispatch(call: Call, options?: SessionRequestOptions): Promise<Result>;
     call(call: Call, options?: SessionRequestOptions): Promise<Input>;
-    invoke<const Reference extends CallableReference>(reference: Reference, input: InputOfReference<Reference>, options?: SessionRequestOptions): Promise<OutputOfReference<Reference>>;
+    invoke<const Reference extends CallableReference<unknown>>(reference: Reference, input: InputOfReference<Reference>, options?: SessionRequestOptions): Promise<OutputOfReference<Reference>>;
     stream(call: Call, options?: SessionRequestOptions): Promise<import("../client/result.js").Stream>;
     binary(call: Call, options?: SessionRequestOptions): Promise<import("@astrale-os/kernel-core/callable").BinaryOutput>;
     close(): void;

package/dist/session/session.js

@@ -119,11 +119,19 @@ export class ClientSession {
     async invoke(reference, input, options) {
         const admittedReference = admitReference(reference);
         const admittedOptions = admitRequestOptions(options);
-        const expected = Object.freeze({
-            origin: admittedReference.origin,
-            revision: admittedReference.revision,
-        });
-        const result = await this.dispatcher.dispatch({ target: admittedReference.target, input }, admittedOptions, this.operation(admittedOptions), expected);
+        const { anchor, steps } = admittedReference.target.ast;
+        const last = steps.at(-1);
+        const instance = last?.kind === 'method' && last.dispatch === 'instance'
+            ? Path.fromAST({ anchor, steps: steps.slice(0, -1) }).raw
+            : undefined;
+        const result = await this.dispatcher.dispatch({
+            target: Object.freeze({
+                callable: admittedReference.callable,
+                revision: admittedReference.revision,
+                ...(instance === undefined ? {} : { instance }),
+            }),
+            input,
+        }, admittedOptions, this.operation(admittedOptions));
         const narrowed = requireResultKind(admittedReference.outputMode, result);
         return (narrowed.kind === 'value'
             ? narrowed.value
@@ -163,7 +171,7 @@ export class ClientSession {
             origin: owner.origin,
             revision: owner.revision,
             callable: method.key,
-            target: Path.instanceMethod(Path.id(node.id), method.name),
+            target: Path.instanceMethod(Path.id(node.id), method.key),
             outputMode: method.output.mode,
         }, input);
     }

package/dist/session/session.typecheck.js

@@ -1,6 +1,7 @@
 import { NodeId } from '@astrale-os/kernel-core/graph/node';
 import { Path } from '@astrale-os/kernel-core/path';
-import { defineSchema, method, nodeClass, schema } from '@astrale-os/kernel-dsl/v1';
+import { K, KernelSchema } from '@astrale-os/kernel-core/schema';
+import { defineSchema, func, method, nodeClass, schema, valueSchema, } from '@astrale-os/kernel-dsl/v1';
 import { ClientSession, reference } from './index.js';
 void new ClientSession(options);
 void auth;
@@ -15,11 +16,64 @@ const dynamicInputIsClientInput = true;
 const dynamicOutputIsUnknown = true;
 void dynamicInputIsClientInput;
 void dynamicOutputIsUnknown;
+const renameInput = valueSchema()({
+    type: 'object',
+    properties: { name: { type: 'string' } },
+    required: ['name'],
+    additionalProperties: false,
+});
+const registrationInput = valueSchema()(K.functions.register.input);
+const booleanOutput = valueSchema()({ type: 'boolean' });
+const typedDomain = schema.resolve(defineSchema('client.input-witness.typecheck', {
+    dependencies: { kernel: KernelSchema },
+    functions: {
+        registerIdentity: func({
+            auth: 'authenticated',
+            input: registrationInput,
+            output: booleanOutput,
+        }),
+    },
+    classes: {
+        Person: nodeClass({
+            methods: {
+                rename: method({ auth: 'authenticated', input: renameInput, output: booleanOutput }),
+                registerIdentity: method({
+                    static: true,
+                    auth: 'authenticated',
+                    input: registrationInput,
+                    output: booleanOutput,
+                }),
+            },
+        }),
+    },
+}));
+const registerReference = reference(typedDomain, typedDomain.functions.registerIdentity);
+const staticRegisterReference = reference(typedDomain, typedDomain.classes.Person.static.methods.registerIdentity);
+const renameReference = reference(typedDomain, typedDomain.classes.Person.methods.rename)(Path.id(NodeId('person')));
+void session.invoke(registerReference, registration);
+void boundSession.invoke(staticRegisterReference, registration);
+void session.invoke(renameReference, renameRequest);
+const registerInputIsRequest = true;
+const renameInputIsInterface = true;
+const renameOutputIsBoolean = true;
+void registerInputIsRequest;
+void renameInputIsInterface;
+void renameOutputIsBoolean;
+// @ts-expect-error The exact Schema's required input fields are retained.
+void session.invoke(renameReference, {});
+// @ts-expect-error A Date is not the Schema's declared string input.
+void session.invoke(renameReference, { name: new Date() });
+// @ts-expect-error A function is not the Schema's declared string input.
+void session.invoke(renameReference, { name: () => 'Ada' });
+// @ts-expect-error RegisterRequest retains its nonempty identities tuple.
+void session.invoke(registerReference, { idempotencyKey: 'key', identities: [] });
+// @ts-expect-error An unknown-schema reference still accepts only portable Client Input.
+void session.invoke(dynamicReference, new Date());
 const abstractMethod = method({
     auth: 'authenticated',
     input: { type: 'null' },
     output: { type: 'null' },
-    inheritance: 'abstract',
+    abstract: true,
 });
 const abstractDomain = schema.resolve(defineSchema('client.reference.typecheck', {
     classes: {
@@ -28,3 +82,11 @@ const abstractDomain = schema.resolve(defineSchema('client.reference.typecheck',
 }));
 // @ts-expect-error Abstract Methods are declarations and cannot become Client references.
 reference(abstractDomain, abstractDomain.classes.AbstractItem.methods.abstractMethod);
+// @ts-expect-error Exact identity is derived internally, never supplied as a Session option.
+void session.invoke(dynamicReference, dynamicInput, { expect: undefined });
+// @ts-expect-error Raw Client options do not select a declaration.
+const unsupportedClientOptions = { expect: undefined };
+void unsupportedClientOptions;
+// @ts-expect-error Internal metadata dispatch is absent from the public package facade.
+import { dispatchTrace } from '../index.js';
+void dispatchTrace;

package/dist/transport/auto/fallback.d.ts

@@ -1,3 +1,4 @@
+import type { NodePath } from '@astrale-os/kernel-core/path';
 import type { RequestOptions, TransportRequest } from '../index.js';
 import { TransportError } from '../../errors/index.js';
 /** One invocation-owned total timeout budget shared by selection and fallback. */
@@ -13,4 +14,4 @@ export declare class InvocationBudget {
     private remaining;
 }
 export declare function mayFallback(error: unknown): error is TransportError;
-export declare function warningTarget(input: TransportRequest): TransportRequest['call']['target'];
+export declare function warningTarget(input: TransportRequest): NodePath;

package/dist/transport/auto/fallback.js

@@ -1,3 +1,4 @@
+import { targetPath } from '@astrale-os/kernel-core/callable';
 import { TransportError } from '../../errors/index.js';
 import { invocationFailure } from '../failure.js';
 import { positiveInteger } from '../index.js';
@@ -66,7 +67,7 @@ export function mayFallback(error) {
         error.phase !== 'timeout');
 }
 export function warningTarget(input) {
-    return input.call.target;
+    return targetPath(input.call.target);
 }
 function abortReason(signal) {
     return signal.reason instanceof Error

package/dist/transport/http/transport.js

@@ -330,7 +330,6 @@ const RESERVED_REQUEST_HEADERS = new Set([
     'content-length',
     'content-type',
     'cookie',
-    'expect',
     'forwarded',
     'host',
     'keep-alive',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-client",
-  "version": "0.6.0-beta.56",
+  "version": "0.6.0-beta.58",
   "description": "Universal Client — protocol-first, transport-agnostic",
   "keywords": [
     "astrale",
@@ -65,14 +65,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-core": "0.9.0-beta.43",
-    "@astrale-os/kernel-dsl": "0.2.0-beta.31",
-    "@astrale-os/kernel-protocol": "0.5.0-beta.47",
+    "@astrale-os/kernel-core": "0.9.0-beta.45",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.33",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.49",
     "@tanstack/pacer": "0.20.1",
     "msgpackr": "^2.0.5"
   },
   "devDependencies": {
-    "@astrale-os/kernel-server": "0.5.0-beta.49",
+    "@astrale-os/kernel-server": "0.5.0-beta.51",
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",
     "@types/node": "^22.0.0",
     "typescript": "7.0.2",

package/dist/session/routing/expectation.d.ts

@@ -1,6 +0,0 @@
-import type { Key, Revision } from '@astrale-os/kernel-dsl/v1';
-/** Private static-consumer expectation carried only by ClientSession.invoke. */
-export interface SchemaExpectation {
-    readonly origin: Key.Origin;
-    readonly revision: Revision;
-}

package/dist/session/routing/expectation.js

@@ -1 +0,0 @@
-export {};