@astrale-os/kernel-client 0.6.0-beta.72 → 0.6.0-beta.75

package/dist/session/session.js

@@ -14,6 +14,7 @@ import { admitFunction } from './admission.js';
 import { createContentApi } from './content.js';
 import { admitControlOptions, admitPolicy, createSessionOperation, DEFAULT_MAXIMUM_BUNDLE_BYTES, DEFAULT_MAXIMUM_PUBLICATION_BYTES, DEFAULT_MAXIMUM_RESPONSE_BYTES, DEFAULT_TIMEOUT_MS, admitKernel, allowEndpoint, kernelInvocationEndpoint, platformDuration, positive, } from './context/index.js';
 import { createSessionDiscovery } from './discovery/index.js';
+import { acquireDomainCredential, admitExchangeOptions, admitExchangeRequest, createSessionExchange, } from './exchange/index.js';
 import { admitReference } from './reference.js';
 import { admitEnvelopeTransport, admitInvocationOptions, admitSessionAuth, requireResultKind, RouteCache, SessionDispatcher, } from './routing/index.js';
 import { resolveViewsFor, targetViewCatalog } from './views/index.js';
@@ -31,6 +32,8 @@ export class ClientSession {
     lifecycle = new AbortController();
     timeoutMs;
     routes;
+    exchangeDependencies;
+    callExchange;
     admitTargetViews;
     closed = false;
     constructor(options) {
@@ -86,24 +89,31 @@ export class ClientSession {
         });
         this.routes = new RouteCache(policy.maximumRouteAgeMs, undefined, options.routeStore);
         const auth = admitSessionAuth(options.auth);
-        const admission = {
+        const exchange = admitExchangeOptions(options.exchange, auth);
+        this.exchangeDependencies = Object.freeze({
             kernel: this.kernel,
-            auth,
             source: () => {
                 allowEndpoint(sourceEndpoint, policy);
                 return pool.clientFor({ transport: 'http', url: sourceEndpoint });
             },
+            ...(auth === undefined ? {} : { auth }),
             fetch: fetchImpl,
             policy,
             limits: { maximumPublicationBytes, maximumBundleBytes },
             maximumResponseBytes,
-        };
+            operation: (signal) => this.operation(signal === undefined ? undefined : { signal }),
+        });
+        this.callExchange =
+            exchange === undefined || auth === undefined
+                ? undefined
+                : createSessionExchange({ ...this.exchangeDependencies, auth }, exchange);
         this.dispatcher = new SessionDispatcher({
             kernel: this.kernel,
             sourceEndpoint,
             pool,
             websocketAvailable,
             auth,
+            ...(this.callExchange === undefined ? {} : { exchange: this.callExchange }),
             cache: this.routes,
             policy,
             envelopeTransport: admitEnvelopeTransport(options.envelopeTransport ?? 'http'),
@@ -127,13 +137,22 @@ export class ClientSession {
         this.graph = createGraph((call, options) => this.call(call, options));
         this.auth = createAuth((target, input, options) => this.call({ target, input }, options), (call, options) => {
             const operation = this.operation(admitControlOptions(options));
-            return admitFunction(admission, acceptCall(call), options, operation);
+            return admitFunction(this.exchangeDependencies, acceptCall(call), options, operation);
         });
     }
     /** Bind one admitted DSL Domain to authenticated graph projection and Method dispatch. */
     bind(domain) {
         return createDomainBinding(domain, this.graph, (node, method, input) => this.invokeDomainMethod(domain, node, method, input));
     }
+    /**
+     * Delegate this Session's caller to one Domain issuer and exchange that delegation for the
+     * Domain's credential to this Kernel. Nothing is cached: hold the result, for example through
+     * `createSessionCredentialProvider`, for as long as it covers the calls it carries.
+     */
+    async exchange(domain, options) {
+        const request = admitExchangeRequest(domain, options);
+        return acquireDomainCredential(this.exchangeDependencies, request, this.operation(request.control));
+    }
     /** Revalidate the intrinsic Publication without acquiring its bundle or Views. */
     publication(options) {
         return this.discovery.publication(this.operation(admitControlOptions(options)));
@@ -208,6 +227,7 @@ export class ClientSession {
         this.ownedPool?.close();
         this.routes.clear();
         this.discovery.clear();
+        this.callExchange?.clear();
     }
     requireOpen() {
         if (this.closed)

package/dist/session/session.typecheck.js

@@ -4,7 +4,7 @@ import { K, KernelSchema } from '@astrale-os/kernel-core/schema';
 import { defineSchema, func, method, nodeClass, schema, valueSchema, } from '@astrale-os/kernel-dsl/v1';
 import { isBinaryInput } from '@astrale-os/kernel-dsl/v1/language';
 import { call } from '../client/index.js';
-import { ClientSession, createSessionCredentialProvider, reference } from './index.js';
+import { ClientSession, createSessionCredentialProvider, execution, reference } from './index.js';
 void new ClientSession(options);
 void auth;
 void control;
@@ -136,6 +136,37 @@ const abstractDomain = schema.resolve(defineSchema('client.reference.typecheck',
         AbstractItem: nodeClass({ abstract: true, methods: { abstractMethod } }),
     },
 }));
+const reminderOutput = valueSchema()({
+    type: 'object',
+    properties: { reminder: { type: 'string' } },
+    required: ['reminder'],
+    additionalProperties: false,
+});
+const durableDomain = schema.resolve(defineSchema('client.durable.typecheck', {
+    classes: {
+        Invoice: nodeClass({
+            methods: {
+                remind: method({
+                    auth: 'authenticated',
+                    input: renameInput,
+                    output: reminderOutput,
+                    execution: { durable: true },
+                }),
+            },
+        }),
+    },
+}));
+const remindReference = reference(durableDomain, durableDomain.classes.Invoice.methods.remind)(Path.id(NodeId('invoice-1')));
+const durableReturnsExecution = true;
+const outcomeIsTyped = true;
+const statusIsTyped = true;
+void session.invoke(execution.result(run), { waitMs: 1_000 });
+void session.invoke(execution.signal(run), { name: 'approval', value: { by: 'billing' } });
+// @ts-expect-error Force is the only cancellation option.
+void session.invoke(execution.cancel(run), { waitMs: 1_000 });
+void durableReturnsExecution;
+void outcomeIsTyped;
+void statusIsTyped;
 // @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.

package/dist/transport/http/transport.js

@@ -163,7 +163,6 @@ export class HttpTransport {
             method: 'POST',
             redirect: 'manual',
             credentials: 'omit',
-            cache: 'no-store',
             referrerPolicy: 'no-referrer',
             // Fetch owns Content-Length; the protocol carries Blob.size across Fetch runtimes.
             headers: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-client",
-  "version": "0.6.0-beta.72",
+  "version": "0.6.0-beta.75",
   "description": "Universal Client — protocol-first, transport-agnostic",
   "keywords": [
     "astrale",
@@ -65,14 +65,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-core": "0.9.0-beta.55",
-    "@astrale-os/kernel-dsl": "0.2.0-beta.40",
-    "@astrale-os/kernel-protocol": "0.5.0-beta.61",
+    "@astrale-os/kernel-core": "0.9.0-beta.56",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.41",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.62",
     "@tanstack/pacer": "0.20.1",
     "msgpackr": "^2.0.5"
   },
   "devDependencies": {
-    "@astrale-os/kernel-server": "0.5.0-beta.63",
+    "@astrale-os/kernel-server": "0.5.0-beta.64",
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",
     "@types/node": "^22.0.0",
     "typescript": "7.0.2",