@tinycloud/web-sdk 3.0.0-beta.2 → 3.0.0-beta.20

package/dist/modules/WebSecretsService.d.ts

@@ -26,6 +26,7 @@ export declare class WebSecretsService implements ISecretsService {
     put(name: string, value: string, options?: SecretScopeOptions): ReturnType<ISecretsService["put"]>;
     delete(name: string, options?: SecretScopeOptions): ReturnType<ISecretsService["delete"]>;
     list(options?: SecretScopeOptions): ReturnType<ISecretsService["list"]>;
+    listAll(): ReturnType<ISecretsService["listAll"]>;
     private get service();
     private ensureMutationPermission;
     private restoreUnlockAfterEscalation;

package/dist/modules/tcw.d.ts

@@ -9,8 +9,8 @@
  *
  * @packageDocumentation
  */
-import { TinyCloudNode, type BootstrapWarning, type DelegateToOptions, type DelegateToResult, type ISessionStorage, type SignStrategy, type ValidatedRuntimeDelegation, type UnifiedOwnerRootInput, type UnifiedOwnerRootReceipt } from "@tinycloud/node-sdk/core";
-import { IKVService, ISQLService, IDuckDbService, IDataVaultService, ISecretsService, ISpaceService, ISpace, ISharingService, ICapabilityKeyRegistry, IHooksService, IEncryptionService, DelegationManager, Delegation, DelegationRevocationReceipt, CreateDelegationParams, Result, DelegationError, ClientSession, Extension, type TelemetryConfig, ISpaceCreationHandler, type Manifest, type ComposedManifestRequest, type AccountService, type ResolvedDelegate, type PermissionEntry, type NetworkDescriptor, type CreateOwnerDelegationParams, type OwnerDelegationReceipt, type RegisterOwnerSharePolicyParams, type OwnerSharePolicyRegistrationReceipt, type LocalNodeIdentityStore, SignInOptions } from "@tinycloud/sdk-core";
+import { TinyCloudNode, type BootstrapWarning, type DelegateToOptions, type DelegateToResult, type ISessionStorage, type SignStrategy, type ValidatedRuntimeDelegation, type UnifiedOwnerRootInput, type UnifiedOwnerRootReceipt, type RegisterPolicyV3Input, type RegisterPolicyV3Receipt } from "@tinycloud/node-sdk/core";
+import { IKVService, ISQLService, IDuckDbService, IDataVaultService, ISecretsService, ISpaceService, ISpace, ISharingService, ICapabilityKeyRegistry, IHooksService, IEncryptionService, DelegationManager, Delegation, DelegationRevocationReceipt, CreateDelegationParams, Result, DelegationError, ClientSession, Extension, type TelemetryConfig, ISpaceCreationHandler, type Manifest, type ComposedManifestRequest, type AccountService, type ResolvedDelegate, type PermissionEntry, type NetworkDescriptor, type CreateOwnerDelegationParams, type OwnerDelegationReceipt, type LocalNodeIdentityStore, SignInOptions } from "@tinycloud/sdk-core";
 import { type BrowserProvider, type BrowserWalletProvider } from "../adapters/browserProvider";
 import { RPCProviders, ClientConfig } from "../providers";
 import type { NotificationConfig } from "../notifications/types";
@@ -74,7 +74,7 @@ export interface Config extends ClientConfig {
      * modal handler is in use.
      */
     spaceCreationTimeoutMs?: number;
-    /** Session expiration time in milliseconds (default: 1 hour) */
+    /** Session expiration time in milliseconds (default: 30 days, `EXPIRY.SESSION_MS`) */
     sessionExpirationMs?: number;
     /** Persist browser sessions so signIn() can restore before prompting. Default true. */
     persistSession?: boolean;
@@ -137,6 +137,8 @@ export interface ShareReceiveResult<T = unknown> {
     delegation: Delegation;
     path: string;
     spaceId: string;
+    /** Owner Node named by the link; that node independently verifies the accompanying delegation. */
+    host: string;
 }
 export declare class TinyCloudWeb {
     /** The connected wallet's raw EIP-1193 provider. */
@@ -233,6 +235,13 @@ export declare class TinyCloudWeb {
     get accountSpaceId(): string | undefined;
     get account(): AccountService;
     get hosts(): string[];
+    /** Registry-resolved owner Node identity used to bind native share targets. */
+    activeNodeIdentity(): Promise<{
+        readonly origin: string;
+        readonly nodeDid: string;
+    }>;
+    /** Publish the active owner Node as a session-signed registry record. */
+    publishActiveNodeLocation(registryUrl: string, fetchFn?: typeof fetch): Promise<import("@tinycloud/sdk-core").LocationRecord>;
     get sessionRestoreStatus(): SessionRestoreStatus;
     /** Holder-bound OpenCredentials issuance using the active TinyCloud session. */
     get credentials(): CredentialsService;
@@ -310,10 +319,10 @@ export declare class TinyCloudWeb {
     createOwnerDelegation(params: CreateOwnerDelegationParams extends infer PermissionShape ? PermissionShape extends CreateOwnerDelegationParams ? Omit<PermissionShape, "spaceId"> & {
         readonly spaceId?: string;
     } : never : never): Promise<OwnerDelegationReceipt>;
-    /** Register an owner-bound addressed sharing policy through TinyCloud Node. */
-    registerOwnerSharePolicy(params: RegisterOwnerSharePolicyParams): Promise<OwnerSharePolicyRegistrationReceipt>;
-    /** Authorize a short-lived, one-use v2 delivery using the authenticated invocation chain. */
-    authorizeShareDelivery(input: Parameters<TinyCloudNode["authorizeShareDelivery"]>[0]): ReturnType<TinyCloudNode["authorizeShareDelivery"]>;
+    /** Register signed policy material through the Node-owned Policy/v3 runtime. */
+    registerPolicy(params: Omit<RegisterPolicyV3Input, "nodeOrigin" | "fetch">): Promise<RegisterPolicyV3Receipt>;
+    /** Authorize a short-lived, one-use v3 delivery against the signed envelope and roots. */
+    authorizeShareDeliveryV3(input: Parameters<TinyCloudNode["authorizeShareDeliveryV3"]>[0]): ReturnType<TinyCloudNode["authorizeShareDeliveryV3"]>;
     /**
      * Issue a delegation using the capability-chain flow (spec:
      * `.claude/specs/capability-chain.md`). When the requested permissions
@@ -384,9 +393,11 @@ export declare class TinyCloudWeb {
     listDelegations(): Promise<Result<Delegation[], DelegationError>>;
     checkPermission(path: string, action: string): Promise<Result<boolean, DelegationError>>;
     /**
-     * Receive and retrieve data from a v2 share link.
+     * Receive and retrieve data from a native TinyCloud bearer delegation.
      * Static method — no auth required. Uses browser WASM.
      */
-    static receiveShare<T = unknown>(link: string, key?: string): Promise<Result<ShareReceiveResult<T>, DelegationError>>;
+    static receiveShare<T = unknown>(link: string, key?: string, options?: {
+        readonly binary?: boolean;
+    }): Promise<Result<ShareReceiveResult<T>, DelegationError>>;
 }
 //# sourceMappingURL=tcw.d.ts.map

package/dist/notifications/types.schema.d.ts

@@ -54,8 +54,8 @@ export declare const ToastSchema: z.ZodObject<{
     timestamp: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     description?: string;
-    type?: "error" | "success" | "warning" | "info" | "loading";
     id?: string;
+    type?: "error" | "success" | "warning" | "info" | "loading";
     title?: string;
     duration?: number;
     action?: {
@@ -65,8 +65,8 @@ export declare const ToastSchema: z.ZodObject<{
     timestamp?: number;
 }, {
     description?: string;
-    type?: "error" | "success" | "warning" | "info" | "loading";
     id?: string;
+    type?: "error" | "success" | "warning" | "info" | "loading";
     title?: string;
     duration?: number;
     action?: {

package/dist/share/service.d.ts

@@ -1,53 +1,55 @@
+import { type CredentialRequirement } from "@tinycloud/sdk-core";
+import { type ShareMetadata } from "@tinycloud/share-sdk";
 import { type ShareEnvelopeV3 } from "@tinycloud/share-envelope";
 import { CredentialsService } from "../credentials";
 import { type ReceiverSessionStorage } from "./receiver-session";
-import type { ReceivedShare, ShareImportAccountClient, ShareImportOptions, ShareImportResult, ShareReceiveOptions, ShareReceivedContent, ShareReceiverClient, ShareReceiverIdentity } from "./types";
+import type { ReceivedShare, ShareDelegateOptions, ShareDelegation, ShareImportAccountClient, ShareImportOptions, ShareImportResult, ShareReceiveOptions, ShareReceivedContent, ShareReceiverClient, ShareReceiverIdentity, ShareReceiverRecipient } from "./types";
 export interface ShareReceiverServiceOptions {
     readonly origin?: string;
     readonly sessionStorage?: ReceiverSessionStorage;
     readonly credentialDiscoveryUrl?: string;
     /** Out-of-band Share application origin allowed to supply invitation URLs. */
     readonly expectedShareOrigin: string;
-    /** Explicit share blob registry. Never inferred from the viewer URL. */
-    readonly registryBaseUrl: string;
-    /** Pinned Node identity used by recipient response verification. */
-    readonly trustedNode: {
-        readonly invitationKid: string;
-        readonly invitationPublicKey: Uint8Array;
-    };
-    /** Exact Ed25519 enforcer DID committed as the signed envelope target. */
-    readonly expectedEnforcerDid: string;
+    /** Registry containing the share owner's signed TinyCloud location record. */
+    readonly registryOrigin: string;
     readonly fetch?: typeof fetch;
 }
-export declare function validateShareReceiverServiceTrust(envelope: Pick<ShareEnvelopeV3, "target">, config: ShareReceiverServiceOptions): {
-    readonly invitationKid: string;
-    readonly invitationPublicKey: Uint8Array;
-};
-/** @internal */
-export declare function validateShareReceiverRegistryBaseUrl(value: string): string;
+export declare function validateShareReceiverServiceTrust(envelope: Pick<ShareEnvelopeV3, "target" | "attestedEnforcerBinding">): void;
 /** @internal */
 export declare function validateShareReceiverExpectedOrigin(shareUrl: string, expectedOrigin: string): string;
 /** @internal */
 export declare function selectShareReceiverAccountSession(client: ShareReceiverClient, requestedIdentity: ShareReceiveOptions["identity"]): Promise<ReturnType<ShareReceiverClient["session"]>>;
-/** @internal */
+/**
+ * @internal Binds the invitation's addressed recipient to the owner-signed
+ * policy's credential commitment. A matcher that does not hash to the
+ * committed requirement is rejected before anything is displayed or sent.
+ */
+export declare function verifiedShareRequirement(envelope: ShareEnvelopeV3): Promise<CredentialRequirement>;
 export declare class ReceivedShareImpl implements ReceivedShare {
     readonly identity: ShareReceiverIdentity;
-    readonly shareId: string;
+    readonly metadata: ShareMetadata;
     private readonly envelope;
+    private readonly requirement;
     private readonly credentials;
     private readonly sign;
     private readonly options;
     private readonly fetchFn;
     private readonly credentialDiscoveryUrl;
-    private readonly trustedNode;
     private content?;
     private getPromise?;
-    constructor(identity: ShareReceiverIdentity, shareId: string, envelope: ShareEnvelopeV3, credentials: CredentialsService, sign: (bytes: Uint8Array) => Promise<Uint8Array>, options: ShareReceiveOptions, fetchFn: typeof fetch, credentialDiscoveryUrl: string, trustedNode: {
-        readonly invitationKid: string;
-        readonly invitationPublicKey: Uint8Array;
-    });
+    private accessPromise?;
+    private stage?;
+    readonly recipient: ShareReceiverRecipient;
+    constructor(identity: ShareReceiverIdentity, metadata: ShareMetadata, envelope: ShareEnvelopeV3, requirement: CredentialRequirement, credentials: CredentialsService, sign: (bytes: Uint8Array) => Promise<Uint8Array>, options: ShareReceiveOptions, fetchFn: typeof fetch, credentialDiscoveryUrl: string);
+    get shareId(): string;
     get(): Promise<ShareReceivedContent>;
+    /** The admitted access, admitted again once its chain has expired. */
+    private access;
+    /** Forget `access` so the next request admits again, unless it was already replaced. */
+    private forget;
+    private admit;
     private load;
+    delegate(options: ShareDelegateOptions): Promise<ShareDelegation>;
     importInto(accountClient: ShareImportAccountClient, options: ShareImportOptions): Promise<ShareImportResult>;
 }
 export declare class ShareReceiverService {

package/dist/share/types.d.ts

@@ -1,4 +1,5 @@
 import type { ClientSession, IKVService } from "@tinycloud/sdk-core";
+import type { ShareMetadata } from "@tinycloud/share-sdk";
 import type { CredentialsService } from "../credentials";
 export type ShareReceiverIdentity = {
     readonly kind: "account";
@@ -16,6 +17,7 @@ export type ShareReceiveProgress = {
 } | {
     readonly state: "credential-acquisition";
     readonly status: "started" | "completed";
+    readonly mailbox?: string;
 } | {
     readonly state: "policy-admission";
     readonly status: "started" | "completed";
@@ -43,6 +45,34 @@ export interface ShareReceiveOptions {
     };
     readonly signal?: AbortSignal;
     readonly onProgress?: (event: ShareReceiveProgress) => void;
+    /**
+     * Open through access another recipient delegated to this identity's key,
+     * instead of proving a credential.
+     */
+    readonly delegation?: ShareDelegation;
+}
+/** One signed link of a share's delegation chain. The owner's Node holds it too. */
+export interface ShareDelegationLink {
+    readonly authorization: string;
+    readonly cid: string;
+}
+/**
+ * A share's access re-delegated to another key: the admitted session first,
+ * then each re-delegation in order. It holds no secret; only the key it names
+ * can use it.
+ */
+export interface ShareDelegation {
+    readonly shareId: string;
+    readonly delegateDid: string;
+    readonly expiresAt: string;
+    readonly chain: readonly ShareDelegationLink[];
+}
+export interface ShareDelegateOptions {
+    /** DID of the key that should hold this share's access, such as an account session key. */
+    readonly to: string;
+    /** Defaults to the longest the current access allows. */
+    readonly expiresAt?: Date;
+    readonly signal?: AbortSignal;
 }
 export interface ShareReceivedContent {
     readonly bytes: Uint8Array;
@@ -68,11 +98,33 @@ export interface ShareImportAccountClient {
     ensureOwnedSpaceHosted(name: string): Promise<string>;
     kvForSpace(spaceId: string): IKVService;
 }
+/**
+ * The recipient an invitation is addressed to. It comes from the signed,
+ * sealed invitation and is checked against the policy's credential
+ * requirement commitment before `receive` returns, so a host may display it.
+ */
+export type ShareReceiverRecipient = {
+    readonly kind: "exactEmail";
+    readonly email: string;
+}
+/** Anyone who proves a mailbox whose issuer-derived domain equals `domain` exactly. */
+ | {
+    readonly kind: "emailDomain";
+    readonly domain: string;
+};
 export interface ReceivedShare {
     readonly identity: ShareReceiverIdentity;
+    readonly recipient: ShareReceiverRecipient;
+    readonly metadata: ShareMetadata;
     readonly shareId: string;
     get(): Promise<ShareReceivedContent>;
     importInto(accountClient: ShareImportAccountClient, options: ShareImportOptions): Promise<ShareImportResult>;
+    /**
+     * Re-delegate this share's access, including decryption, to another key.
+     * Proves the credential first if this share has not been opened yet. The
+     * delegate opens it with `receive(url, { delegation })`.
+     */
+    delegate(options: ShareDelegateOptions): Promise<ShareDelegation>;
 }
 export interface ShareReceiverClient extends ShareImportAccountClient {
     readonly credentialHolderDid: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinycloud/web-sdk",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.20",
   "description": "A set of tools and utilities to help you build your app with TinyCloud.",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -43,10 +43,10 @@
   "dependencies": {
     "@multiformats/multiaddr": "^13.0.1",
     "@multiformats/multiaddr-to-uri": "^12.0.0",
-    "@tinycloud/node-sdk": "3.0.0-beta.2",
-    "@tinycloud/sdk-core": "3.0.0-beta.2",
-    "@tinycloud/share-envelope": "0.2.1-beta.0",
-    "@tinycloud/share-sdk": "0.3.0-beta.0",
+    "@tinycloud/node-sdk": "3.0.0-beta.20",
+    "@tinycloud/sdk-core": "3.0.0-beta.19",
+    "@tinycloud/share-envelope": "1.0.0-beta.5",
+    "@tinycloud/share-sdk": "1.0.0-beta.9",
     "@tinycloud/web-sdk-wasm": "1.7.6",
     "axios": "^1.7.9",
     "viem": "^2.45.0",