@tinycloud/node-sdk 3.11.1-beta.0 → 3.12.0-beta.1

package/dist/{TinyCloudNode-BmpjkpWR.d.cts → TinyCloudNode-DLrINr98.d.ts}

@@ -1,881 +1,10 @@
 import * as _tinycloud_sdk_core from '@tinycloud/sdk-core';
-import { AutoSignStrategy, AutoRejectStrategy, CallbackStrategy, CapabilityPresentationEnvelopeV1, IUserAuthorization, ISigner, ISessionStorage, ISpaceCreationHandler, RegistryPolicy, RegistrySequenceStore, OnNodeNotFound, LocalNodeIdentityStore, IWasmBindings, ISessionManager, SiweConfig, Manifest, ComposedManifestRequest, ReplicationOptions, TinyCloudSession, PersistedSessionData, ClientSession, PermissionEntry, Extension, SignRequest, SpaceHostResult, SignInOptions, TelemetryConfig, ServiceContext, IKVService, ISQLService, IDuckDbService, IHooksService, CreateOwnerDelegationParams as CreateOwnerDelegationParams$1, OwnerDelegationReceipt as OwnerDelegationReceipt$1, Delegation, StorageFullEvent, IStorageService, INotificationHandler, IENSResolver, RetryPolicy, KVReplicaStorage, AccountService, InvokeAnyFunction as InvokeAnyFunction$1, UnifiedPolicyCapability, RegisterPolicyV3Input, RegisterPolicyV3Receipt, CanonicalJson, ShareDeliveryAuthorizationV3Receipt, IDataVaultService, IEncryptionService, NetworkDescriptor, ISecretsService, ICapabilityKeyRegistry, DelegationManager, ISpaceService, ISpace, ISharingService, DelegationResult, DelegationRevocationReceipt, DelegationStatus, ServiceSession, ReplicationControl, ResolvedDelegate } from '@tinycloud/sdk-core';
+import { TinyCloudSession, TelemetryConfig, ServiceContext, IKVService, ISQLService, IDuckDbService, IHooksService, CreateOwnerDelegationParams as CreateOwnerDelegationParams$1, OwnerDelegationReceipt as OwnerDelegationReceipt$1, Delegation, IWasmBindings, ISigner, StorageFullEvent, IStorageService, RegistryPolicy, RegistrySequenceStore, OnNodeNotFound, LocalNodeIdentityStore, ISessionStorage, INotificationHandler, IENSResolver, ISpaceCreationHandler, SiweConfig, Manifest, ComposedManifestRequest, RetryPolicy, ReplicationOptions, KVReplicaStorage, PermissionEntry, AccountService, SignInOptions, InvokeAnyFunction as InvokeAnyFunction$1, UnifiedPolicyCapability, RegisterPolicyV3Input, RegisterPolicyV3Receipt, CanonicalJson, ShareDeliveryAuthorizationV3Receipt, IDataVaultService, IEncryptionService, NetworkDescriptor, ISecretsService, ICapabilityKeyRegistry, DelegationManager, ISpaceService, ISpace, ISharingService, DelegationResult, DelegationRevocationReceipt, DelegationStatus, ServiceSession, ReplicationControl, ResolvedDelegate } from '@tinycloud/sdk-core';
 import { ReplicaPurgeFailedEvent, ReplicaSessionStamp } from '@tinycloud/sdk-services/kv/replication';
 import { InvokeFunction, InvokeAnyFunction, FetchFunction, RequestSink, RequestLogReader } from '@tinycloud/sdk-services';
 import { NamedKeyClient } from '@tinycloud/sdk-services/encryption/named-keys';
-import { EventEmitter } from 'events';
-import { P as PortableDelegation, S as SessionGrantProof, h as VerifiedSessionGrant } from './delegation-Ckc3UETl.cjs';
-
-/**
- * Node.js-specific SignStrategy types for TinyCloud authorization.
- *
- * This module re-exports common types from sdk-core and provides
- * Node.js-specific implementations (e.g., NodeEventEmitterStrategy
- * using Node's EventEmitter instead of browser EventTarget).
- *
- * @packageDocumentation
- */
-
-/**
- * Node.js event emitter strategy: emits sign requests as events.
- *
- * Uses Node.js EventEmitter for compatibility with Node.js applications.
- * For browser environments, use the EventEmitterStrategy from sdk-core
- * which uses EventTarget.
- *
- * Events emitted:
- * - 'sign-request': When a sign request is received
- *
- * Use cases:
- * - Async approval workflows in Node.js
- * - External signing services
- * - Multi-step authorization flows
- *
- * @example
- * ```typescript
- * const emitter = new EventEmitter();
- * const strategy: NodeEventEmitterStrategy = { type: 'event-emitter', emitter };
- *
- * emitter.on('sign-request', async (req, respond) => {
- *   const approved = await externalApprovalService.check(req);
- *   respond({ approved, signature: approved ? await sign(req.message) : undefined });
- * });
- * ```
- */
-interface NodeEventEmitterStrategy {
-    type: "event-emitter";
-    emitter: EventEmitter;
-    /** Timeout in milliseconds for waiting on event response (default: 60000) */
-    timeout?: number;
-}
-/**
- * Node.js sign strategy union type.
- *
- * Determines how sign requests are handled in NodeUserAuthorization.
- * Uses Node.js EventEmitter for the event-emitter strategy.
- */
-type SignStrategy = AutoSignStrategy | AutoRejectStrategy | CallbackStrategy | NodeEventEmitterStrategy;
-/**
- * Default sign strategy is auto-sign for convenience.
- * This is the Node.js-specific version typed with SignStrategy.
- */
-declare const defaultSignStrategy: SignStrategy;
-
-/**
- * Structural shape of the OpenKey SDK's `authorizeTinyCloud()` method.
- * Callers pass any object that conforms to this shape — typically an
- * `OpenKey` instance from `@openkey/sdk` — without either package
- * needing to import from the other.
- */
-interface OpenKeyAuthorizeTinyCloud {
-    authorizeTinyCloud(request: {
-        protocolVersion: 1;
-        siwe: string;
-        keyId?: string;
-        jwk?: Record<string, unknown>;
-        host?: string;
-        /**
-         * Display-only presentation envelope. Forwarded to the OpenKey
-         * widget review UI. The envelope MUST NEVER expand authority — the
-         * ReCap payload remains the sole gate — and the widget/server
-         * validates and size-bounds it before use.
-         */
-        presentation?: CapabilityPresentationEnvelopeV1;
-        /**
-         * Ask OpenKey to let the user change the session expiry in the approval.
-         * Sent only when true. `@openkey/sdk` >= 0.13.0 (beta: 0.13.0-beta.0)
-         * forwards it; 0.12.x ignores it.
-         */
-        expiryChangeable?: boolean;
-    }, opts?: {
-        mode?: "iframe" | "popup" | "redirect";
-    }): Promise<{
-        protocolVersion: 1;
-        address: string;
-        signature: string;
-        signedMessage: string;
-        selectedActionKeys: string[];
-        permissions: Array<{
-            service: string;
-            space: string;
-            path: string;
-            actions: string[];
-        }>;
-    }>;
-}
-interface OpenKeyBridgeInput {
-    protocolVersion: 1;
-    siwe: string;
-    jwk: Record<string, unknown>;
-    /** SDK-prepared session-key DID, for local handoff consistency only; not an OpenKey request field. */
-    readonly verificationMethod: string;
-    host?: string;
-    /** Optional keyId hint the caller wants OpenKey to bind to. */
-    keyId?: string;
-    /**
-     * Optional presentation envelope built by `NodeUserAuthorization`
-     * from its `_manifest`. Passed through to `authorizeTinyCloud` so the
-     * widget can render honest provenance labels and the OpenKey server
-     * can origin-bind the browser origin against the app's well-known
-     * manifest. Display-only.
-     */
-    presentation?: CapabilityPresentationEnvelopeV1;
-    /**
-     * Ask OpenKey to let the user change the session expiry. Forwarded only
-     * when true. The SDK accepts a changed expiry only for a request that
-     * carried this flag, and then uses the SIGNED expiry.
-     */
-    expiryChangeable?: boolean;
-}
-type NodeUserAuthorizationAuthorizeFn = (input: OpenKeyBridgeInput) => Promise<{
-    protocolVersion: 1;
-    address: string;
-    signature: string;
-    signedMessage: string;
-    selectedActionKeys: string[];
-    permissions: Array<{
-        service: string;
-        space: string;
-        path: string;
-        actions: string[];
-    }>;
-}>;
-/**
- * Wire a concrete OpenKey-shaped SDK object into the `authorizeFn`
- * `NodeUserAuthorization.signInWithOpenKey` expects. Rejects any
- * response that does not carry the canonical rich-result shape so
- * wire drift shows up at the bridge boundary rather than deep inside
- * `signInWithOpenKeyResult`.
- *
- * @example
- * ```ts
- * import { OpenKey } from '@openkey/sdk';
- * import { wireOpenKeyAuthorize } from '@tinycloud/node-sdk';
- * const openkey = new OpenKey({ appName: 'my-app' });
- * await openkey.connect();
- * const authorize = wireOpenKeyAuthorize(openkey);
- * const clientSession = await nodeAuth.signInWithOpenKey(authorize);
- * ```
- */
-declare function wireOpenKeyAuthorize(openkey: OpenKeyAuthorizeTinyCloud, opts?: {
-    mode?: "iframe" | "popup" | "redirect";
-}): NodeUserAuthorizationAuthorizeFn;
-
-type OpenKeyAuthorizeInput = OpenKeyBridgeInput;
-/** SIWE and session key prepared before an OpenKey approval click. */
-interface PreparedOpenKeyAuthorization {
-    readonly request: OpenKeyAuthorizeInput;
-    readonly prepared: PreparedOpenKeySession;
-    readonly keyId: string;
-    readonly jwk: Record<string, unknown>;
-    readonly address: string;
-    readonly chainId: number;
-    readonly generation: number;
-    readonly createdAt: number;
-    /** The app-level maximum for a changed signed expiry, if one was given. In memory only; never sent or persisted. */
-    readonly maxExpiresAt?: OpenKeyMaxExpiresAt;
-}
-/**
- * A latest acceptable signed expiry: epoch MILLISECONDS, a `Date`, or a function returning either. A function is read
- * when the OpenKey result arrives, not when the request is prepared.
- */
-type OpenKeyMaxExpiresAt = number | Date | (() => number | Date);
-type OpenKeyAuthorizationResultV1 = Awaited<ReturnType<NodeUserAuthorizationAuthorizeFn>>;
-type PreparedOpenKeySession = {
-    siwe: string;
-    jwk: Record<string, unknown>;
-    spaceId: string;
-    verificationMethod: string;
-};
-/**
- * Configuration for NodeUserAuthorization.
- */
-interface NodeUserAuthorizationConfig {
-    /** The signer used for signing messages */
-    signer: ISigner;
-    /** Sign strategy for handling sign requests */
-    signStrategy?: SignStrategy;
-    /** Session storage implementation */
-    sessionStorage?: ISessionStorage;
-    /** Domain for SIWE messages */
-    domain: string;
-    /** URI for SIWE messages (default: domain) */
-    uri?: string;
-    /** Statement included in SIWE messages */
-    statement?: string;
-    /** Space prefix for new sessions */
-    spacePrefix?: string;
-    /** Default actions for sessions */
-    defaultActions?: Record<string, Record<string, string[]>>;
-    /** Session expiration time in milliseconds (default: 30 days, `EXPIRY.SESSION_MS`) */
-    sessionExpirationMs?: number;
-    /** Automatically create space if it doesn't exist (default: false) */
-    autoCreateSpace?: boolean;
-    /** Custom space creation handler. If provided, takes precedence over autoCreateSpace. */
-    spaceCreationHandler?: ISpaceCreationHandler;
-    /** Explicit TinyCloud server endpoints. When omitted, signIn resolves the user's host. */
-    tinycloudHosts?: string[];
-    /** TinyCloud location registry URL. Default: https://registry.tinycloud.xyz. */
-    tinycloudRegistryUrl?: string | null;
-    /**
-     * Fallback TinyCloud hosts. Default: hosted TinyCloud node. Used only by the
-     * default `registryPolicy` ("legacy-fallback"), whose silent fallback is
-     * deprecated and will be removed in a future major release.
-     */
-    tinycloudFallbackHosts?: string[] | null;
-    /**
-     * How sign-in uses the location registry when no host is configured.
-     *
-     * - `"legacy-fallback"` (default, deprecated): a registry miss or failure
-     *   silently uses `tinycloudFallbackHosts`, with a one-time warning.
-     * - `"fail-closed"`: sign-in acts on the registry verdict for the signer
-     *   address. Registered owners go to their listed hosts, unregistered owners
-     *   to `newUserHost`, and an unavailable registry is
-     *   `RegistryUnavailableError`, never a new account. Automatic space
-     *   creation is refused on a host the owner's record does not list
-     *   (`NodeRegistryEntryExistsError`) or when the registry gives no verdict
-     *   (`RegistryUnavailableError`).
-     */
-    registryPolicy?: RegistryPolicy;
-    /**
-     * `fail-closed` only: host for owners with no registry record (and only
-     * them). Default https://node.tinycloud.xyz. `null` refuses them with
-     * `NodeNotFoundError`.
-     */
-    newUserHost?: string | null;
-    /**
-     * `fail-closed` only: chain ID of the v1 registry subject, which is built
-     * from the signer address, never the session chain. Default 1.
-     */
-    registryChainId?: number;
-    /** `fail-closed` only: highest registry sequence seen per owner. Default: in-memory. */
-    registrySequenceStore?: RegistrySequenceStore;
-    /**
-     * `fail-closed` only: called when sign-in resolves no host
-     * (`NodeNotFoundError` or `RegistryUnavailableError`) to retry, use another
-     * host (not identity-checked; it persists with the session), or abort.
-     * Without it, sign-in throws the error.
-     */
-    onNodeNotFound?: OnNodeNotFound;
-    /** Probe configured/registered local nodes before registry/fallback resolution. Default: true. */
-    autoDiscoverLocalNode?: boolean;
-    /** Local loopback node URL to probe. Omit to avoid probing loopback. */
-    localNodeUrl?: string;
-    /** Known `*.local.tinycloud.link` subdomain name, probed directly. */
-    localLinkName?: string;
-    /** Expected local node DID. A locally-discovered node whose DID differs is rejected. */
-    expectedNodeDid?: string;
-    /** Pin store for trust-on-first-use local node identity verification. Defaults to an in-memory store. */
-    localNodeIdentityStore?: LocalNodeIdentityStore;
-    /** Whether to include public space capabilities in the session (default: true) */
-    enablePublicSpace?: boolean;
-    /** WASM bindings for cryptographic operations. Required. */
-    wasmBindings: IWasmBindings;
-    /** Existing session manager to share with a higher-level SDK client. */
-    sessionManager?: ISessionManager;
-    /**
-     * SIWE nonce override. If omitted, the WASM layer generates a random nonce.
-     * If `siweConfig.nonce` is also provided, `siweConfig.nonce` wins.
-     */
-    nonce?: string;
-    /** Optional SIWE configuration overrides (e.g., nonce for server-provided nonces) */
-    siweConfig?: SiweConfig;
-    /**
-     * App manifest used to drive the SIWE recap at sign-in.
-     *
-     * When set, `signIn` resolves the manifest (via
-     * {@link resolveManifest}), unions the app's own permissions with
-     * every `delegations[*].permissions` list, converts to the WASM
-     * abilities shape, and uses that map as the session's granted
-     * capabilities — *instead* of `defaultActions`.
-     *
-     * This is what makes manifest-declared pre-delegations usable: the
-     * session key's recap covers both the app's runtime needs and the
-     * downstream delegation targets, so `delegateTo` can issue the
-     * sub-delegation via the session-key UCAN path without a wallet
-     * prompt.
-     *
-     * When omitted, `signIn` falls back to `defaultActions` for
-     * backwards compatibility.
-     */
-    manifest?: Manifest | Manifest[];
-    /** Pre-composed manifest request. Takes precedence over `manifest`. */
-    capabilityRequest?: ComposedManifestRequest;
-    /** Include canonical account registry read/create-update/list permissions when composing `manifest` and plain sign-in. Default true. */
-    includeAccountRegistryPermissions?: boolean;
-    /**
-     * Replication sign-in augmentation (TC-858 §4.1): prefixes whose reads a
-     * local replica may serve. For each prefix the session request gains one
-     * `kv` entry `{get, sync}` on the primary space — but only where an
-     * unrestricted `get` covering it is already requested. Storage and
-     * scheduling never reach this layer.
-     */
-    replication?: Pick<ReplicationOptions, "enabled" | "prefixes" | "allowSecrets" | "syncScope">;
-    /** Extra top-level resource URIs and their abilities added to the sign-in ReCap (e.g. named-key prefixes). */
-    additionalRawAbilities?: Record<string, string[]>;
-    /**
-     * Mints the replica session stamp on each fresh sign-in (TC-858 §4). Returns
-     * `undefined` when replication is off, so the persisted session carries no stamp.
-     */
-    establishReplicaStamp?: (session: TinyCloudSession) => Promise<PersistedSessionData["replicaStamp"]>;
-}
-interface CreateBootstrapSessionOptions {
-    spaceId: string;
-    capabilityRequest: ComposedManifestRequest;
-    rawAbilities?: Record<string, string[]>;
-}
-/**
- * Node.js implementation of IUserAuthorization.
- *
- * Supports multiple sign strategies for different use cases:
- * - auto-sign: Automatically approve all sign requests (trusted backends)
- * - auto-reject: Reject all sign requests (read-only mode)
- * - callback: Delegate to a custom callback function (CLI prompts)
- * - event-emitter: Emit sign requests as events (async workflows)
- *
- * @example
- * ```typescript
- * // Auto-sign for backend services
- * const auth = new NodeUserAuthorization({
- *   signer: new PrivateKeySigner(process.env.PRIVATE_KEY),
- *   signStrategy: { type: 'auto-sign' },
- *   domain: 'api.myapp.com',
- * });
- *
- * // Callback for CLI prompts
- * const auth = new NodeUserAuthorization({
- *   signer,
- *   signStrategy: {
- *     type: 'callback',
- *     handler: async (req) => {
- *       const approved = await promptUser(`Sign for ${req.address}?`);
- *       return { approved };
- *     }
- *   },
- *   domain: 'cli.myapp.com',
- * });
- * ```
- */
-declare class NodeUserAuthorization implements IUserAuthorization {
-    private readonly signer;
-    private readonly signStrategy;
-    private readonly sessionStorage;
-    private readonly domain;
-    private readonly uri;
-    private readonly statement?;
-    private readonly spacePrefix;
-    private readonly defaultActions;
-    private readonly sessionExpirationMs;
-    private readonly autoCreateSpace;
-    private readonly spaceCreationHandler?;
-    private tinycloudHosts?;
-    private readonly tinycloudRegistryUrl?;
-    private readonly tinycloudFallbackHosts?;
-    private readonly registryPolicy?;
-    private readonly newUserHost?;
-    private readonly registryChainId?;
-    private readonly registrySequenceStore;
-    private readonly onNodeNotFound?;
-    /** Verdict from the last `fail-closed` host resolution, reused by {@link assertMayCreateSpace}. */
-    private registryVerdict?;
-    private readonly autoDiscoverLocalNode?;
-    private readonly localNodeUrl?;
-    private readonly localLinkName?;
-    private readonly expectedNodeDid?;
-    private readonly localNodeIdentityStore?;
-    private readonly enablePublicSpace;
-    private readonly replication?;
-    private readonly additionalRawAbilities?;
-    private readonly establishReplicaStamp?;
-    private readonly nonce?;
-    private readonly siweConfig?;
-    private readonly wasm;
-    /**
-     * Stored manifest, if one was provided at construction time. Used by
-     * {@link signIn} to derive the session's granted capabilities instead
-     * of falling back to {@link defaultActions}.
-     */
-    private _manifest?;
-    private _capabilityRequest?;
-    private readonly includeAccountRegistryPermissions;
-    private sessionManager;
-    private activeSessionKeyId;
-    private preparedSessionCounter;
-    /** Incremented by resetSession; a sign-in started earlier publishes nothing. */
-    private sessionGeneration;
-    /**
-     * Sign-in saves run one at a time, in order, each together with its own
-     * cancellation cleanup, so no later write can land between the two.
-     */
-    private persistenceQueue;
-    private extensions;
-    private _session?;
-    private _tinyCloudSession?;
-    private _address?;
-    private _chainId?;
-    private _nodeFeatures;
-    private _nodeFeaturesKnown;
-    /**
-     * `nodeId` from the `GET /info` performed during sign-in/restore, tagged with
-     * the host it came from. Callers that need the node DID (encryption-network
-     * admin invocations) reuse this instead of re-fetching `/info`.
-     */
-    private _nodeInfoIdentity?;
-    private _lastActivationSkippedSpaceIds;
-    /**
-     * Spaces the sign-in activation reported hosted. Only the first POST of a
-     * delegation lists them: the node answers a repeat with empty lists.
-     */
-    private _lastActivationActivatedSpaceIds;
-    constructor(config: NodeUserAuthorizationConfig);
-    /**
-     * Return the manifest currently driving sign-in behavior, or
-     * `undefined` if none is set. Used by TinyCloudWeb/TinyCloudNode
-     * internals to surface the manifest for requestPermissions flows
-     * without forcing the caller to track it separately.
-     */
-    get manifest(): Manifest | Manifest[] | undefined;
-    get capabilityRequest(): ComposedManifestRequest | undefined;
-    get hosts(): string[];
-    /**
-     * Install or replace the stored manifest. Takes effect on the next
-     * `signIn()` call — the current session (if any) is not touched.
-     */
-    setManifest(manifest: Manifest | Manifest[] | undefined): void;
-    setCapabilityRequest(request: ComposedManifestRequest | undefined): void;
-    /**
-     * The current active session (web-core compatible).
-     */
-    get session(): ClientSession | undefined;
-    /**
-     * The current TinyCloud session with full delegation data.
-     * Includes spaceId, delegationHeader, and delegationCid.
-     */
-    get tinyCloudSession(): TinyCloudSession | undefined;
-    /**
-     * Rehydrate the auth-layer session from previously-persisted delegation
-     * data. Used by {@link TinyCloudNode.restoreSession} so that downstream
-     * surfaces that read from `tinyCloudSession` (notably
-     * `grantRuntimePermissions`, which extracts the SIWE expiry from it) work
-     * without re-running the full sign-in flow.
-     *
-     * Caller must supply the same fields that `signIn` would have written —
-     * `siwe` is the load-bearing one because `extractSiweExpiration` returns
-     * undefined for missing SIWEs and the SDK then treats the session as
-     * expired-at-epoch-zero.
-     *
-     * @param hosts - The TinyCloud hosts this session was created against,
-     *   as persisted in {@link PersistedSessionData.tinycloudHosts}. When
-     *   present (and non-empty) they are adopted directly so the restored
-     *   session resolves to the same node as the original sign-in without
-     *   re-running registry/fallback resolution. When absent (old session)
-     *   hosts are resolved lazily on the first host-needing call via
-     *   {@link ensureTinyCloudHosts}.
-     */
-    setRestoredTinyCloudSession(session: TinyCloudSession, hosts?: string[]): void;
-    /**
-     * @internal End the session: adopt a fresh session manager whose active key
-     * is `sessionKeyId`, and return to the constructed state.
-     */
-    resetSession(sessionManager: ISessionManager, sessionKeyId: string, hosts?: string[]): void;
-    /** Throws when the session was reset (signed out) after `generation` was read. */
-    private assertSignInCurrent;
-    /** Runs `task` after every earlier queued persistence task has settled. */
-    private enqueuePersistence;
-    /** @internal Atomically adopt the state staged by TinyCloudNode.restoreSession. */
-    installRestoredSession(sessionManager: ISessionManager, session: TinyCloudSession | undefined, hosts?: string[], nodeFeatures?: string[]): void;
-    /**
-     * Ensure `tinycloudHosts` are resolved before a host-needing call.
-     *
-     * Fresh sign-in resolves hosts up front; a restored session may not have
-     * (old persisted sessions predate {@link PersistedSessionData.tinycloudHosts}).
-     * This guard makes a restored session resolve the node exactly like a fresh
-     * sign-in — persisted hosts are preferred (already set by
-     * {@link setRestoredTinyCloudSession}), otherwise the registry/fallback
-     * resolution runs lazily here. Idempotent: {@link resolveTinyCloudHostsForSignIn}
-     * early-returns when hosts are already set.
-     *
-     * Throws if hosts are unset and the restored session has no address/chainId
-     * to resolve from — a real failure that must surface, not be masked.
-     */
-    ensureTinyCloudHosts(): Promise<void>;
-    private resolveTinyCloudHostsForSignIn;
-    /**
-     * Space-creation guard (TC-1443). Under `registryPolicy: "fail-closed"`,
-     * throws unless the owner's registry verdict allows a space on the primary
-     * host: `NodeRegistryEntryExistsError` when the owner's record does not
-     * list it, `RegistryUnavailableError` when the registry gives no
-     * verdict. Reuses this session's sign-in verdict unless it was
-     * `unavailable`, else looks it up now (explicit-host apps). Under the
-     * default policy it returns at once and performs no lookup.
-     */
-    assertMayCreateSpace(): Promise<void>;
-    private requireTinyCloudHosts;
-    private get primaryTinyCloudHost();
-    get nodeFeatures(): string[];
-    get nodeFeaturesKnown(): boolean;
-    refreshNodeInfo(): Promise<void>;
-    /**
-     * The node DID reported by `GET /info` for `host`, if the sign-in (or
-     * restore) that populated it targeted that same host. Returns `undefined`
-     * for any other host, and for nodes whose `/info` omits `nodeId`, so callers
-     * fall back to fetching it themselves rather than using a foreign node's DID.
-     */
-    nodeIdForHost(host: string): string | undefined;
-    get lastActivationSkippedSpaceIds(): string[];
-    get lastActivationActivatedSpaceIds(): string[];
-    /**
-     * Compute the `abilities` map the WASM `prepareSession` call should
-     * see at sign-in time.
-     *
-     * When a manifest is installed, we resolve it and union together:
-     * - the app's own `resources` (what it needs at runtime)
-     * - every `additionalDelegates[*].permissions` list (what it will
-     *   re-delegate to other DIDs post sign-in)
-     *
-     * into the short-service / path / full-URN-actions shape the WASM
-     * layer expects. This is the key invariant that lets
-     * {@link TinyCloudNode.delegateTo} issue manifest-declared
-     * delegations via the session key (no wallet prompt): the session's
-     * own recap already covers every action those delegations need.
-     *
-     * When no manifest is installed, we fall back to the
-     * {@link defaultActions} table so existing callers see no change.
-     *
-     * This is a pure function of `this._manifest` + `this.defaultActions`
-     * — the manifest resolution performs no I/O and throws a
-     * {@link ManifestValidationError} on structural problems (missing
-     * id/name, unparseable expiry, etc), which will surface at sign-in
-     * rather than being silently swallowed.
-     *
-     * @internal
-     */
-    private getCapabilityRequest;
-    private refreshNamedKeyFeatureForSignIn;
-    /** Manifest key paths that this sign-in cannot grant. */
-    get unavailableKeyPaths(): string[];
-    private resolveSpaceName;
-    /**
-     * The plain-session primary abilities: `defaultActions` (the shared table)
-     * unless the primary space IS the account space, where account-registry
-     * permissions merge into a private clone so the shared table is never
-     * mutated. Shared between `resolveSignInCapabilities` and
-     * `signInPermissionInputs` so sign-in and `replicationSignInEntries`
-     * can't disagree (§4.6).
-     */
-    private primaryActionsForSignIn;
-    /**
-     * The abilities a `spacePrefix: "secrets"` plain session actually requests
-     * for its primary space: the vault-secrets subtree only — the
-     * `defaultActions` root `get` is REPLACED, not merged (sign-in installs
-     * this map under the primary space id). Shared between
-     * `resolveSignInCapabilities` and `signInPermissionInputs` so the
-     * replication augmentation measures coverage against the effective
-     * pre-replication request, never the uninstalled `primaryActions` (§4.1).
-     */
-    private secretsPrimaryAbilities;
-    /**
-     * The effective sign-in request as `PermissionEntry`s plus the resolved
-     * primary space id — the inputs to the replication augmentation (§4.1).
-     * `resolveSignInCapabilities` merges the augmented entries into its
-     * abilities; `replicationSignInEntries()` returns them verbatim, so the
-     * entries the SIWE recap carries and the restore check sees are the same.
-     */
-    private signInPermissionInputs;
-    /**
-     * Merge replication augmentation entries into a space's abilities map
-     * without mutating shared tables (`defaultActions` may back the base map):
-     * the primary entry in `spaceAbilities` is replaced with a copy whose `kv`
-     * paths gain `get`/`sync`. Returns the merged map for `abilities`.
-     */
-    private mergeReplicationEntries;
-    /**
-     * The replication entries this authorization's sign-in request carries
-     * for the signed-in or restored address (TC-858 §4.1/§4.6): the output of
-     * the same augmentation `resolveSignInCapabilities` runs — one
-     * `{tinycloud.kv, primarySpace, prefix, [get, sync]}` per configured
-     * prefix that already has an unrestricted covering `get` and passes the
-     * secrets opt-in gate. Empty when replication is off or no address is
-     * known. Pure.
-     */
-    replicationSignInEntries(): PermissionEntry[];
-    private defaultEncryptionNetworkId;
-    /** Sign-in capabilities plus the caller's additional top-level resource abilities. */
-    private resolveSignInCapabilities;
-    private resolveBaseSignInCapabilities;
-    /**
-     * Build SIWE overrides from the top-level nonce and siweConfig.
-     * - Top-level `nonce` is seeded first so `siweConfig.nonce` wins if both are set.
-     * - resources are inserted after WASM preparation, before the final ReCap
-     * - uri triggers a warning (overwriting delegation target)
-     * - all other fields override directly
-     * - per-call nonce overrides siweConfig.nonce when provided
-     */
-    private buildSiweOverrides;
-    private prepareSessionWithResources;
-    /**
-     * Add an extension to the authorization flow.
-     */
-    extend(extension: Extension): void;
-    /**
-     * Get the space ID for the current session.
-     */
-    getSpaceId(): string | undefined;
-    /**
-     * Create the space on the TinyCloud server (host delegation).
-     * This registers the user as the owner of the space.
-     */
-    private hostSpace;
-    /**
-     * Create a specific space on the server via host delegation.
-     * Used for lazy creation of additional spaces (e.g., public).
-     */
-    hostPublicSpace(spaceId: string): Promise<boolean>;
-    /**
-     * Create a specific owned space on the server via host delegation.
-     * Used by manifest registry setup for the account space.
-     */
-    hostOwnedSpace(spaceId: string, purpose?: SignRequest["purpose"]): Promise<boolean>;
-    /**
-     * {@link hostOwnedSpace} with the full host-delegation result, so a failure
-     * keeps its HTTP status (e.g. a typed 401/403) instead of collapsing to
-     * `false`.
-     */
-    hostOwnedSpaceResult(spaceId: string, purpose?: SignRequest["purpose"], signal?: AbortSignal): Promise<SpaceHostResult>;
-    /**
-     * Ensure the user's space exists on the TinyCloud server.
-     * Creates the space if it doesn't exist and autoCreateSpace is enabled.
-     * If autoCreateSpace is false and space doesn't exist, silently returns
-     * (user may be using delegations to access other spaces).
-     *
-     * @throws Error if space creation fails
-     */
-    ensureSpaceExists(): Promise<void>;
-    /** {@link assertMayCreateSpace}, reporting a refusal to the creation handler before rethrowing it. */
-    private guardSpaceCreation;
-    private recordActivationSkippedSpaces;
-    createBootstrapSession(options: CreateBootstrapSessionOptions): Promise<TinyCloudSession>;
-    /**
-     * When a session that starts at `now` ends. Refused with a dated message when
-     * the configured lifetime reaches past what a sign-in message can carry,
-     * instead of the bare `RangeError` or WASM parse error `toISOString()` and
-     * `prepareSession` would otherwise give.
-     */
-    private sessionExpiryFrom;
-    private persistedData;
-    /**
-     * Sign in and create a new session.
-     *
-     * This follows the correct SIWE-ReCap flow:
-     * 1. Create session key and get JWK
-     * 2. Call prepareSession() which generates the SIWE with ReCap capabilities
-     * 3. Sign the SIWE string from prepareSession
-     * 4. Call completeSessionSetup() with the prepared session + signature
-     *
-     * @param options - Optional per-call SIWE overrides for this sign-in only
-     */
-    signIn(options?: SignInOptions): Promise<ClientSession>;
-    /**
-     * Sign out and clear the current session.
-     */
-    signOut(): Promise<void>;
-    /**
-     * Get the current wallet/signer address.
-     */
-    address(): string | undefined;
-    /**
-     * Get the current chain ID.
-     */
-    chainId(): number | undefined;
-    /**
-     * Sign a message with the connected signer.
-     */
-    signMessage(message: string, purpose?: SignRequest["purpose"]): Promise<string>;
-    /**
-     * Prepare a session for external signing.
-     *
-     * Use this method when you need to sign the SIWE message externally (e.g., via
-     * a hardware wallet, multi-sig, or external service). After obtaining the signature,
-     * call `signInWithPreparedSession()` to complete the sign-in.
-     *
-     * @example
-     * ```typescript
-     * const { prepared, keyId, jwk } = await auth.prepareSessionForSigning();
-     * const signature = await externalSigner.signMessage(prepared.siwe);
-     * const session = await auth.signInWithPreparedSession(prepared, signature, keyId, jwk);
-     * ```
-     */
-    prepareSessionForSigning(): Promise<{
-        prepared: {
-            siwe: string;
-            jwk: Record<string, unknown>;
-            spaceId: string;
-            verificationMethod: string;
-        };
-        keyId: string;
-        jwk: Record<string, unknown>;
-        address: string;
-        chainId: number;
-    }>;
-    /**
-     * Complete sign-in with a prepared session and signature.
-     *
-     * Use this method after obtaining a signature for the SIWE message from
-     * `prepareSessionForSigning()`. The signature MUST be over `prepared.siwe`.
-     *
-     * @param prepared - The prepared session from `prepareSessionForSigning()`
-     * @param signature - The signature over `prepared.siwe`
-     * @param keyId - The session key ID from `prepareSessionForSigning()`
-     * @param jwk - The JWK from `prepareSessionForSigning()`
-     */
-    signInWithPreparedSession(prepared: {
-        siwe: string;
-        jwk: Record<string, unknown>;
-        spaceId: string;
-        verificationMethod: string;
-    }, signature: string, keyId: string, jwk: Record<string, unknown>): Promise<ClientSession>;
-    /**
-     * End-to-end sign-in via OpenKey `authorizeTinyCloud()` (Sol CRITICAL-4).
-     *
-     * This is the production entry point that wires
-     * {@link prepareSessionForSigning} → OpenKey `authorizeTinyCloud()` →
-     * {@link signInWithOpenKeyResult} into one call. Consumers pass in a
-     * caller-provided `authorizeFn` (typically a thin wrapper around
-     * `openkey.authorizeTinyCloud()`) so this method has no direct
-     * dependency on the OpenKey SDK — it works with any transport that
-     * conforms to the versioned protocol.
-     *
-     * The `authorizeFn` MUST:
-     *   1. Send the prepared SIWE bytes to OpenKey.
-     *   2. Return the exact `TinyCloudAuthorizationResultV1` shape (with
-     *      `signedMessage` — the bytes the signature actually verifies
-     *      against — plus `selectedActionKeys` and `permissions`).
-     *
-     * NodeUserAuthorization then completes the session with `signedMessage`
-     * (never the prepared bytes), verifying the signature, the immutable
-     * SIWE fields, and every subset invariant enforced by
-     * {@link signInWithOpenKeyResult}. This preserves the exact-byte
-     * guarantee: if the user did NOT narrow, the returned `signedMessage`
-     * equals the prepared SIWE byte-for-byte; if the user narrowed, only
-     * the ReCap block differs and every immutable header field survives.
-     *
-     * Legacy exact-byte {@link signIn} callers are unaffected — this method
-     * is opt-in.
-     *
-     * @param authorizeFn Callback that invokes the versioned OpenKey
-     *   `authorizeTinyCloud()` protocol and returns the result. Receives
-     *   the prepared SIWE bytes plus a `host` hint the widget should bind
-     *   into its /authorize-sign-prepare context.
-     * @param options Optional overrides for the OpenKey request.
-     */
-    signInWithOpenKey(authorizeFn: NodeUserAuthorizationAuthorizeFn, options?: {
-        host?: string;
-        openkeyKeyId?: string;
-        /** Caller-supplied display reason, not signed authority. */
-        reason?: string;
-        /**
-         * Let the user change the session expiry in the OpenKey approval. Sent
-         * to OpenKey as `expiryChangeable: true` (`@openkey/sdk` >= 0.13.0
-         * (beta: 0.13.0-beta.0) forwards it; 0.12.x ignores it). The SIGNED
-         * expiry is then the session's expiry.
-         */
-        expiryChangeable?: boolean;
-        /**
-         * The latest signed expiry the caller will accept, used only with `expiryChangeable`: a signed expiry beyond it
-         * is refused before any session is built, stored or activated. Epoch MILLISECONDS or a `Date`; a function is
-         * called when the result arrives (so a slow approval does not count against it) and returns either. It is not
-         * sent to OpenKey and not persisted. It limits a CHANGED expiry only: an expiry equal to the one this SDK
-         * requested is accepted, so keep the configured session lifetime within the maximum.
-         */
-        maxExpiresAt?: OpenKeyMaxExpiresAt;
-        /**
-         * Supply another candidate without regenerating the SIWE or session key.
-         * Called only after transport or pre-commit verification rejects a result.
-         * Return null to cancel; activation errors are never signing retries.
-         */
-        retryResult?: (error: Error, originalRequest: OpenKeyAuthorizeInput, attempt: number) => Promise<OpenKeyAuthorizationResultV1 | null>;
-    }): Promise<ClientSession>;
-    /** Finish address, host and SIWE preparation before an approval click. */
-    prepareOpenKeySignIn(options?: Parameters<NodeUserAuthorization["signInWithOpenKey"]>[1]): Promise<PreparedOpenKeyAuthorization>;
-    /** Complete a prepared approval. The caller starts authorization before awaiting this method. */
-    completeOpenKeySignIn(pending: PreparedOpenKeyAuthorization, authorization: Promise<OpenKeyAuthorizationResultV1>, options?: Parameters<NodeUserAuthorization["signInWithOpenKey"]>[1]): Promise<ClientSession>;
-    /**
-     * Build a `CapabilityPresentationEnvelopeV1` from `this._manifest`. The
-     * envelope is display-only — the OpenKey widget renders it under an
-     * honest trust label, and the server /authorize-sign-prepare route
-     * decides whether to upgrade the label to `origin-bound` by fetching
-     * the well-known manifest and comparing its digest to
-     * `manifestDigest`.
-     *
-     * Returns `undefined` when no manifest is set — the widget renders as
-     * "no manifest supplied" (unsigned).
-     *
-     * The digest is a deterministic SHA-256 over canonical JSON of the
-     * first manifest payload; OpenKey parses the fetched well-known manifest
-     * and applies the same canonicalization before comparing digests.
-     */
-    private buildPresentationEnvelope;
-    /**
-     * Complete sign-in with a versioned OpenKey authorization result.
-     *
-     * Where `signInWithPreparedSession` completes with a signature over the
-     * ORIGINAL prepared SIWE, this method completes with the SIWE bytes the
-     * OpenKey widget actually presented and signed (`signedMessage`). It
-     * exists because the versioned authorizeTinyCloud protocol lets the user
-     * narrow capabilities; the returned bytes may differ from the original
-     * request and are the only ones the signature actually verifies against.
-     *
-     * The `result` parameter is validated at the trust boundary via
-     * `validateAuthorizationResultV1` (in sdk-core). Callers should validate
-     * BEFORE calling this method so unknown/missing fields are rejected
-     * before any session state is created.
-     *
-     * Validation performed here (defence-in-depth: even a "valid" v1 payload
-     * must clear these checks before any session state is created):
-     * 1. `result.address` matches the local signer's address.
-     * 2. `result.signature` recovers to `result.address` when verified against
-     *    `result.signedMessage`.
-     * 3. Every immutable SIWE header field (domain, address, URI, version,
-     *    chainId, nonce, issuedAt) in the original prepared SIWE is preserved
-     *    byte-for-byte in `result.signedMessage`. `statement` is NOT in this
-     *    list because the WASM renders it from the ReCap contents; it MUST
-     *    change when the ReCap is narrowed.
-     * 4. Every capability in `result.signedMessage`'s ReCap block was present
-     *    in the original prepared SIWE — narrowing OK, broadening rejected.
-     * 5. Every `result.selectedActionKeys` entry corresponds to a
-     *    (resource, action) pair in the returned SIWE.
-     *
-     * `options.expiryChangeable` is true only when the request sent to OpenKey
-     * carried `expiryChangeable: true`. Then (and only then) the signed
-     * `Expiration Time` may differ from the prepared one and is the expiry the
-     * session is built with; the changed expiry must pass
-     * `checkChangedExpiration` and every other field in (3) must still match.
-     * Without it, any expiry difference is refused as in (3).
-     */
-    signInWithOpenKeyResult(result: OpenKeyAuthorizationResultV1, prepared: PreparedOpenKeySession, keyId: string, jwk: Record<string, unknown>, options?: {
-        expiryChangeable?: boolean;
-        maxExpiresAt?: OpenKeyMaxExpiresAt;
-    }): Promise<ClientSession>;
-    /** Validate a candidate without activating a network session, so paste retries reuse one preparation. */
-    private verifyOpenKeyResult;
-    /**
-     * Clear persisted session data. With `ownSignature`, a stored session that provably has a different
-     * signature (a newer sign-in for the same address) is left alone.
-     */
-    clearPersistedSession(address?: string, ownSignature?: string): Promise<void>;
-    /**
-     * Check if a session is persisted for an address.
-     */
-    isSessionPersisted(address: string): boolean;
-    /**
-     * Request a signature based on the configured strategy.
-     */
-    private requestSignature;
-    /**
-     * Request signature via event emitter with timeout.
-     */
-    private requestSignatureViaEmitter;
-}
+import { S as SpaceHosting, c as SignStrategy, a as NodeUserAuthorization, P as PreparedOpenKeyAuthorization } from './NodeUserAuthorization-BtoDI9in.js';
+import { P as PortableDelegation, S as SessionGrantProof, e as VerifiedSessionGrant } from './delegation-BQbAuKad.js';
 
 /**
  * The handles needed to rehydrate this delegation activation in a fresh
@@ -1418,6 +547,8 @@ declare class TinyCloudNode {
      * hosting is confirmed against the session that was active at the time.
      */
     private readonly confirmedHostedSpaceIds;
+    /** The primary space's hosting answer when no authorization layer holds it (a session-only restore). */
+    private _restoredSpaceHosting;
     /**
      * Owned space ids known to be hosted for the current session: the sign-in
      * activation listed them as `activated`, or this session hosted them. Unlike
@@ -1550,6 +681,30 @@ declare class TinyCloudNode {
      */
     get storage(): IStorageService;
     private readStorageStatus;
+    /**
+     * Whether the TinyCloud node hosts the primary space (the default) or a named
+     * or full-id space: `"hosted"`, `"not-hosted"`, or `"unknown"` when the node
+     * cannot say.
+     *
+     * Sends one authorized read the session already holds on that space (a kv
+     * list under a granted prefix, else kv metadata, `tinycloud.space/info`, or
+     * a kv get of a key that does not exist), signed for that space. A session
+     * with no such read sends nothing and answers `unknown`. A 401/403 registers
+     * the session delegation with the node once and asks again once. Network
+     * failures, 5xx and a 5 s timeout answer `unknown`; this never throws.
+     *
+     * `hosted` is remembered for the session and `not-hosted` never is. The
+     * answer for the primary space is also what {@link spaceHosting} reports; a
+     * `unknown` answer leaves the previous one in place.
+     */
+    checkSpaceHosting(space?: string): Promise<SpaceHosting>;
+    /**
+     * The node's last answer for the primary space: recorded at sign-in from the
+     * activation, or by {@link checkSpaceHosting}. `unknown` after a restore until
+     * something asks.
+     */
+    get spaceHosting(): SpaceHosting;
+    private probeSpaceHosting;
     private get nodeFeatures();
     private get replicationNodeFeatures();
     /** SIWE domain — uses config override or defaults to app.tinycloud.xyz */
@@ -2818,4 +1973,4 @@ declare class TinyCloudNode {
     }): Promise<PortableDelegation>;
 }
 
-export { ACCEPTED_MARKER_VERSIONS as A, type BootstrapWarning as B, type CreateOwnerDelegationParams as C, type DelegateToOptions as D, type EnsureEncryptionNetworkOptions as E, InvalidRestoredSessionError as I, type NodeEventEmitterStrategy as N, type OpenKeyAuthorizeTinyCloud as O, type PreparedOpenKeyAuthorization as P, type RuntimePermissionGrantOptions as R, type SecretPermissionHint as S, TinyCloudNode as T, type UnifiedOwnerRootInput as U, type DelegateToResult as a, DelegatedAccess as b, NodeUserAuthorization as c, type NodeUserAuthorizationConfig as d, type OwnerDelegationReceipt as e, type SecretReadInput as f, type SecretReadResult as g, type SignStrategy as h, type TinyCloudNodeConfig as i, type UnifiedOwnerRootReceipt as j, UnsupportedSessionRestoreError as k, defaultSignStrategy as l, BOOTSTRAP_COMPLETION_MARKER_KEY as m, BOOTSTRAP_COMPLETION_MARKER_VERSION as n, type BootstrapCompletionMarker as o, type NodeUserAuthorizationAuthorizeFn as p, type OpenKeyAuthorizationResultV1 as q, type OpenKeyAuthorizeInput as r, type OpenKeyBridgeInput as s, type RestorableSession as t, wireOpenKeyAuthorize as w };
+export { ACCEPTED_MARKER_VERSIONS as A, type BootstrapWarning as B, type CreateOwnerDelegationParams as C, type DelegateToOptions as D, type EnsureEncryptionNetworkOptions as E, InvalidRestoredSessionError as I, type OwnerDelegationReceipt as O, type RuntimePermissionGrantOptions as R, type SecretPermissionHint as S, TinyCloudNode as T, type UnifiedOwnerRootInput as U, type DelegateToResult as a, DelegatedAccess as b, type SecretReadInput as c, type SecretReadResult as d, type TinyCloudNodeConfig as e, type UnifiedOwnerRootReceipt as f, UnsupportedSessionRestoreError as g, BOOTSTRAP_COMPLETION_MARKER_KEY as h, BOOTSTRAP_COMPLETION_MARKER_VERSION as i, type BootstrapCompletionMarker as j, type RestorableSession as k };