@astrale-os/kernel-client 0.6.0-beta.57 → 0.6.0-beta.59

package/dist/auth/auth.d.ts

@@ -3,7 +3,7 @@ import type { PathLike } from '@astrale-os/kernel-core/path';
 import type { Input } from '../client/index.js';
 import type { RequestOptions } from '../transport/index.js';
 import type { PolicyDecisionInput } from './authorization.js';
-import type { DelegateOptions, MintOptions } from './credential.js';
+import type { DelegateOptions, MintOptions, ImpersonateOptions } from './credential.js';
 import type { WhoisInput } from './identity.js';
 import type { RegisterRequest } from './register.js';
 export type AuthCall = (target: PathLike, input: Input, options?: RequestOptions) => Promise<Input>;
@@ -12,6 +12,7 @@ export interface AuthApi {
     whoami(options?: RequestOptions): Promise<Identity & Authentication>;
     whois(input: WhoisInput, options?: RequestOptions): Promise<(Identity & Authentication) | null>;
     can(input: PolicyDecisionInput, options?: RequestOptions): Promise<boolean>;
+    impersonate(input: ImpersonateOptions, options?: RequestOptions): Promise<MintedCredential>;
     mint(input: MintOptions, options?: RequestOptions): Promise<MintedCredential>;
     delegate(identity: IdentityId, input: DelegateOptions, options?: RequestOptions): Promise<MintedCredential>;
 }

package/dist/auth/credential.d.ts

@@ -7,13 +7,18 @@ export interface MintOptions {
     readonly ttlSeconds: number;
     readonly grant?: UnresolvedGrant;
 }
+export interface ImpersonateOptions extends MintOptions {
+    readonly identity: IdentityId;
+}
 export interface DelegateOptions {
     readonly audience: string;
     readonly ttlSeconds: number;
     readonly attenuation: UnresolvedIdentityExpr;
 }
+export declare const IDENTITY_IMPERSONATE_PATH: NodePath;
 export declare const IDENTITY_MINT_PATH: NodePath;
 export declare function credentialApi(call: AuthCall): Readonly<{
+    impersonate(input: ImpersonateOptions, options?: RequestOptions): Promise<MintedCredential>;
     mint(input: MintOptions, options?: RequestOptions): Promise<MintedCredential>;
     delegate(principal: IdentityId, input: DelegateOptions, options?: RequestOptions): Promise<MintedCredential>;
 }>;

package/dist/auth/credential.js

@@ -1,9 +1,13 @@
 import { Path } from '@astrale-os/kernel-core/path';
 import { identity } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
 const identityOwner = Path.project(identity.whoami.owner);
+export const IDENTITY_IMPERSONATE_PATH = Path.staticMethod(identityOwner, identity.impersonate.name).raw;
 export const IDENTITY_MINT_PATH = Path.staticMethod(identityOwner, identity.mint.name).raw;
 export function credentialApi(call) {
     return Object.freeze({
+        async impersonate(input, options) {
+            return credential(await call(IDENTITY_IMPERSONATE_PATH, input, options));
+        },
         async mint(input, options) {
             return credential(await call(IDENTITY_MINT_PATH, input, options));
         },

package/dist/auth/index.d.ts

@@ -1,6 +1,6 @@
 export { createAuth, type AuthApi, type AuthCall } from './auth.js';
 export { IDENTITY_CAN_PATH, type PolicyDecisionInput } from './authorization.js';
-export { IDENTITY_MINT_PATH, type DelegateOptions, type MintOptions } from './credential.js';
+export { IDENTITY_MINT_PATH, IDENTITY_IMPERSONATE_PATH, type DelegateOptions, type MintOptions, type ImpersonateOptions, } from './credential.js';
 export { IDENTITY_WHOAMI_PATH, IDENTITY_WHOIS_PATH, type WhoisInput } from './identity.js';
 export { IDENTITY_REGISTER_PATH, type RegisterIdentity, type RegisterRequest } from './register.js';
 export type { Identity, IdentityId, Subject, IssuerId, MintedCredential, RegisterResult, UnresolvedGrant, UnresolvedIdentityExpr, } from '@astrale-os/kernel-core/auth';

package/dist/auth/index.js

@@ -1,5 +1,5 @@
 export { createAuth } from './auth.js';
 export { IDENTITY_CAN_PATH } from './authorization.js';
-export { IDENTITY_MINT_PATH } from './credential.js';
+export { IDENTITY_MINT_PATH, IDENTITY_IMPERSONATE_PATH, } from './credential.js';
 export { IDENTITY_WHOAMI_PATH, IDENTITY_WHOIS_PATH } from './identity.js';
 export { IDENTITY_REGISTER_PATH } from './register.js';

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/graph/domain/project.js

@@ -47,7 +47,7 @@ function propertyAccessor(selected, props) {
 function methodAccessor(selected, node, call) {
     return (input) => {
         const method = resolveMethod(selected, input);
-        if (method.abstract === true) {
+        if (!method.executable) {
             throw new TypeError(`Abstract Method ${method.key} cannot be invoked.`);
         }
         return (value) => call(node, method, value);
@@ -104,7 +104,7 @@ function installPropertyShortcuts(target, selected, props, reserved) {
 }
 function installMethodShortcuts(target, selected, node, call, reserved) {
     for (const member of selected.methods) {
-        if (member.abstract === true || 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/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, 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,22 +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 ExecutableStaticMethod = ResolvedMethod<unknown, unknown, true, false>;
-type ExecutableInstanceMethod = ResolvedMethod<unknown, unknown, false, false>;
+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

@@ -3,7 +3,7 @@ import { callableAddress, Key, patterns, } from '@astrale-os/kernel-dsl/v1/addre
 export function reference(domain, callable) {
     if (Key.origin(callable.key) !== domain.origin)
         invalid();
-    if ('owner' in callable && callable.abstract === true)
+    if ('owner' in callable && !callable.executable)
         invalid();
     const common = Object.freeze({
         origin: domain.origin,

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

@@ -1,10 +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 { SessionEnvelopeTransport, SessionRequestOptions } from './request.js';
+import { acceptCall } from '../../client/index.js';
 export interface SessionDispatcherOptions {
     readonly kernel: IssuerId;
     readonly sourceEndpoint: string;
@@ -19,7 +20,7 @@ export interface SessionDispatcherOptions {
 export declare class SessionDispatcher {
     private readonly state;
     constructor(state: SessionDispatcherOptions);
-    dispatch(input: Call, options: SessionRequestOptions, operation: SessionOperation): Promise<Result>;
+    dispatch(input: Parameters<typeof acceptCall>[0], options: SessionRequestOptions, operation: SessionOperation): Promise<Result>;
     private dispatchSource;
     private followSource;
     private dispatchDestinationWithRecovery;

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.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,6 +16,59 @@ 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' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-client",
-  "version": "0.6.0-beta.57",
+  "version": "0.6.0-beta.59",
   "description": "Universal Client — protocol-first, transport-agnostic",
   "keywords": [
     "astrale",
@@ -65,14 +65,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-core": "0.9.0-beta.44",
-    "@astrale-os/kernel-dsl": "0.2.0-beta.32",
-    "@astrale-os/kernel-protocol": "0.5.0-beta.48",
+    "@astrale-os/kernel-core": "0.9.0-beta.46",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.33",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.50",
     "@tanstack/pacer": "0.20.1",
     "msgpackr": "^2.0.5"
   },
   "devDependencies": {
-    "@astrale-os/kernel-server": "0.5.0-beta.50",
+    "@astrale-os/kernel-server": "0.5.0-beta.52",
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",
     "@types/node": "^22.0.0",
     "typescript": "7.0.2",