/** * Call-back kernel client. * * Every authenticated inbound request produces a `BoundClientSessionView` the * handler uses to call back into the parent kernel. The view is bound to * a composed credential (`union(delegation, self)`) so the kernel * enforces both the caller's scoped identity and the function's own. * * The connection pool and schema registry are cached per kernel URL and reused * across requests. The `ClientSession` itself is per-request: it carries a * delegation mint bound to the calling function's own subject (`config.subject`) * so a remote-bound call (one that redirects to another worker) mints a * worker-scoped credential for the audience the kernel puts on the redirect * (`CallRedirection.iss`) — the worker→worker dance, done reactively instead of * the old proactive `lookupRemoteBinding` resolve-then-dial. */ import type { Delegation } from '@astrale-os/kernel-core'; import type { UnresolvedIdentityExpr } from '@astrale-os/kernel-core'; import { type FnMap } from '@astrale-os/kernel-client'; import { type BoundClientSessionView } from '@astrale-os/kernel-client/session'; import type { RemoteIdentityConfig } from './identity.js'; /** * Build a `BoundClientSessionView` that signs outbound calls as the composed * identity (the caller's delegation unioned with this function's own * identity). Remote-bound redirects mint worker-scoped delegations via AuthApi. */ export declare function bindKernel(delegation: Delegation, kernelUrl: string, config: RemoteIdentityConfig): Promise>; /** * Bind a session to a PRE-SIGNED credential — no delegation mint, no composed * grant; the credential IS the authority. The seam behind * `DomainAuthority.sessionFor` (a worker acting as an identity it issues). Pool + * schema registry are the same per-URL caches the composed sessions use. */ export declare function bindCredentialSession(kernelUrl: string, credential: string, opts?: { delegation?: UnresolvedIdentityExpr; }): BoundClientSessionView; //# sourceMappingURL=kernel-client.d.ts.map