@tinycloud/web-sdk 2.11.0 → 3.0.0-beta.0

package/dist/adapters/BrowserENSResolver.d.ts

@@ -1,8 +1,8 @@
 import { IENSResolver } from "@tinycloud/sdk-core";
-import { providers } from "ethers";
+import type { BrowserWalletProvider } from "./browserProvider";
 export declare class BrowserENSResolver implements IENSResolver {
-    private provider;
-    constructor(provider: providers.Web3Provider);
+    private readonly provider;
+    constructor(provider: BrowserWalletProvider);
     resolveAddress(ensName: string): Promise<string | null>;
     resolveName(address: string): Promise<string | null>;
     resolveAvatar(ensName: string): Promise<string | null>;

package/dist/adapters/BrowserWalletSigner.d.ts

@@ -1,23 +1,22 @@
 import { ISigner, Bytes } from "@tinycloud/sdk-core";
-import { providers } from "ethers";
+import { type BrowserProvider, type BrowserWalletProvider } from "./browserProvider";
 /**
- * Browser wallet signer that wraps ethers.js Web3Provider.
+ * Browser wallet signer that wraps an EIP-1193 provider.
  * Supports MetaMask, WalletConnect, and any EIP-1193 provider.
  *
- * The wallet popup is triggered implicitly by ethers.js when
- * signMessage() is called -- no separate "strategy" type needed.
+ * The wallet popup is triggered by eth_requestAccounts when getAddress() is
+ * called -- no separate "strategy" type needed.
  */
 export declare class BrowserWalletSigner implements ISigner {
     private provider;
-    private signer;
     private cachedAddress?;
     private cachedChainId?;
-    constructor(externalProvider: providers.ExternalProvider | providers.Web3Provider);
+    constructor(provider: BrowserWalletProvider);
     getAddress(): Promise<string>;
     getConnectedAddress(): Promise<string | undefined>;
     getChainId(): Promise<number>;
     signMessage(message: Bytes | string): Promise<string>;
-    /** Get the underlying ethers.js Web3Provider (for advanced use) */
-    getProvider(): providers.Web3Provider;
+    /** Get the underlying EIP-1193 provider (for advanced use). */
+    getProvider(): BrowserProvider;
 }
 //# sourceMappingURL=BrowserWalletSigner.d.ts.map

package/dist/adapters/browserProvider.d.ts

@@ -0,0 +1,6 @@
+import type { EIP1193Provider } from "viem";
+/** The EIP-1193 provider supplied by an injected wallet. */
+export type BrowserWalletProvider = EIP1193Provider;
+/** The EIP-1193 provider used by the browser-facing SDK. */
+export type BrowserProvider = EIP1193Provider;
+//# sourceMappingURL=browserProvider.d.ts.map

package/dist/adapters/index.d.ts

@@ -1,4 +1,5 @@
 export { BrowserWalletSigner } from "./BrowserWalletSigner";
+export { type BrowserProvider, type BrowserWalletProvider, } from "./browserProvider";
 export { BrowserSessionStorage } from "./BrowserSessionStorage";
 export type { BrowserSessionLoadResult, BrowserSessionLoadStatus, BrowserSessionStorageOptions, } from "./BrowserSessionStorage";
 export { BrowserENSResolver } from "./BrowserENSResolver";

package/dist/credentials/browser.d.ts

@@ -1,12 +1,12 @@
 import type { CredentialFlowDescriptor } from "@tinycloud/sdk-core";
-import type { CredentialInteractionAdapter, CredentialRedirectResumeState, CredentialRedirectStore } from "./types";
+import type { CredentialBrowserInteractionAdapter, CredentialInlineInteractionAdapter, CredentialInteractionSurface, CredentialRedirectResumeState, CredentialRedirectStore } from "./types";
 interface BrowserSurface {
     readonly opener: Window;
     open(url: string): Window | null;
     redirect(url: string): void;
 }
 /** Exact-origin, locator-only browser interaction. Messages are non-secret wake signals. */
-export declare class BrowserCredentialInteraction implements CredentialInteractionAdapter {
+export declare class BrowserCredentialInteraction implements CredentialBrowserInteractionAdapter {
     private readonly surface;
     readonly kind: "popup" | "redirect";
     constructor(kind?: "popup" | "redirect", surface?: BrowserSurface);
@@ -20,6 +20,22 @@ export declare class BrowserCredentialInteraction implements CredentialInteracti
         closed: () => boolean;
     }>;
 }
+/**
+ * Adapter for a host application's in-page acquisition view. It intentionally
+ * exposes no OpenCredentials locator or verifier to the host: the host can
+ * render an accessible local proof form, but only the SDK may submit that
+ * proof to OpenCredentials.
+ */
+export declare class InlineCredentialInteraction implements CredentialInlineInteractionAdapter {
+    private readonly present;
+    readonly kind: "inline";
+    constructor(present: (input: {
+        readonly signal?: AbortSignal;
+    }) => Promise<CredentialInteractionSurface>);
+    start(input: {
+        signal?: AbortSignal;
+    }): Promise<CredentialInteractionSurface>;
+}
 /** Request-scoped redirect continuation. It stores no TinyCloud session or key material. */
 export declare class BrowserCredentialRedirectStore implements CredentialRedirectStore {
     private readonly storage;

package/dist/credentials/element.d.ts

@@ -0,0 +1,42 @@
+import { type CredentialFlowDescriptor } from "@tinycloud/sdk-core";
+import type { CredentialAcquisitionTheme, CredentialInteractionSurface, InlineCredentialProofRequest, PrimitiveStepResult } from "./types";
+export declare const TINYCLOUD_CREDENTIAL_ACQUISITION_TAG = "tinycloud-credential-acquisition";
+declare const ElementBase: typeof HTMLElement;
+/** SDK-owned Shadow-DOM view. It is deliberately unaware of locators, verifiers, sessions, and transport. */
+export declare class TinyCloudCredentialAcquisitionElement extends ElementBase {
+    private root?;
+    private resolver?;
+    private rejecter?;
+    private closed;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    configure(theme?: CredentialAcquisitionTheme): void;
+    requestProof(request: InlineCredentialProofRequest): Promise<PrimitiveStepResult>;
+    report(state: "signing" | "verifying" | "saving" | "success" | "recovery", message?: string): void;
+    finish(): void;
+    cancel(): void;
+    isClosed(): boolean;
+    private renderShell;
+    private renderPrompt;
+}
+/** Registers the element once in a browser document. */
+export declare function defineTinyCloudCredentialAcquisitionElement(): void;
+/** Controller that turns the SDK element into the safe low-level inline interaction surface. */
+export declare class CredentialAcquisitionController {
+    private readonly options;
+    private element?;
+    constructor(options: {
+        readonly descriptor: CredentialFlowDescriptor;
+        readonly mountTarget?: Element | string;
+        readonly theme?: CredentialAcquisitionTheme;
+    });
+    start(input: {
+        readonly signal?: AbortSignal;
+    }): Promise<CredentialInteractionSurface>;
+    progress(state: "signing" | "verifying" | "saving" | "success" | "recovery"): void;
+    finish(): void;
+    fail(): void;
+    private target;
+}
+export {};
+//# sourceMappingURL=element.d.ts.map

package/dist/credentials/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./browser";
+export * from "./element";
 export * from "./interpreter";
 export * from "./renderer";
 export * from "./service";

package/dist/credentials/interpreter.d.ts

@@ -1,5 +1,5 @@
 import { type CredentialFlowDescriptor, type CredentialProgressEvent, type CredentialRequirement } from "@tinycloud/sdk-core";
-import type { CredentialAcquisitionTransport, CredentialSigningAdapter, PrimitiveStepHandler } from "./types";
+import type { CredentialAcquisitionTransport, CredentialSigningAdapter, InlineCredentialProofHandler, PrimitiveStepHandler } from "./types";
 /** Finite step interpreter. Dispatch is exclusively by registered primitive and version. */
 export declare function interpretCredentialFlow(input: {
     readonly descriptor: CredentialFlowDescriptor;
@@ -12,6 +12,11 @@ export declare function interpretCredentialFlow(input: {
     readonly openerOrigin: string;
     readonly transport: CredentialAcquisitionTransport;
     readonly signing: CredentialSigningAdapter;
+    /**
+     * Fallback for a host-owned surface. It receives every declared proof step,
+     * including primitives added by a later protocol version.
+     */
+    readonly proofHandler?: InlineCredentialProofHandler;
     readonly handlers?: Partial<Record<"collect_input" | "mailbox_otp", PrimitiveStepHandler>>;
     readonly signal?: AbortSignal;
     readonly onProgress?: (event: CredentialProgressEvent) => void;

package/dist/credentials/service.d.ts

@@ -1,6 +1,6 @@
 import { type CredentialFlowDescriptor, type CredentialIssuerMetadata, type CredentialRequirement, type IssuedCredentialEnvelope, type StoredCredentialRecord, type VerifiedCredential } from "@tinycloud/sdk-core";
 import { OpenCredentialsHttpTransport } from "./transport";
-import type { CredentialClient, CredentialsAcquireOptions, CredentialsEnsureOptions, CredentialsEnsureResult, CredentialsOperationOptions } from "./types";
+import type { CredentialClient, CredentialsAcquireOptions, CredentialsEnsureOptions, CredentialsEnsureResult, CredentialsOperationOptions, CredentialsPolicyAdmissionOptions, CredentialsPolicyAdmissionResult } from "./types";
 export declare class CredentialsService {
     private readonly client;
     constructor(client: CredentialClient);
@@ -21,5 +21,6 @@ export declare class CredentialsService {
     }>;
     acquire(requirementValue: CredentialRequirement, options: CredentialsAcquireOptions): Promise<VerifiedCredential>;
     ensure(requirementValue: CredentialRequirement, options: CredentialsEnsureOptions): Promise<CredentialsEnsureResult>;
+    admitPolicy(options: CredentialsPolicyAdmissionOptions): Promise<CredentialsPolicyAdmissionResult>;
 }
 //# sourceMappingURL=service.d.ts.map

package/dist/credentials/types.d.ts

@@ -1,4 +1,5 @@
-import type { ClientSession, CredentialFlowDescriptor, CredentialHolderBinding, CredentialIssuerMetadata, CredentialProgressEvent, CredentialRequirement, CredentialStorageReceipt, IssuedCredentialEnvelope, IKVService, StoredCredentialRecord, VerifiedCredential } from "@tinycloud/sdk-core";
+import type { ClientSession, CredentialFlowDescriptor, CredentialHolderBinding, CredentialIssuerMetadata, CredentialProgressEvent, CredentialRequirement, CredentialStorageReceipt, IssuedCredentialEnvelope, IKVService, StoredCredentialRecord, VerifiedCredential, PolicyCredentialAdmissionV3, UnifiedPolicyCapability, UnifiedPolicyV2 } from "@tinycloud/sdk-core";
+import type { ValidatedRuntimeDelegation } from "@tinycloud/node-sdk/core";
 export interface CredentialClient {
     readonly sessionDid: string;
     readonly credentialHolderDid: string;
@@ -7,9 +8,19 @@ export interface CredentialClient {
     signSessionBytes(bytes: Uint8Array): Promise<Uint8Array>;
     autoSignCredentialBytes?(bytes: Uint8Array): Promise<Uint8Array | undefined>;
     approveCredentialBytes?(bytes: Uint8Array): Promise<Uint8Array>;
+    activateCompactRuntimeDelegation?(input: {
+        readonly authorization: string;
+        readonly cid: string;
+        readonly host: string;
+    }): Promise<ValidatedRuntimeDelegation>;
     ensureOwnedSpaceHosted(name: string): Promise<string>;
     credentialSpaceOwnerDid(spaceId: string): string;
     kvForSpace(spaceId: string): IKVService;
+    /**
+     * Root authorization CID of the active account session. Exposed here rather
+     * than on {@link ClientSession} so the CID stays out of the public session.
+     */
+    accountAuthorizationCid(): string;
 }
 export interface CredentialSigningAdapter {
     /** Return undefined when the existing exact-request auto-sign policy does not apply. */
@@ -25,18 +36,61 @@ export type PrimitiveStepHandler = (input: {
     readonly constraints: Readonly<Record<string, unknown>>;
     readonly signal?: AbortSignal;
 }) => Promise<PrimitiveStepResult>;
-export interface CredentialInteractionAdapter {
-    readonly kind: "popup" | "redirect" | "headless";
+/**
+ * The bounded view a host-owned inline surface may receive. It deliberately
+ * excludes requirement values, which can contain private policy inputs.
+ */
+export interface InlineCredentialProofRequest {
+    readonly stepId: string;
+    readonly constraints: Readonly<Record<string, unknown>>;
+    readonly display: {
+        readonly title: string;
+        readonly description: string;
+        readonly consent: string;
+        readonly progressLabel: string;
+        readonly errorLiveRegion: "assertive";
+    };
+    readonly inputs: readonly {
+        readonly id: string;
+        readonly label: string;
+        readonly schema: CredentialFlowDescriptor["inputs"][number]["schema"];
+    }[];
+    readonly signal?: AbortSignal;
+}
+export type InlineCredentialProofHandler = (input: InlineCredentialProofRequest) => Promise<PrimitiveStepResult>;
+export type CredentialInteractionKind = "popup" | "redirect" | "headless" | "inline";
+export interface CredentialInteractionSurface {
+    readonly wake: () => Promise<void>;
+    readonly close: () => void;
+    readonly closed: () => boolean;
+    /**
+     * A bounded, local UI callback for a declared primitive step. The adapter
+     * returns user-entered proof bytes to the SDK; it never receives an
+     * acquisition locator, request verifier, or transport capability.
+     */
+    readonly requestProof?: InlineCredentialProofHandler;
+}
+/** A browser-owned interaction that navigates to the OpenCredentials locator. */
+export interface CredentialBrowserInteractionAdapter {
+    readonly kind: Exclude<CredentialInteractionKind, "inline">;
     start(input: {
         readonly interaction: CredentialFlowDescriptor["interaction"];
         readonly locator: string;
         readonly signal?: AbortSignal;
-    }): Promise<{
-        readonly wake: () => Promise<void>;
-        readonly close: () => void;
-        readonly closed: () => boolean;
-    }>;
+    }): Promise<CredentialInteractionSurface>;
 }
+/**
+ * A host-owned, in-page acquisition surface. It intentionally receives no
+ * OpenCredentials locator, request verifier, or transport capability. The SDK
+ * owns every OpenCredentials request, including submission of returned proof.
+ */
+export interface CredentialInlineInteractionAdapter {
+    readonly kind: "inline";
+    start(input: {
+        readonly signal?: AbortSignal;
+    }): Promise<CredentialInteractionSurface>;
+}
+export type CredentialInteractionAdapter = CredentialBrowserInteractionAdapter | CredentialInlineInteractionAdapter;
 export interface CredentialRedirectResumeState {
     readonly type: "TinyCloudCredentialRedirectResume";
     readonly version: 1;
@@ -106,8 +160,16 @@ export interface CredentialsOperationOptions {
     readonly now?: () => Date;
 }
 export interface CredentialsAcquireOptions extends CredentialsOperationOptions {
-    readonly interaction?: "popup" | "redirect" | "headless";
+    /**
+     * `inline` mounts the first-party TinyCloud element unless a bounded local
+     * proof adapter is explicitly supplied.
+     */
+    readonly interaction?: CredentialInteractionKind;
     readonly browser?: CredentialInteractionAdapter;
+    /** An element or selector inside the current document for the SDK-owned UI. */
+    readonly mountTarget?: Element | string;
+    /** Presentation-only tokens. Security-critical copy and proof order are fixed by the descriptor. */
+    readonly theme?: CredentialAcquisitionTheme;
     readonly transport?: CredentialAcquisitionTransport;
     readonly signing?: CredentialSigningAdapter;
     readonly stepHandlers?: Partial<Record<"collect_input" | "mailbox_otp", PrimitiveStepHandler>>;
@@ -115,6 +177,11 @@ export interface CredentialsAcquireOptions extends CredentialsOperationOptions {
     /** Same-origin, request-scoped persistence used to resume a full-page redirect. */
     readonly redirectStore?: CredentialRedirectStore;
 }
+export interface CredentialAcquisitionTheme {
+    readonly accentColor?: string;
+    readonly backgroundColor?: string;
+    readonly textColor?: string;
+}
 export interface CredentialsEnsureOptions extends CredentialsAcquireOptions {
 }
 export interface CredentialsEnsureResult {
@@ -123,4 +190,20 @@ export interface CredentialsEnsureResult {
     readonly record: StoredCredentialRecord;
     readonly receipt?: CredentialStorageReceipt;
 }
+export interface CredentialsPolicyAdmissionOptions {
+    readonly ensured: CredentialsEnsureResult;
+    readonly policy: UnifiedPolicyV2;
+    readonly policyCid: string;
+    readonly policyRootCid: string;
+    readonly enforcementRootCid: string;
+    readonly requirement: CredentialRequirement;
+    readonly requestedCapabilities: readonly UnifiedPolicyCapability[];
+    readonly nodeOrigin: string;
+    readonly fetch?: typeof fetch;
+    readonly now?: Date;
+    readonly jti?: string;
+}
+export interface CredentialsPolicyAdmissionResult extends PolicyCredentialAdmissionV3 {
+    readonly installed: ValidatedRuntimeDelegation;
+}
 //# sourceMappingURL=types.d.ts.map