@astrale-os/sdk 0.5.0-beta.13 → 0.5.0-beta.131

package/dist/server/remote.js

@@ -1,795 +0,0 @@
-import { call, Client } from '@astrale-os/kernel-client';
-import { createAuth } from '@astrale-os/kernel-client/auth';
-import { createGraph } from '@astrale-os/kernel-client/graph';
-import { ClientSession } from '@astrale-os/kernel-client/session';
-import { AuthValueError, credential, delegation, grant, issuer, jwk, } from '@astrale-os/kernel-core/auth';
-import { Domain } from '@astrale-os/kernel-core/domain';
-import { NodeId } from '@astrale-os/kernel-core/graph/node';
-import { Path } from '@astrale-os/kernel-core/path';
-import { syscalls } from '@astrale-os/kernel-core/schema';
-import { errors as protocolErrors, issuer as issuerProtocol, publication as publicationProtocol, } from '@astrale-os/kernel-protocol';
-import { errors as joseErrors, importJWK, jwtVerify, SignJWT } from 'jose';
-import { bindCallables, createDeployment } from '../deployment/index.js';
-import { InvocationInternalError, projectClientError, protocolError } from '../invocation/error.js';
-import { acceptInvocationTarget } from '../invocation/target.js';
-import { createApplication } from './application.js';
-const CALLBACK_TTL_SECONDS = 120;
-const MAXIMUM_DISCOVERY_DOCUMENT_BYTES = 256 * 1024;
-const DEFAULT_ROUTE_AGE_MS = 60_000;
-const DEFAULT_TOKEN_EXCHANGE_TTL_SECONDS = 300;
-/**
- * Compose the portable V2 Deployment/Application pair for one remotely hosted Domain.
- * The helper owns only generic remote identity, installation attestation, and callback authority;
- * provider routing and lifecycle remain adapter capabilities.
- */
-export function createRemoteApplication(input) {
-    const issuerId = httpIssuer(input.identity.issuer, input.identity.allowInsecureHttp === true);
-    if (input.identity.subject !== input.definition.schema.origin) {
-        throw new TypeError('Remote identity subject must equal the Domain origin.');
-    }
-    const delivery = input.deployment;
-    const deploymentInput = {
-        definition: input.definition,
-        issuer: issuerId,
-        bundleHref: delivery.bundleHref,
-        bindings: {
-            callables: bindCallables(input.definition, delivery.endpoint),
-        },
-        ...(delivery.frontendBaseHref === undefined
-            ? {}
-            : { frontendBaseHref: delivery.frontendBaseHref }),
-        ...(delivery.frontendCacheKey === undefined
-            ? {}
-            : { frontendCacheKey: delivery.frontendCacheKey }),
-        ...(delivery.protocolViewBindings === undefined
-            ? {}
-            : { protocolViewBindings: delivery.protocolViewBindings }),
-        ...(delivery.routes === undefined ? {} : { routes: delivery.routes }),
-        ...(delivery.manifest === undefined ? {} : { manifest: delivery.manifest }),
-        ...(delivery.delivery === undefined ? {} : { delivery: delivery.delivery }),
-        servingEndpoint: delivery.endpoint,
-    };
-    const deployed = createDeployment(deploymentInput);
-    const signing = signingMaterial(input.identity.privateKey);
-    let current = deployed;
-    const applicationInput = {
-        deployment: deployed,
-        environment: input.environment,
-        identity: remoteIdentity({ ...input.identity, issuer: issuerId }, signing),
-        server: input.server,
-        ...(input.workflowRunner === undefined ? {} : { workflowRunner: input.workflowRunner }),
-        ...(delivery.delivery === undefined
-            ? {}
-            : { delivery: publicDeliveryProvider(() => current, signing) }),
-        ...(input.app === undefined ? {} : { app: input.app }),
-    };
-    const application = createApplication(applicationInput);
-    return Object.freeze({
-        app: application.app,
-        get publication() {
-            return application.publication;
-        },
-        replace(candidate) {
-            const replaced = application.replace(candidate);
-            current = candidate;
-            return replaced;
-        },
-        drain: application.drain,
-        close: application.close,
-    });
-}
-/** Build one immutable Application identity backed by an asymmetric private JWK. */
-export function createRemoteIdentity(input) {
-    return remoteIdentity(input, signingMaterial(input.privateKey));
-}
-function remoteIdentity(input, signing) {
-    const selfIssuer = httpIssuer(input.issuer, input.allowInsecureHttp === true);
-    const fetchImpl = input.fetch ?? globalThis.fetch.bind(globalThis);
-    if (typeof fetchImpl !== 'function')
-        throw new TypeError('Remote identity requires Fetch.');
-    if (typeof input.subject !== 'string' || input.subject.length === 0) {
-        throw new TypeError('Remote identity subject must not be empty.');
-    }
-    if (input.allowEndpoint !== undefined && typeof input.allowEndpoint !== 'function') {
-        throw new TypeError('Remote identity endpoint policy is invalid.');
-    }
-    const maximumExchangeTtlSeconds = admitExchangeOptions(input.tokenExchange);
-    return Object.freeze({
-        issuer: selfIssuer,
-        signingAlgorithm: signing.algorithm,
-        loadPublicKeys: async () => [signing.publicKey],
-        tokenExchange: exchangeProvider(selfIssuer, input.subject, signing, fetchImpl, input, maximumExchangeTtlSeconds),
-        admit: (request) => admitAttempt(request, signing, selfIssuer, fetchImpl, input),
-        authenticate: async (request) => {
-            const established = await establishCaller(request.credential, selfIssuer, fetchImpl, request.context.execution, input);
-            if (established.verified.iss !== request.via.issuer) {
-                throw protocolError('AUTH_INVALID', 'Credential is invalid.');
-            }
-            const context = request.context.execution;
-            const callbackAudience = established.verified.iss;
-            const composed = composedIdentity(established.delegation.credential);
-            const composedCredential = await signCallback(signing, selfIssuer, input.subject, callbackAudience, composed, established.verified, context);
-            const fetch = boundedFetch(fetchImpl, context.signal);
-            const session = new ClientSession({
-                kernel: callbackAudience,
-                fetch,
-                auth: {
-                    ttlSeconds: callbackTtl(context.deadline),
-                    resolve: () => ({ credential: composedCredential }),
-                },
-                policy: {
-                    maximumRouteAgeMs: DEFAULT_ROUTE_AGE_MS,
-                    ...(input.allowEndpoint === undefined ? {} : { allowEndpoint: input.allowEndpoint }),
-                    ...(input.allowInsecureHttp === true ? { allowInsecureHttp: true } : {}),
-                },
-                timeoutMs: Math.max(1, context.deadline - Date.now()),
-            });
-            const dispatch = (call, options) => session.dispatch(call, boundedSessionOptions(context, options));
-            const kernel = kernelCapability(session, dispatch, context);
-            const app = domainHandle(request.domain, dispatch);
-            return Object.freeze({
-                caller: established.caller,
-                app,
-                kernel,
-            });
-        },
-    });
-}
-function admitExchangeOptions(input) {
-    if (input === undefined)
-        return DEFAULT_TOKEN_EXCHANGE_TTL_SECONDS;
-    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-        throw new TypeError('Remote identity tokenExchange options are invalid.');
-    }
-    const fields = Reflect.ownKeys(input);
-    if (fields.some((field) => field !== 'maximumTtlSeconds')) {
-        throw new TypeError('Remote identity tokenExchange options contain an unknown field.');
-    }
-    const maximumTtlSeconds = input.maximumTtlSeconds ?? DEFAULT_TOKEN_EXCHANGE_TTL_SECONDS;
-    if (!Number.isSafeInteger(maximumTtlSeconds) || maximumTtlSeconds < 1) {
-        throw new TypeError('tokenExchange.maximumTtlSeconds must be a positive safe integer.');
-    }
-    return maximumTtlSeconds;
-}
-function signingMaterial(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-        throw new TypeError('Remote identity private key must be a JWK object.');
-    }
-    const algorithm = input.alg;
-    if (typeof algorithm !== 'string' || algorithm.length === 0) {
-        throw new TypeError('Remote identity private JWK requires alg.');
-    }
-    const keyId = input.kid;
-    if (keyId !== undefined && (typeof keyId !== 'string' || keyId.length === 0)) {
-        throw new TypeError('Remote identity private JWK kid is invalid.');
-    }
-    const value = input;
-    const { d: _d, p: _p, q: _q, dp: _dp, dq: _dq, qi: _qi, oth: _oth, k: _k, 
-    // A WebCrypto-exported private JWK can be restricted to signing. That
-    // operation does not apply to the derived public verification key and
-    // makes strict JOSE consumers reject it when retained in JWKS.
-    key_ops: _keyOperations, ...publicValue } = value;
-    const publicKey = jwk.acceptPublic({
-        ...publicValue,
-        alg: algorithm,
-        ...(keyId ? { kid: keyId } : {}),
-    });
-    return Object.freeze({
-        algorithm,
-        ...(keyId === undefined ? {} : { keyId }),
-        privateKey: importJWK(input, algorithm),
-        publicKey,
-    });
-}
-function exchangeProvider(domainIssuer, subject, signing, fetch, policy, maximumTtlSeconds) {
-    return Object.freeze({
-        async exchange(request, context) {
-            try {
-                const outer = await verifyCredential(request.token, domainIssuer, fetch, context.signal, policy);
-                requireExchangeProfile(outer.verified, 'outer');
-                const carried = delegation.accept(outer.verified.claims.delegation);
-                if (typeof carried.credential !== 'string')
-                    exchangeInvalid();
-                const inner = await verifyCredentialAgainst(carried.credential, outer.verified.iss, outer.basis);
-                requireExchangeProfile(inner.verified, 'inner');
-                requireExchangeCoherence(outer.verified, inner.verified);
-                acceptResolvedDelegation(inner.verified.claims.delegation);
-                const now = Math.floor(Date.now() / 1_000);
-                const expiresAt = Math.min(outer.verified.exp, inner.verified.exp, now + maximumTtlSeconds);
-                if (expiresAt <= now)
-                    exchangeExpired();
-                const token = await new SignJWT({
-                    grant: {
-                        v: 1,
-                        expr: { kind: 'identity', credential: carried.credential },
-                    },
-                })
-                    .setProtectedHeader({
-                    alg: signing.algorithm,
-                    ...(signing.keyId === undefined ? {} : { kid: signing.keyId }),
-                })
-                    .setIssuer(domainIssuer)
-                    .setSubject(subject)
-                    .setAudience(outer.verified.iss)
-                    .setIssuedAt(now)
-                    .setExpirationTime(expiresAt)
-                    .sign(await signing.privateKey);
-                return issuerProtocol.exchange.response(token, expiresAt);
-            }
-            catch (cause) {
-                if (cause instanceof protocolErrors.ProtocolError)
-                    throw cause;
-                if (context.signal.aborted) {
-                    throw protocolError('CANCELLED', 'Token exchange was cancelled.');
-                }
-                if (cause instanceof joseErrors.JWTExpired)
-                    exchangeExpired();
-                if (cause instanceof IssuerUnavailable)
-                    exchangeUnavailable();
-                if (cause instanceof CredentialRejected ||
-                    cause instanceof joseErrors.JOSEError ||
-                    cause instanceof AuthValueError) {
-                    exchangeInvalid();
-                }
-                throw cause;
-            }
-        },
-    });
-}
-function requireExchangeProfile(input, profile) {
-    const expected = ['aud', 'delegation', 'exp', 'iat', 'iss', 'sub'];
-    const actual = Object.keys(input.claims).sort();
-    if (actual.length !== expected.length ||
-        actual.some((field, index) => field !== expected[index]) ||
-        typeof input.iat !== 'number' ||
-        !Number.isSafeInteger(input.iat) ||
-        input.iat < 1 ||
-        typeof input.exp !== 'number' ||
-        !Number.isSafeInteger(input.exp) ||
-        input.exp < 1 ||
-        typeof input.aud !== 'string') {
-        exchangeInvalid();
-    }
-    if (profile === 'outer')
-        delegation.accept(input.claims.delegation);
-    else
-        acceptResolvedDelegation(input.claims.delegation);
-}
-function requireExchangeCoherence(outer, inner) {
-    if (inner.iss !== outer.iss || inner.sub !== outer.sub || inner.aud !== outer.iss) {
-        exchangeInvalid();
-    }
-}
-function acceptResolvedDelegation(input) {
-    if (input === null ||
-        typeof input !== 'object' ||
-        Array.isArray(input) ||
-        Reflect.ownKeys(input).length !== 2 ||
-        !Object.hasOwn(input, 'v') ||
-        !Object.hasOwn(input, 'expr') ||
-        Reflect.get(input, 'v') !== 1) {
-        exchangeInvalid();
-    }
-    return grant.accept({ expr: Reflect.get(input, 'expr') });
-}
-function exchangeInvalid() {
-    throw new protocolErrors.ProtocolError({
-        code: protocolErrors.CODES.AUTH_INVALID,
-        message: 'Token is invalid.',
-    });
-}
-function exchangeExpired() {
-    throw new protocolErrors.ProtocolError({
-        code: protocolErrors.CODES.AUTH_EXPIRED,
-        message: 'Token is expired.',
-    });
-}
-function exchangeUnavailable() {
-    throw new protocolErrors.ProtocolError({
-        code: protocolErrors.CODES.BACKEND_UNAVAILABLE,
-        message: 'Token exchange is unavailable.',
-    });
-}
-async function establishCaller(input, audience, fetch, execution, policy) {
-    requireLive(execution);
-    try {
-        const context = await verifyCredential(input, audience, fetch, execution.signal, policy);
-        const carried = delegation.accept(context.verified.claims.delegation);
-        if (typeof carried.credential !== 'string') {
-            throw new CredentialRejected('Destination carrier has no Kernel authority proof.');
-        }
-        const proof = await verifyCredentialAgainst(carried.credential, context.verified.iss, context.basis);
-        if (proof.verified.sub !== context.verified.sub) {
-            throw new CredentialRejected('Destination carrier and authority proof subjects differ.');
-        }
-        const authority = acceptResolvedDelegation(proof.verified.claims.delegation);
-        let principal;
-        try {
-            principal = NodeId(context.verified.sub);
-        }
-        catch {
-            throw new CredentialRejected('Credential subject is not a Kernel IdentityId.');
-        }
-        return Object.freeze({
-            verified: context.verified,
-            delegation: carried,
-            caller: Object.freeze({
-                kind: 'authenticated',
-                principal,
-                authority,
-                authentication: credential.evidence(context),
-            }),
-        });
-    }
-    catch (cause) {
-        requireLive(execution);
-        if (cause instanceof IssuerUnavailable) {
-            throw protocolError('BACKEND_UNAVAILABLE', 'Credential issuer is unavailable.');
-        }
-        if (cause instanceof CredentialRejected ||
-            cause instanceof joseErrors.JOSEError ||
-            cause instanceof protocolErrors.ProtocolError) {
-            throw protocolError('AUTH_INVALID', 'Credential is invalid.');
-        }
-        throw cause;
-    }
-}
-async function verifyCredential(input, audience, fetch, signal, policy) {
-    let inspected;
-    try {
-        inspected = credential.inspect(input);
-    }
-    catch (cause) {
-        throw new CredentialRejected('Credential is malformed.', cause);
-    }
-    if (inspected.iss === undefined)
-        throw new CredentialRejected('Credential issuer is missing.');
-    let admittedIssuer;
-    try {
-        admittedIssuer = httpIssuer(inspected.iss, policy.allowInsecureHttp === true);
-    }
-    catch (cause) {
-        throw new CredentialRejected('Credential issuer is invalid.', cause);
-    }
-    const basis = await discoverVerificationBasis(admittedIssuer, fetch, signal, policy);
-    const verified = await verifyCredentialAgainst(input, audience, basis, inspected);
-    admitEndpoint(invocationUrl(admittedIssuer), policy);
-    return Object.freeze({ raw: input, verified: verified.verified, basis });
-}
-async function discoverVerificationBasis(admittedIssuer, fetch, signal, policy) {
-    const paths = issuerProtocol.paths(admittedIssuer);
-    const configurationUrl = new URL(paths.configuration, admittedIssuer).toString();
-    admitEndpoint(configurationUrl, policy);
-    const configurationResponse = await fetchDiscovery(fetch, configurationUrl, signal);
-    const configuration = issuerProtocol.acceptConfiguration(await boundedJson(configurationResponse, signal), admittedIssuer);
-    admitEndpoint(configuration.jwks_uri, policy);
-    const keysResponse = await fetchDiscovery(fetch, configuration.jwks_uri, signal);
-    const keys = issuerProtocol.acceptKeySet(await boundedJson(keysResponse, signal), configuration.id_token_signing_alg_values_supported).keys;
-    return Object.freeze({
-        issuer: admittedIssuer,
-        algorithms: configuration.id_token_signing_alg_values_supported,
-        keys,
-    });
-}
-async function verifyCredentialAgainst(input, audience, basis, preinspected) {
-    let inspected;
-    try {
-        inspected = preinspected ?? credential.inspect(input);
-    }
-    catch (cause) {
-        throw new CredentialRejected('Credential is malformed.', cause);
-    }
-    if (inspected.iss !== basis.issuer) {
-        throw new CredentialRejected('Credential issuer differs from the captured verification basis.');
-    }
-    const compact = typeof input === 'string' ? input : new TextDecoder().decode(input);
-    const candidates = basis.keys.filter((candidate) => inspected.kid === undefined || candidate.kid === inspected.kid);
-    const matches = [];
-    let expired;
-    for (const candidate of candidates) {
-        try {
-            const imported = await importJWK(candidate, candidate.alg ?? basis.algorithms[0]);
-            matches.push(await jwtVerify(compact, imported, {
-                issuer: basis.issuer,
-                audience,
-                algorithms: [...basis.algorithms],
-            }));
-        }
-        catch (cause) {
-            if (cause instanceof joseErrors.JWTExpired)
-                expired = cause;
-            if (cause instanceof joseErrors.JOSEError)
-                continue;
-            throw cause;
-        }
-    }
-    if (matches.length === 0 && expired !== undefined)
-        throw expired;
-    if (matches.length !== 1) {
-        throw new CredentialRejected('Credential signature is not uniquely verified.');
-    }
-    const match = matches[0];
-    let verified;
-    try {
-        verified = credential.acceptVerified({
-            method: 'jwt',
-            iss: match.payload.iss,
-            sub: match.payload.sub,
-            aud: match.payload.aud,
-            kid: match.protectedHeader.kid,
-            iat: match.payload.iat,
-            nbf: match.payload.nbf,
-            exp: match.payload.exp,
-            claims: match.payload,
-        });
-        credential.verifyAudience(verified, audience);
-    }
-    catch (cause) {
-        throw new CredentialRejected('Credential claims are invalid.', cause);
-    }
-    return Object.freeze({ raw: input, verified });
-}
-async function fetchDiscovery(fetch, url, signal) {
-    let response;
-    try {
-        response = await fetch(url, { method: 'GET', redirect: 'error', signal });
-    }
-    catch (cause) {
-        if (signal.aborted)
-            throw signal.reason;
-        throw new IssuerUnavailable('Issuer discovery request failed.', cause);
-    }
-    if (!response.ok) {
-        await response.body?.cancel();
-        throw new IssuerUnavailable(`Issuer discovery returned HTTP ${response.status}.`);
-    }
-    return response;
-}
-async function boundedJson(response, signal) {
-    const declared = response.headers.get('content-length');
-    if (declared !== null && Number(declared) > MAXIMUM_DISCOVERY_DOCUMENT_BYTES) {
-        await response.body?.cancel();
-        throw new CredentialRejected('Issuer discovery document exceeds the byte limit.');
-    }
-    if (response.body === null)
-        throw new CredentialRejected('Issuer discovery response is empty.');
-    const reader = response.body.getReader();
-    const chunks = [];
-    let size = 0;
-    try {
-        for (;;) {
-            const read = await reader.read();
-            if (read.done)
-                break;
-            size += read.value.byteLength;
-            if (size > MAXIMUM_DISCOVERY_DOCUMENT_BYTES) {
-                await reader.cancel();
-                throw new CredentialRejected('Issuer discovery document exceeds the byte limit.');
-            }
-            chunks.push(read.value);
-        }
-    }
-    catch (cause) {
-        if (signal.aborted)
-            throw signal.reason;
-        throw cause;
-    }
-    finally {
-        reader.releaseLock();
-    }
-    if (signal.aborted)
-        throw signal.reason;
-    const bytes = new Uint8Array(size);
-    let offset = 0;
-    for (const chunk of chunks) {
-        bytes.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    try {
-        return JSON.parse(new TextDecoder().decode(bytes));
-    }
-    catch (cause) {
-        throw new CredentialRejected('Issuer discovery document is not JSON.', cause);
-    }
-}
-function identityLeaf(nested) {
-    return Object.freeze({ kind: 'identity', credential: nested });
-}
-function composedIdentity(nested) {
-    return Object.freeze({
-        kind: 'union',
-        operands: Object.freeze([
-            Object.freeze({ kind: 'identity', self: true }),
-            identityLeaf(nested),
-        ]),
-    });
-}
-async function signDomainCallback(signing, callbackIssuer, subject, audience, execution) {
-    requireLive(execution);
-    const now = Math.floor(Date.now() / 1_000);
-    const expiresAt = Math.min(Math.floor(execution.deadline / 1_000), now + CALLBACK_TTL_SECONDS);
-    if (expiresAt <= now) {
-        throw protocolError('AUTH_INVALID', 'Credential is invalid.');
-    }
-    return new SignJWT({
-        grant: { v: 1, expr: { kind: 'identity', self: true } },
-    })
-        .setProtectedHeader({
-        alg: signing.algorithm,
-        ...(signing.keyId === undefined ? {} : { kid: signing.keyId }),
-    })
-        .setIssuer(callbackIssuer)
-        .setSubject(subject)
-        .setAudience(audience)
-        .setIssuedAt(now)
-        .setExpirationTime(expiresAt)
-        .sign(await signing.privateKey);
-}
-async function signCallback(signing, callbackIssuer, subject, audience, expression, carrier, execution) {
-    requireLive(execution);
-    const now = Math.floor(Date.now() / 1_000);
-    const expiresAt = Math.min(carrier.exp ?? Number.POSITIVE_INFINITY, Math.floor(execution.deadline / 1_000), now + CALLBACK_TTL_SECONDS);
-    if (!Number.isFinite(expiresAt) || expiresAt <= now) {
-        throw protocolError('AUTH_INVALID', 'Credential is invalid.');
-    }
-    return new SignJWT({ grant: { v: 1, expr: expression } })
-        .setProtectedHeader({
-        alg: signing.algorithm,
-        ...(signing.keyId === undefined ? {} : { kid: signing.keyId }),
-    })
-        .setIssuer(callbackIssuer)
-        .setSubject(subject)
-        .setAudience(audience)
-        .setIssuedAt(now)
-        .setExpirationTime(expiresAt)
-        .sign(await signing.privateKey);
-}
-function kernelCapability(session, dispatch, execution) {
-    const value = (call, options) => session.call(call, boundedSessionOptions(execution, options));
-    const graph = createGraph(value);
-    const auth = createAuth((target, input, options) => value(call(target, input), boundedRequestOptions(execution, options)));
-    return Object.freeze({
-        ...graph,
-        auth,
-        dispatch: (call, options) => dispatch(call, options),
-        call: (call, options) => session.call(call, boundedSessionOptions(execution, options)),
-        stream: (call, options) => session.stream(call, boundedSessionOptions(execution, options)),
-        binary: (call, options) => session.binary(call, boundedSessionOptions(execution, options)),
-        snapshot: (options) => session.snapshot(boundedSessionOptions(execution, options)),
-        viewsFor: (target, options) => session.viewsFor(target, boundedSessionOptions(execution, options)),
-        domain: async (domainSchema) => domainHandle(Domain.fromSchema(domainSchema), dispatch),
-    });
-}
-function domainHandle(domain, dispatch) {
-    const callables = concreteCallables(domain);
-    const invokeCallable = async (callable, receiver, input, options) => {
-        if (!callables.has(callable)) {
-            throw new InvocationInternalError('FUNCTION_HANDLER_INVALID', 'Callable is not a concrete member of the Domain.');
-        }
-        const target = 'on' in callable ? Path.instanceMethod(Path.from(receiver), callable.name) : callable.path;
-        if (target === undefined) {
-            throw new InvocationInternalError('FUNCTION_HANDLER_INVALID', 'Callable has no canonical Path.');
-        }
-        const result = await dispatch(call(target, input), options);
-        return callableOutput(callable, result);
-    };
-    const methodBinder = (method, receiver) => (input) => invokeCallable(method, Path.id(receiver.id), input);
-    const invoke = ((callable, receiverOrInput, inputOrOptions, options) => 'on' in callable
-        ? invokeCallable(callable, receiverOrInput, inputOrOptions, options)
-        : invokeCallable(callable, undefined, receiverOrInput, inputOrOptions));
-    const bind = ((definitionOrValue, value) => value === undefined
-        ? domain.$.wrap(definitionOrValue, methodBinder)
-        : domain.$.wrap(definitionOrValue, value, methodBinder));
-    return Object.freeze({
-        ...domain,
-        $: Object.freeze({ ...domain.$, invoke, bind }),
-    });
-}
-function concreteCallables(domain) {
-    const result = new Set();
-    for (const definition of domain.$.definitions.values()) {
-        if (definition.kind === 'function') {
-            result.add(definition);
-            continue;
-        }
-        if ((definition.kind !== 'class' && definition.kind !== 'interface') ||
-            definition.family !== 'node') {
-            continue;
-        }
-        for (const method of definition.methods.values()) {
-            if (method.definition.inheritance !== 'abstract') {
-                result.add(method);
-            }
-        }
-    }
-    return result;
-}
-function callableOutput(callable, result) {
-    switch (callable.definition.output.mode) {
-        case 'value':
-            if (result.kind === 'value')
-                return result.value;
-            break;
-        case 'stream':
-            if (result.kind === 'stream')
-                return result.stream;
-            break;
-        case 'binary':
-            if (result.kind === 'binary')
-                return result.value;
-            break;
-    }
-    if (result.kind === 'stream')
-        void result.stream.cancel('Remote callable output kind changed.');
-    throw new InvocationInternalError('INVOCATION_OUTPUT_INVALID', `Remote callable returned ${result.kind} for ${callable.definition.output.mode} output.`);
-}
-async function admitAttempt(request, signing, domainIssuer, fetch, policy) {
-    const execution = request.context.execution;
-    const kernel = request.via.issuer;
-    const url = invocationUrl(kernel);
-    try {
-        admitEndpoint(url, policy);
-    }
-    catch (cause) {
-        if (cause instanceof CredentialRejected) {
-            throw protocolError('ACCESS_DENIED', 'Remote Kernel endpoint is not allowed.');
-        }
-        throw cause;
-    }
-    const callback = await signDomainCallback(signing, domainIssuer, request.domain.$.origin, kernel, execution);
-    const owner = Path.project(syscalls.function.admit.ref.owner);
-    const target = Path.staticMethod(owner, syscalls.function.admit.ref.name);
-    const client = new Client({ url, fetch: boundedFetch(fetch, execution.signal) });
-    try {
-        const portableRequest = {
-            call: request.call,
-            ...(request.credential === undefined ? {} : { credential: request.credential }),
-        };
-        const result = await client.as(callback).call(call(target, portableRequest), {
-            ...boundedRequestOptions(execution),
-            delegate: {
-                ttlSeconds: callbackTtl(execution.deadline),
-                attenuation: { kind: 'identity', self: true },
-            },
-        });
-        return acceptInvocationTarget(result.value);
-    }
-    catch (cause) {
-        requireLive(execution);
-        const projected = projectClientError(cause);
-        if (projected === undefined)
-            throw cause;
-        throw projected;
-    }
-    finally {
-        client.close();
-    }
-}
-function publicDeliveryProvider(current, signing) {
-    if (current().publication.delivery?.authentication.kind !== 'public') {
-        throw new TypeError('Remote application helper currently requires a public delivery endpoint.');
-    }
-    return Object.freeze({
-        async create(request) {
-            const deployed = current();
-            if (deployed.publication.delivery?.authentication.kind !== 'public') {
-                throw protocolError('CONFLICT', 'Delivery endpoint changed.');
-            }
-            if (request.etag !== deployed.publication.etag) {
-                throw protocolError('CONFLICT', 'Delivery Publication changed.');
-            }
-            const now = Math.floor(Date.now() / 1_000);
-            const attestation = await new SignJWT({
-                purpose: publicationProtocol.delivery.PURPOSE,
-                nonce: request.nonce,
-                etag: deployed.publication.etag,
-                schemaRevision: deployed.publication.schema.revision,
-            })
-                .setProtectedHeader({
-                alg: signing.algorithm,
-                ...(signing.keyId === undefined ? {} : { kid: signing.keyId }),
-            })
-                .setIssuer(deployed.publication.identity.issuer)
-                .setSubject(deployed.publication.origin)
-                .setAudience(request.kernel)
-                .setExpirationTime(now + CALLBACK_TTL_SECONDS)
-                .sign(await signing.privateKey);
-            return publicationProtocol.delivery.accept({
-                format: 'astrale.domain.delivery',
-                version: 1,
-                publication: deployed.publication,
-                attestation,
-            });
-        },
-    });
-}
-function boundedFetch(fetch, lifecycle) {
-    return (input, init = {}) => fetch(input, {
-        ...init,
-        signal: init.signal === undefined || init.signal === null
-            ? lifecycle
-            : AbortSignal.any([lifecycle, init.signal]),
-    });
-}
-function boundedRequestOptions(execution, options = {}) {
-    return boundedOptions(execution, options);
-}
-function boundedSessionOptions(execution, options) {
-    return boundedOptions(execution, options ?? {});
-}
-function boundedOptions(execution, options) {
-    requireLive(execution);
-    const remaining = Math.max(1, execution.deadline - Date.now());
-    return {
-        ...options,
-        signal: options.signal === undefined
-            ? execution.signal
-            : AbortSignal.any([execution.signal, options.signal]),
-        timeoutMs: Math.min(options.timeoutMs ?? remaining, remaining),
-    };
-}
-function requireLive(execution) {
-    if (execution.signal.aborted) {
-        throw protocolError('CANCELLED', 'Remote invocation was cancelled.');
-    }
-    if (execution.deadline <= Date.now()) {
-        throw protocolError('DEADLINE_EXCEEDED', 'Remote invocation deadline was exceeded.');
-    }
-}
-function callbackTtl(deadline) {
-    return Math.max(1, Math.min(CALLBACK_TTL_SECONDS, Math.floor((deadline - Date.now()) / 1_000)));
-}
-function httpIssuer(input, allowInsecureHttp) {
-    const admitted = issuer.accept(input);
-    let url;
-    try {
-        url = new URL(admitted);
-    }
-    catch (cause) {
-        throw new TypeError('Remote identity issuer must be an absolute HTTP(S) URL.', { cause });
-    }
-    if (url.username !== '' ||
-        url.password !== '' ||
-        url.search !== '' ||
-        url.hash !== '' ||
-        (url.protocol !== 'https:' && !(allowInsecureHttp && url.protocol === 'http:'))) {
-        throw new TypeError(allowInsecureHttp
-            ? 'Remote identity issuer must be an absolute HTTP(S) URL without credentials, query, or fragment.'
-            : 'Remote identity issuer must be an absolute HTTPS URL without credentials, query, or fragment.');
-    }
-    return admitted;
-}
-function admitEndpoint(input, policy) {
-    let url;
-    try {
-        url = new URL(input);
-    }
-    catch (cause) {
-        throw new CredentialRejected('Credential issuer endpoint is invalid.', cause);
-    }
-    if (url.username !== '' ||
-        url.password !== '' ||
-        url.hash !== '' ||
-        (url.protocol !== 'https:' && !(policy.allowInsecureHttp === true && url.protocol === 'http:'))) {
-        throw new CredentialRejected('Credential issuer endpoint is not allowed.');
-    }
-    if (policy.allowEndpoint?.(url.toString()) === false) {
-        throw new CredentialRejected('Credential issuer endpoint is denied by policy.');
-    }
-}
-function invocationUrl(input) {
-    return `${input.replace(/\/+$/u, '')}/invoke`;
-}
-class CredentialRejected extends Error {
-    constructor(message, cause) {
-        super(message, { cause });
-        this.name = 'CredentialRejected';
-    }
-}
-class IssuerUnavailable extends Error {
-    constructor(message, cause) {
-        super(message, { cause });
-        this.name = 'IssuerUnavailable';
-    }
-}
-//# sourceMappingURL=remote.js.map