@astrale-os/kernel-client 0.6.0-beta.40 → 0.6.0-beta.42

package/dist/schema/index.d.ts

@@ -1,3 +1,3 @@
-export { createSchema, type SchemaApi, type SchemaCall, type SchemaOptions, type DomainBundle, type DomainInfo, type InstallResult, } from './schema.js';
+export { createSchema, DEFAULT_SCHEMA_LIFECYCLE_TIMEOUT_MS, type SchemaApi, type SchemaCall, type SchemaOptions, type DomainBundle, type DomainInfo, type InstallResult, } from './schema.js';
 export { acceptOperationId, createOperationId } from './operation.js';
 export type { DomainRequest, InstallReceipt, InstallRequest, OperationId, UninstallReceipt, UninstallRequest, } from './contracts.js';

package/dist/schema/index.js

@@ -1,2 +1,2 @@
-export { createSchema, } from './schema.js';
+export { createSchema, DEFAULT_SCHEMA_LIFECYCLE_TIMEOUT_MS, } from './schema.js';
 export { acceptOperationId, createOperationId } from './operation.js';

package/dist/schema/operation.js

@@ -5,5 +5,5 @@ export function acceptOperationId(input) {
 }
 /** Allocate one cryptographically generated operation identity for a new lifecycle request. */
 export function createOperationId() {
-    return acceptOperationId(globalThis.crypto.randomUUID());
+    return acceptOperationId(crypto.randomUUID());
 }

package/dist/schema/schema.d.ts

@@ -5,6 +5,7 @@ import type { RequestOptions } from '../transport/index.js';
 import type { InstallRequest, UninstallReceipt, UninstallRequest } from './contracts.js';
 export type SchemaCall = (call: Call, options?: RequestOptions) => Promise<Result>;
 export interface SchemaOptions extends protocolSchema.installation.introspection.Limits {
+    readonly lifecycleTimeoutMs?: number;
 }
 export type DomainInfo = protocolSchema.installation.introspection.DomainInfo;
 export type DomainBundle = protocolSchema.installation.introspection.DomainBundle;
@@ -15,5 +16,6 @@ export interface SchemaApi {
     inspect(origin: Key.Origin, options?: RequestOptions): Promise<DomainInfo>;
     bundle(origin: Key.Origin, options?: RequestOptions): Promise<DomainBundle>;
 }
+export declare const DEFAULT_SCHEMA_LIFECYCLE_TIMEOUT_MS = 110000;
 /** Bind the canonical Schema lifecycle syscalls to one caller-scoped value-call capability. */
 export declare function createSchema(call: SchemaCall, limits: SchemaOptions): SchemaApi;

package/dist/schema/schema.js

@@ -7,6 +7,7 @@ import { acceptOutput } from './admission.js';
 import { introspect } from './introspection.js';
 const INSTALL_PATH = Path.project(install).raw;
 const UNINSTALL_PATH = Path.project(uninstall).raw;
+export const DEFAULT_SCHEMA_LIFECYCLE_TIMEOUT_MS = 110_000;
 /** Bind the canonical Schema lifecycle syscalls to one caller-scoped value-call capability. */
 export function createSchema(call, limits) {
     if (typeof call !== 'function')
@@ -14,7 +15,7 @@ export function createSchema(call, limits) {
     const admittedLimits = admitLimits(limits);
     return Object.freeze({
         async install(request, options) {
-            const result = await call(invocation(INSTALL_PATH, request), options);
+            const result = await call(invocation(INSTALL_PATH, request), lifecycleOptions(options, admittedLimits.lifecycleTimeoutMs));
             if (result.kind !== 'binary') {
                 throw new TypeError('Schema install returned a non-binary result.');
             }
@@ -30,7 +31,7 @@ export function createSchema(call, limits) {
             return decoded;
         },
         async uninstall(request, options) {
-            const output = value(await call(invocation(UNINSTALL_PATH, request), options));
+            const output = value(await call(invocation(UNINSTALL_PATH, request), lifecycleOptions(options, admittedLimits.lifecycleTimeoutMs)));
             return acceptOutput(uninstallOutput, output);
         },
         async inspect(origin, options) {
@@ -68,13 +69,22 @@ function value(result) {
     return result.value;
 }
 function admitLimits(input) {
+    const lifecycleTimeoutMs = input?.lifecycleTimeoutMs ?? DEFAULT_SCHEMA_LIFECYCLE_TIMEOUT_MS;
     if (input === null ||
         typeof input !== 'object' ||
         !Number.isSafeInteger(input.maximumPublicationBytes) ||
         input.maximumPublicationBytes < 1 ||
         !Number.isSafeInteger(input.maximumBundleBytes) ||
-        input.maximumBundleBytes < 1) {
+        input.maximumBundleBytes < 1 ||
+        !Number.isSafeInteger(lifecycleTimeoutMs) ||
+        lifecycleTimeoutMs < 1 ||
+        lifecycleTimeoutMs > 2_147_483_647) {
         throw new TypeError('Schema introspection limits are invalid.');
     }
-    return Object.freeze({ ...input });
+    return Object.freeze({ ...input, lifecycleTimeoutMs });
+}
+function lifecycleOptions(options, timeoutMs) {
+    if (options?.timeoutMs !== undefined)
+        return options;
+    return Object.freeze({ ...options, timeoutMs });
 }

package/dist/session/routing/cache.js

@@ -228,12 +228,13 @@ function refreshBoundary(credentialExpiry) {
         : credentialExpiry - DESTINATION_CREDENTIAL_REFRESH_SKEW_MS;
 }
 async function routeIntegrity(sourceCredential, key, learned) {
-    if (globalThis.crypto?.subtle === undefined) {
+    const webCrypto = typeof crypto === 'undefined' ? undefined : crypto;
+    if (webCrypto?.subtle === undefined) {
         throw new TypeError('Persistent Session route integrity requires Web Crypto HMAC support.');
     }
     const algorithm = Object.freeze({ name: 'HMAC', hash: 'SHA-256' });
-    const cryptographicKey = await globalThis.crypto.subtle.importKey('raw', new TextEncoder().encode(sourceCredential), algorithm, false, ['sign']);
-    const signature = await globalThis.crypto.subtle.sign(algorithm, cryptographicKey, new TextEncoder().encode(integrityMaterial(key, learned)));
+    const cryptographicKey = await webCrypto.subtle.importKey('raw', new TextEncoder().encode(sourceCredential), algorithm, false, ['sign']);
+    const signature = await webCrypto.subtle.sign(algorithm, cryptographicKey, new TextEncoder().encode(integrityMaterial(key, learned)));
     return encodeBase64Url(new Uint8Array(signature));
 }
 async function matchesIntegrity(sourceCredential, key, learned, expected) {
@@ -281,10 +282,11 @@ function canonicalExpr(input) {
     return { kind: input.kind, operands: input.operands.map(canonicalExpr) };
 }
 async function digestText(input) {
-    if (globalThis.crypto?.subtle === undefined) {
+    const webCrypto = typeof crypto === 'undefined' ? undefined : crypto;
+    if (webCrypto?.subtle === undefined) {
         throw new TypeError('Session route caching requires Web Crypto SHA-256 support.');
     }
-    const bytes = await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(input));
+    const bytes = await webCrypto.subtle.digest('SHA-256', new TextEncoder().encode(input));
     return [...new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, '0')).join('');
 }
 function jwtExpiry(input) {

package/dist/session/session.d.ts

@@ -30,6 +30,7 @@ export interface ClientSessionOptions {
     readonly maximumBundleBytes?: number;
     readonly maximumResponseBytes?: number;
     readonly timeoutMs?: number;
+    readonly schemaLifecycleTimeoutMs?: number;
 }
 export type ConnectOptions = Omit<ClientSessionOptions, 'kernel' | 'policy'> & {
     readonly url: string;

package/dist/session/session.js

@@ -4,7 +4,7 @@ import { SessionError } from '../errors/index.js';
 import { createDomainBinding } from '../graph/domain/binding.js';
 import { createGraph } from '../graph/index.js';
 import { ClientPool } from '../pool/index.js';
-import { createSchema } from '../schema/index.js';
+import { createSchema, DEFAULT_SCHEMA_LIFECYCLE_TIMEOUT_MS } from '../schema/index.js';
 import { AutoTransport } from '../transport/auto/index.js';
 import { HttpTransport } from '../transport/http/index.js';
 import { WebSocketTransport } from '../transport/websocket/index.js';
@@ -46,11 +46,12 @@ export class ClientSession {
         const maximumBundleBytes = positive(options.maximumBundleBytes ?? DEFAULT_MAXIMUM_BUNDLE_BYTES, 'maximumBundleBytes');
         const maximumResponseBytes = positive(options.maximumResponseBytes ?? DEFAULT_MAXIMUM_RESPONSE_BYTES, 'maximumResponseBytes');
         const timeoutMs = platformDuration(options.timeoutMs ?? DEFAULT_TIMEOUT_MS, 'timeoutMs');
+        const schemaLifecycleTimeoutMs = platformDuration(options.schemaLifecycleTimeoutMs ?? DEFAULT_SCHEMA_LIFECYCLE_TIMEOUT_MS, 'schemaLifecycleTimeoutMs');
         this.timeoutMs = timeoutMs;
         const websocketAvailable = options.client !== undefined ||
             options.pool !== undefined ||
             options.websocket !== undefined ||
-            typeof globalThis.WebSocket === 'function';
+            typeof WebSocket === 'function';
         const client = options.client ??
             defaultClientFactory({
                 fetch: fetchImpl,
@@ -92,6 +93,7 @@ export class ClientSession {
         this.schema = createSchema((request, options) => this.dispatch(request, options), {
             maximumPublicationBytes,
             maximumBundleBytes,
+            lifecycleTimeoutMs: schemaLifecycleTimeoutMs,
         });
         this.graph = createGraph((call, options) => this.call(call, options));
     }

package/dist/session/session.typecheck.js

@@ -28,4 +28,3 @@ 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);
-void {};

package/dist/store/store.typecheck.js

@@ -13,9 +13,6 @@ const edgeProjection = edgeSource.select({
 const read = store.read(nodeGraph, options);
 const peek = store.peek(nodeProjection, options);
 const snapshot = store.getSnapshot(edgeProjection, options);
-// @ts-expect-error ready is the successful local snapshot state; fresh is retired.
-const retiredFreshSnapshot = { state: 'fresh' };
-void retiredFreshSnapshot;
 store.subscribe(nodeGraph, () => undefined, options);
 store.observe(nodeProjection, (value) => {
     if ('response' in value && value.response !== undefined) {
@@ -35,6 +32,4 @@ store.subscribe(nodeGraph, () => undefined);
 store.getSnapshot(nodeGraph);
 // @ts-expect-error Query-page identity is required for observations.
 store.observe(nodeGraph, () => undefined);
-// @ts-expect-error watch is reserved for a future remote-liveness protocol.
-store.watch(nodeGraph, () => undefined, options);
 void {};

package/dist/transport/auto/warning.js

@@ -9,8 +9,11 @@ export function emitWarning(warning, observer) {
     try {
         if (observer)
             observer(warning);
-        else
-            globalThis.console?.warn(formatClientWarning(warning));
+        else {
+            const runtimeConsole = globalThis
+                .console;
+            runtimeConsole?.warn(formatClientWarning(warning));
+        }
     }
     catch {
         // Warning observation cannot change invocation settlement.

package/dist/transport/http/transport.js

@@ -141,7 +141,7 @@ export class HttpTransport {
         }
     }
     async fetchResponse(codec, encoded, trace, control) {
-        return this.fetchImpl(this.url, {
+        const init = {
             method: 'POST',
             redirect: 'manual',
             credentials: 'omit',
@@ -155,7 +155,8 @@ export class HttpTransport {
             },
             body: toBody(encoded),
             signal: control.signal,
-        });
+        };
+        return this.fetchImpl(this.url, init);
     }
     async decodeBinary(response, requestId, binaryId, streaming, control) {
         if (binaryId !== String(requestId)) {

package/dist/transport/websocket/connection.js

@@ -81,7 +81,7 @@ export class WebSocketConnection {
             control.close();
             return Promise.reject(invocationFailure(`WebSocket request exceeds maximumRequestBytes (${this.maximumRequestBytes}).`, 'send'));
         }
-        if (this.socket.bufferedAmount + encodedBytes > this.maximumBufferedBytes) {
+        if (socketBufferedAmount(this.socket) + encodedBytes > this.maximumBufferedBytes) {
             control.close();
             return Promise.reject(invocationFailure(`WebSocket connection exceeds maximumBufferedBytes (${this.maximumBufferedBytes}).`, 'send'));
         }
@@ -105,7 +105,7 @@ export class WebSocketConnection {
             const encoded = this.codec.encode(protocol.decodeCancelRequest({ version: protocol.VERSION, kind: 'cancel', requestId }));
             const bytes = frameSize(encoded);
             if (bytes > this.maximumRequestBytes ||
-                this.socket.bufferedAmount + bytes > this.maximumBufferedBytes) {
+                socketBufferedAmount(this.socket) + bytes > this.maximumBufferedBytes) {
                 throw new WebSocketBindingFailure('WebSocket cancellation exceeds the connection send policy.', 1008, 'Client send policy exceeded');
             }
             this.socket.send(socketData(encoded));
@@ -180,6 +180,9 @@ export class WebSocketConnection {
         this.shutdown(invocationFailure(message, this.opened ? 'receive' : 'connect'));
     }
 }
+function socketBufferedAmount(socket) {
+    return socket.bufferedAmount ?? 0;
+}
 async function normalizeFrame(input) {
     if (typeof input === 'string')
         return input;

package/dist/transport/websocket/transport.js

@@ -140,7 +140,7 @@ function admitCodecName(input) {
     throw new TypeError('codec must be "json" or "msgpack".');
 }
 function admitWebSocket(input) {
-    const implementation = input ?? globalThis.WebSocket;
+    const implementation = input ?? (typeof WebSocket === 'undefined' ? undefined : WebSocket);
     if (typeof implementation !== 'function') {
         throw new TypeError('WebSocketTransport requires a WebSocket implementation.');
     }

package/package.json

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