@astrale-os/kernel-client 0.5.1 → 0.6.0-beta.1

package/dist/session/client-session.js

@@ -1,673 +0,0 @@
-import { SELF_DELEGATION } from '../auth/defaults.js';
-import { KernelClient as KernelClientImpl } from '../client/client.js';
-import { withDetails } from '../errors/errors.js';
-import { PoolClosedError } from '../pool/errors.js';
-import { ClientPool as ClientPoolImpl } from '../pool/pool.js';
-import { SchemaRegistry } from '../schema/registry.js';
-import { createSchemaClient } from '../schema/typed-client.js';
-import { createBoundSessionView } from './bound.js';
-import { DelegationCache as DelegationCacheImpl, delegationCacheKey } from './delegation/cache.js';
-import { DelegationPolicyError, DelegationRefusedError } from './delegation/errors.js';
-import { allowAllDelegations } from './delegation/policy.js';
-import { DispatchRouteCache } from './dispatch-routes.js';
-import { IdentityPickerError, PersistenceLoadFailedError, RegistryWriteFailedError, SchemaOwnershipConflictError, UnresolvedIdentityError, } from './errors/session-errors.js';
-import { forwardedFor } from './forward.js';
-import { classifyError, freezeHops, generateCid, unwrapResult } from './helpers.js';
-import { HopLimitExceededError, RedirectPolicyError, RedirectRefusedError, } from './redirect/errors.js';
-import { allowAllPolicy } from './redirect/policy.js';
-const DEFAULT_MAX_HOPS = 1;
-/**
- * ClientSession — the orchestration layer above `KernelClient`.
- *
- * Composes `ClientPool`, `DelegationCache`, `DelegationPolicy`,
- * `RedirectPolicy`, and `SchemaPersistence` into a single call
- * surface. See `docs/specs/kernel-client-session.md`.
- */
-export class ClientSession {
-    default;
-    registry;
-    #pool;
-    #delegation;
-    #delegationPolicy;
-    #redirect;
-    #identity;
-    #hooks;
-    #logger;
-    #schemaStore;
-    #ownsRegistry;
-    #ownsPool;
-    #maxHops;
-    #routes;
-    #closed = false;
-    #constructionReady = null;
-    #pendingMints = new Map();
-    #mintInvocations = new Map();
-    constructor(config) {
-        if (!config.default)
-            throw new Error('ClientSessionConfig.default is required');
-        this.default = config.default;
-        this.#identity = config.identity;
-        this.#hooks = config.hooks ?? {};
-        this.#logger = config.logger ?? console;
-        this.#maxHops = config.maxHops ?? DEFAULT_MAX_HOPS;
-        this.#routes =
-            config.routes instanceof DispatchRouteCache
-                ? config.routes
-                : new DispatchRouteCache(config.routes);
-        const schemaStore = config.schemaStore;
-        this.#schemaStore = schemaStore;
-        const schema = config.schema;
-        if (SchemaRegistry.is(schema)) {
-            if (schemaStore)
-                throw new SchemaOwnershipConflictError();
-            this.registry = schema;
-            this.#ownsRegistry = false;
-        }
-        else {
-            this.registry = new SchemaRegistry();
-            this.#ownsRegistry = true;
-            if (Array.isArray(schema) && schema.length > 0)
-                this.registry.load(schema);
-        }
-        this.#redirect = config.redirect ?? allowAllPolicy();
-        // Wrap caller-provided cache config so ClientSession can fire `onDelegationMint`
-        // with waiter cids. Pre-constructed caches pass through — caller owns the
-        // mint and ClientSession doesn't intercept.
-        if (config.delegation) {
-            if (config.delegation instanceof DelegationCacheImpl) {
-                this.#delegation = config.delegation;
-            }
-            else {
-                const userConfig = config.delegation;
-                this.#delegation = new DelegationCacheImpl({
-                    ...userConfig,
-                    mint: this.wrapMint(userConfig.mint, userConfig.ttl ?? 300),
-                });
-            }
-        }
-        this.#delegationPolicy =
-            config.delegationPolicy ?? allowAllDelegations({ default: this.default });
-        // Externally-constructed pools are caller-owned and survive disconnect();
-        // ClientSession only tears down pools it constructed itself.
-        if (config.pool instanceof ClientPoolImpl) {
-            this.#pool = config.pool;
-            this.#ownsPool = false;
-        }
-        else if (config.pool) {
-            this.#pool = new ClientPoolImpl(config.pool);
-            this.#ownsPool = true;
-        }
-        else {
-            const registry = this.registry;
-            this.#pool = new ClientPoolImpl({
-                clientFactory: (url) => new KernelClientImpl({
-                    url,
-                    schema: registry,
-                    hooks: undefined,
-                    fetch: config.fetch,
-                }),
-            });
-            this.#ownsPool = true;
-        }
-        if (this.#schemaStore && this.#ownsRegistry) {
-            this.#constructionReady = this.hydrate(config.schema);
-        }
-    }
-    /**
-     * Idempotent teardown. Tears down the pool (and every cached client).
-     * Registry, schema store, and delegation cache are untouched — they may
-     * be shared across ClientSessions.
-     */
-    disconnect() {
-        if (this.#closed)
-            return;
-        this.#closed = true;
-        if (this.#ownsPool)
-            this.#pool.disconnect();
-    }
-    get pool() {
-        return this.#pool;
-    }
-    get delegation() {
-        return this.#delegation;
-    }
-    describe(method) {
-        return this.registry.resolve(method);
-    }
-    /**
-     * Await schema-persistence hydration. Every dispatch primitive awaits this
-     * implicitly; consumers can await it explicitly to front-load load failures.
-     */
-    async ready() {
-        if (this.#constructionReady)
-            await this.#constructionReady;
-    }
-    // ─── Dispatch primitives ───────────────────────────────────────────────────
-    async call(method, params, opts) {
-        return this.dispatch('call', method, params, opts);
-    }
-    async stream(method, params, opts) {
-        return this.dispatch('stream', method, params, opts);
-    }
-    async binary(method, params, opts) {
-        return this.dispatch('binary', method, params, opts);
-    }
-    signal(method, params, opts) {
-        if (this.#closed)
-            throw new PoolClosedError();
-        // Fire-and-forget: background task runs the same pre-dispatch delegation
-        // logic as `call`; errors surface via `onError`.
-        const initialTarget = opts?.url ?? this.default;
-        const cid = opts?.correlationId ?? generateCid();
-        void this.runSignal(method, params, opts, cid).catch((err) => {
-            const context = classifyError(err);
-            void this.fireError(err, method, params, (opts?.credential ?? ''), initialTarget, cid, opts?.maxHops ?? this.#maxHops, [{ url: initialTarget, at: Date.now() }], context);
-        });
-    }
-    // ─── Bound view + schema proxy ────────────────────────────────────────────
-    as(credential, opts) {
-        return createBoundSessionView(this, credential, opts);
-    }
-    withSchema(schema) {
-        return createSchemaClient(async (method, params, credential, callOpts) => {
-            const shellOpts = {};
-            if (callOpts?.timeout !== undefined)
-                shellOpts.timeout = callOpts.timeout;
-            if (callOpts?.signal !== undefined)
-                shellOpts.signal = callOpts.signal;
-            if (callOpts?.class !== undefined)
-                shellOpts.class = callOpts.class;
-            if (callOpts?.correlationId !== undefined)
-                shellOpts.correlationId = callOpts.correlationId;
-            if (callOpts?.url !== undefined)
-                shellOpts.url = callOpts.url;
-            if (callOpts?.delegation !== undefined)
-                shellOpts.delegation = callOpts.delegation;
-            if (callOpts?.attestation !== undefined)
-                shellOpts.attestation = callOpts.attestation;
-            if (callOpts?.skipDelegation !== undefined)
-                shellOpts.skipDelegation = callOpts.skipDelegation;
-            if (callOpts?.maxHops !== undefined)
-                shellOpts.maxHops = callOpts.maxHops;
-            if (callOpts?.self !== undefined)
-                shellOpts.self = callOpts.self;
-            if (credential !== undefined)
-                shellOpts.credential = credential;
-            return this.call(method, params, shellOpts);
-        }, schema);
-    }
-    // ─── Internal dispatch loop ───────────────────────────────────────────────
-    async dispatch(kind, method, params, opts) {
-        if (this.#closed)
-            throw new PoolClosedError();
-        // Seed values so the outer catch can build a ClientSessionErrorCtx even when
-        // identity-resolution or persistence-hydration is what threw.
-        const cid = opts?.correlationId ?? generateCid();
-        const initialTarget = opts?.url ?? this.default;
-        const effectiveMaxHops = opts?.maxHops ?? this.#maxHops;
-        const hops = [{ url: initialTarget, at: Date.now() }];
-        const startedAt = Date.now();
-        let baseCred = (opts?.credential ?? '');
-        let target = initialTarget;
-        let directTarget = false;
-        let hopIndex = 0;
-        let dispatchMethod = method;
-        // Replaced (not merged) by `redirection.self` on each hop.
-        let currentSelf = opts?.self;
-        // The audience the kernel told us this hop's target expects (`redirection.iss`).
-        let currentIss;
-        try {
-            // Hydration + identity-resolve inside try so their errors route through
-            // `onError` instead of escaping as unclassified rejections.
-            await this.ready();
-            baseCred = await this.resolveIdentity(opts);
-            const route = await this.#routes.resolve(method, params, opts, this.registry);
-            if (route) {
-                target = route.url;
-                dispatchMethod = route.method;
-                currentSelf = route.self;
-                currentIss = route.iss;
-                directTarget = true;
-                hops[0] = { url: target, at: hops[0].at };
-            }
-            const beforeCtx = {
-                method: dispatchMethod,
-                params,
-                credential: baseCred,
-                url: target,
-                correlationId: cid,
-                maxHops: effectiveMaxHops,
-            };
-            await this.fire('onBeforeCall', beforeCtx);
-            while (true) {
-                const resolved = await this.resolveDelegatedCredential({
-                    target,
-                    method: dispatchMethod,
-                    params,
-                    opts,
-                    cid,
-                    hops,
-                    baseCred,
-                    beforeCtx,
-                    iss: currentIss,
-                });
-                const credential = resolved.credential;
-                const delegationMintedThisHop = resolved.mintedThisHop;
-                const client = this.#pool.clientFor(target);
-                const result = await this.wireSend(client, kind, dispatchMethod, params, credential, opts, hopIndex, cid, currentSelf, 
-                // Learned routes and redirect follow-ups must override schema bindings
-                // on the inner client, so the per-hop target rides as `opts.url`.
-                directTarget || hopIndex > 0 ? target : undefined);
-                if (result.kind !== 'redirect') {
-                    const unwrapped = unwrapResult(result);
-                    const afterCtx = Object.freeze({
-                        ...beforeCtx,
-                        result: unwrapped,
-                        hops: freezeHops(hops),
-                        durationMs: Date.now() - startedAt,
-                    });
-                    await this.fire('onAfterCall', afterCtx);
-                    return unwrapped;
-                }
-                const redirection = result.redirection;
-                // `maxHops: 0` means "refuse any redirect" — surface
-                // RedirectRefusedError, not HopLimitExceededError.
-                if (effectiveMaxHops === 0) {
-                    const refusedCtx = Object.freeze({
-                        ...beforeCtx,
-                        fromUrl: target,
-                        redirection,
-                        reason: 'maxHops: 0 refuses every redirect',
-                    });
-                    await this.fire('onRedirectRefused', refusedCtx);
-                    throw new RedirectRefusedError(redirection, 'maxHops: 0 refuses every redirect');
-                }
-                if (hops.length > effectiveMaxHops) {
-                    throw new HopLimitExceededError(method, freezeHops(hops));
-                }
-                let redirectDecision;
-                try {
-                    redirectDecision = await this.#redirect.decide(redirection, freezeHops(hops), cid, opts?.signal);
-                }
-                catch (cause) {
-                    throw new RedirectPolicyError(redirection, { cause: cause });
-                }
-                if (redirectDecision.follow === false) {
-                    const refusedCtx = {
-                        ...beforeCtx,
-                        fromUrl: target,
-                        redirection,
-                        reason: redirectDecision.reason,
-                    };
-                    await this.fire('onRedirectRefused', refusedCtx);
-                    throw new RedirectRefusedError(redirection, redirectDecision.reason);
-                }
-                if (redirection.schema) {
-                    try {
-                        this.registry.save(redirection.schema);
-                    }
-                    catch (cause) {
-                        throw new RegistryWriteFailedError(redirection.schema.ref, {
-                            cause: cause,
-                        });
-                    }
-                    // Persistence is best-effort: save errors surface through onError
-                    // (or logger.warn fallback) and the call proceeds.
-                    if (this.#ownsRegistry && this.#schemaStore) {
-                        const learned = redirection.schema;
-                        void this.#schemaStore.save(learned).catch((err) => {
-                            if (this.#hooks.onError) {
-                                const ctx = {
-                                    ...beforeCtx,
-                                    error: err,
-                                    hops: freezeHops(hops),
-                                    context: 'persistence.save',
-                                };
-                                void this.fire('onError', ctx);
-                            }
-                            else {
-                                this.#logger.warn?.('schemaStore.save failed', err);
-                            }
-                        });
-                    }
-                }
-                await this.#routes.remember(dispatchMethod, opts?.class, redirection, this.registry);
-                const followCtx = Object.freeze({
-                    ...beforeCtx,
-                    fromHop: hopIndex,
-                    fromUrl: target,
-                    toUrl: redirection.url,
-                    redirection,
-                    ...(redirection.schema ? { schemaLearned: redirection.schema } : {}),
-                    delegationMinted: delegationMintedThisHop,
-                });
-                await this.fire('onRedirectFollow', followCtx);
-                hops.push({ url: redirection.url, at: Date.now() });
-                target = redirection.url;
-                directTarget = false;
-                hopIndex += 1;
-                dispatchMethod = redirection.path;
-                currentSelf = redirection.self;
-                currentIss = redirection.iss;
-            }
-        }
-        catch (err) {
-            const decorated = this.decorate(err, method, params, target, cid, hops);
-            const context = classifyError(decorated);
-            await this.fireError(decorated, method, params, baseCred, initialTarget, cid, effectiveMaxHops, hops, context);
-            throw decorated;
-        }
-    }
-    // ─── Signal dispatch (fire-and-forget) ─────────────────────────────────────
-    async runSignal(method, params, opts, cid) {
-        // Await hydration inside runSignal so a PersistenceLoadFailedError reaches
-        // the signal's outer .catch instead of becoming an unhandled rejection on
-        // the constructor's hydration promise.
-        await this.ready();
-        const baseCred = await this.resolveIdentity(opts);
-        const route = await this.#routes.resolve(method, params, opts, this.registry);
-        const target = route?.url ?? opts?.url ?? this.default;
-        const dispatchMethod = route?.method ?? method;
-        const selfOverride = route?.self ?? opts?.self;
-        const resolved = await this.resolveDelegatedCredential({
-            target,
-            method: dispatchMethod,
-            params,
-            opts,
-            cid,
-            hops: [{ url: target, at: Date.now() }],
-            baseCred,
-            // Signals surface delegation refusal via `onError`, not the paired
-            // `onDelegationRefused` hook — undefined disables it in the helper.
-            beforeCtx: undefined,
-            iss: route?.iss,
-        });
-        const credential = resolved.credential;
-        const client = this.#pool.clientFor(target);
-        client.signal(dispatchMethod, params, credential, {
-            ...forwardedFor(opts, 0, route ? target : undefined),
-            correlationId: cid,
-            ...(selfOverride !== undefined ? { self: selfOverride } : {}),
-        });
-        await this.fire('onAfterSignal', {
-            method: dispatchMethod,
-            params,
-            url: target,
-            correlationId: cid,
-            dispatchedAt: Date.now(),
-        });
-    }
-    // ─── Helpers ───────────────────────────────────────────────────────────────
-    /**
-     * Wrap the caller's mint to fire `onDelegationMint` with the list of
-     * waiter cids — read AFTER the mint resolves so late joiners to the dedup
-     * are included.
-     */
-    wrapMint(userMint, defaultTtl) {
-        return async (audience, delegation, attestation, context) => {
-            const key = delegationCacheKey(audience, delegation, attestation, context?.authority);
-            // Bump before awaiting so a synchronous before/after snapshot in
-            // dispatch observes the increment even across microtask re-entry.
-            this.#mintInvocations.set(key, (this.#mintInvocations.get(key) ?? 0) + 1);
-            const startedAt = Date.now();
-            const result = await userMint(audience, delegation, attestation, context);
-            const durationMs = Date.now() - startedAt;
-            const pending = this.#pendingMints.get(key);
-            // `pending` is empty when a consumer called cache.get directly
-            // (bypassing ClientSession) — legal, but triggeringCorrelationIds stays [].
-            const cids = pending ? [...pending.cids] : [];
-            const firstMethod = pending?.methods[0] ?? '';
-            void this.fire('onDelegationMint', {
-                audience,
-                delegation,
-                ...(attestation !== undefined ? { attestation } : {}),
-                triggeringCorrelationIds: cids,
-                triggeringMethod: firstMethod,
-                durationMs,
-                ttl: result.ttl ?? defaultTtl,
-            });
-            return result;
-        };
-    }
-    trackPendingMint(audience, delegation, attestation, authority, cid, method) {
-        const key = delegationCacheKey(audience, delegation, attestation, authority);
-        let entry = this.#pendingMints.get(key);
-        if (!entry) {
-            entry = { cids: [], methods: [] };
-            this.#pendingMints.set(key, entry);
-        }
-        entry.cids.push(cid);
-        entry.methods.push(method);
-        return key;
-    }
-    untrackPendingMint(key, cid) {
-        const entry = this.#pendingMints.get(key);
-        if (!entry)
-            return;
-        const idx = entry.cids.indexOf(cid);
-        if (idx !== -1) {
-            entry.cids.splice(idx, 1);
-            entry.methods.splice(idx, 1);
-        }
-        if (entry.cids.length === 0)
-            this.#pendingMints.delete(key);
-    }
-    async hydrate(schemaConfig) {
-        if (!this.#schemaStore)
-            return;
-        let loaded;
-        try {
-            loaded = await this.#schemaStore.load();
-        }
-        catch (cause) {
-            throw new PersistenceLoadFailedError({ cause: cause });
-        }
-        // Persisted schemas first, then the explicit `schema` array —
-        // caller-passed preload is authoritative on drift.
-        for (const entry of loaded) {
-            try {
-                this.registry.save(entry);
-            }
-            catch {
-                // Swallowed: conflicts resolve via the explicit-array pass below.
-            }
-        }
-        if (Array.isArray(schemaConfig) && schemaConfig.length > 0) {
-            for (const entry of schemaConfig) {
-                try {
-                    this.registry.save(entry);
-                }
-                catch {
-                    // Already loaded in constructor; re-save is best-effort.
-                }
-            }
-        }
-    }
-    async resolveIdentity(opts) {
-        if (opts?.credential !== undefined)
-            return opts.credential;
-        if (this.#identity === undefined) {
-            throw new UnresolvedIdentityError('No identity configured and no opts.credential passed — cannot dispatch');
-        }
-        if (typeof this.#identity === 'function') {
-            let resolved;
-            try {
-                resolved = await this.#identity();
-            }
-            catch (cause) {
-                throw new IdentityPickerError({ cause: cause });
-            }
-            if (resolved === undefined) {
-                throw new UnresolvedIdentityError('Identity picker returned undefined — user not signed in or session expired');
-            }
-            return resolved;
-        }
-        return this.#identity;
-    }
-    audienceFor(target, method, params, ctx) {
-        try {
-            return this.#delegationPolicy.audienceFor(target, method, params, ctx);
-        }
-        catch (cause) {
-            throw new DelegationPolicyError(undefined, { cause: cause });
-        }
-    }
-    /**
-     * Per-hop credential resolution shared by `dispatch` and `runSignal`.
-     * Handles `skipDelegation` bypass, policy derivation (wrapped as
-     * `DelegationPolicyError` on throw), async `decide` consent + refinement,
-     * and cache lookup with pending-mint bookkeeping.
-     *
-     * Returns `mintedThisHop` for `RedirectFollowCtx.delegationMinted`, keyed
-     * off the per-key mint counter so `ttl: 0` mints and concurrent LRU
-     * eviction don't lie. `beforeCtx: undefined` disables the pre-throw
-     * `onDelegationRefused` hook (signals use `onError` instead).
-     */
-    async resolveDelegatedCredential(args) {
-        const { target, method, params, opts, cid, hops, baseCred, beforeCtx, iss } = args;
-        if (opts?.skipDelegation) {
-            return { credential: baseCred, mintedThisHop: false };
-        }
-        const delegationCtx = {
-            target,
-            method,
-            params,
-            correlationId: cid,
-            hops,
-            ...(iss !== undefined ? { iss } : {}),
-        };
-        const audience = this.audienceFor(target, method, params, delegationCtx);
-        if (audience === undefined) {
-            return { credential: baseCred, mintedThisHop: false };
-        }
-        let delegation;
-        let attestation;
-        try {
-            delegation =
-                opts?.delegation ??
-                    this.#delegationPolicy.delegationFor?.(target, method, params, delegationCtx) ??
-                    SELF_DELEGATION;
-            attestation =
-                opts?.attestation ??
-                    this.#delegationPolicy.attestationFor?.(target, method, params, delegationCtx);
-        }
-        catch (cause) {
-            throw new DelegationPolicyError(audience, { cause: cause });
-        }
-        if (this.#delegationPolicy.decide) {
-            const preRefineDelegation = delegation;
-            const preRefineAttestation = attestation;
-            let decision;
-            try {
-                decision = await this.#delegationPolicy.decide(audience, preRefineDelegation, preRefineAttestation, delegationCtx, opts?.signal);
-            }
-            catch (cause) {
-                throw new DelegationPolicyError(audience, { cause: cause });
-            }
-            if (decision.allow === false) {
-                if (beforeCtx !== undefined) {
-                    const refusedCtx = {
-                        ...beforeCtx,
-                        target,
-                        audience,
-                        delegation: preRefineDelegation,
-                        ...(preRefineAttestation !== undefined ? { attestation: preRefineAttestation } : {}),
-                        reason: decision.reason,
-                    };
-                    await this.fire('onDelegationRefused', refusedCtx);
-                }
-                throw new DelegationRefusedError(audience, preRefineDelegation, preRefineAttestation, decision.reason);
-            }
-            // Substitute before cache lookup so the refined shape becomes both
-            // the cache key and what `onDelegationMint` reports.
-            if (decision.delegation !== undefined)
-                delegation = decision.delegation;
-            if (decision.attestation !== undefined)
-                attestation = decision.attestation;
-        }
-        if (!this.#delegation) {
-            // No cache → base credential dispatches; the target kernel rejects
-            // with AuthenticationError if it needed a delegation.
-            return { credential: baseCred, mintedThisHop: false };
-        }
-        // Key the counter identically to the cache (post-refine) so mints for
-        // other audiences don't inflate this call's delta.
-        const cacheKey = delegationCacheKey(audience, delegation, attestation, baseCred);
-        const mintsBefore = this.#mintInvocations.get(cacheKey) ?? 0;
-        const pendingKey = this.trackPendingMint(audience, delegation, attestation, baseCred, cid, method);
-        let credential;
-        try {
-            credential = await this.#delegation.get(audience, delegation, attestation, {
-                authority: baseCred,
-            });
-        }
-        finally {
-            this.untrackPendingMint(pendingKey, cid);
-        }
-        return {
-            credential,
-            mintedThisHop: (this.#mintInvocations.get(cacheKey) ?? 0) > mintsBefore,
-        };
-    }
-    async wireSend(client, kind, method, params, credential, opts, hopIndex, cid, selfOverride, redirectTarget) {
-        const callOpts = {
-            ...forwardedFor(opts, hopIndex, redirectTarget),
-            correlationId: cid,
-            // Loop-local override supersedes `opts.self` after hop 0.
-            ...(selfOverride !== undefined && { self: selfOverride }),
-        };
-        switch (kind) {
-            case 'call':
-                return client.send(method, params, credential, callOpts);
-            case 'stream':
-                return client.sendStream(method, params, credential, callOpts);
-            case 'binary':
-                return client.sendBinary(method, params, credential, callOpts);
-        }
-    }
-    decorate(err, method, params, url, correlationId, hops) {
-        if (!(err instanceof Error))
-            return new Error(String(err));
-        const webOs = err;
-        const existing = webOs.details ?? {};
-        // `transport` is opaque to ClientSession — copy what the client stamped, or
-        // leave undefined. ClientSession does not invent a transport name.
-        const merged = {
-            method: existing.method ?? method,
-            params: existing.params ?? params,
-            url: existing.url ?? url,
-            correlationId: existing.correlationId ?? correlationId,
-            hops: freezeHops(hops),
-        };
-        if (existing.transport !== undefined)
-            merged.transport = existing.transport;
-        withDetails(err, merged);
-        return err;
-    }
-    async fire(name, ctx) {
-        const hook = this.#hooks[name];
-        if (!hook)
-            return;
-        try {
-            await hook(ctx);
-        }
-        catch (err) {
-            this.#logger.error?.(`ClientSessionHooks.${name} threw`, err);
-        }
-    }
-    async fireError(error, method, params, credential, url, correlationId, maxHops, hops, context) {
-        const ctx = {
-            method,
-            params,
-            credential,
-            url,
-            correlationId,
-            maxHops,
-            error: error,
-            hops: freezeHops(hops),
-            context,
-        };
-        await this.fire('onError', ctx);
-    }
-}
-//# sourceMappingURL=client-session.js.map