@tinycloudlabs/sdk-core 1.0.0

package/dist/spaces/SpaceService.js

@@ -0,0 +1,715 @@
+/**
+ * SpaceService - Global singleton for managing spaces (owned and delegated).
+ *
+ * SpaceService provides a unified interface for discovering, creating,
+ * and accessing spaces. It handles both owned spaces (created by the user)
+ * and delegated spaces (shared by other users).
+ *
+ * @packageDocumentation
+ */
+import { ok, err, serviceError } from "@tinycloudlabs/sdk-services";
+import { Space, } from "./Space";
+import { validateServerDelegationsResponse, validateServerOwnedSpacesResponse, validateServerCreateSpaceResponse, validateServerSpaceInfoResponse, } from "./spaces.schema.js";
+// =============================================================================
+// Service Name and Error Codes
+// =============================================================================
+const SERVICE_NAME = "space";
+/**
+ * Error codes for SpaceService operations.
+ */
+export const SpaceErrorCodes = {
+    /** Space not found */
+    NOT_FOUND: "SPACE_NOT_FOUND",
+    /** Space already exists */
+    ALREADY_EXISTS: "SPACE_ALREADY_EXISTS",
+    /** Creation failed */
+    CREATION_FAILED: "SPACE_CREATION_FAILED",
+    /** Authentication required */
+    AUTH_REQUIRED: "AUTH_REQUIRED",
+    /** Invalid space name or URI */
+    INVALID_NAME: "INVALID_SPACE_NAME",
+    /** Network error */
+    NETWORK_ERROR: "NETWORK_ERROR",
+    /** Not initialized */
+    NOT_INITIALIZED: "NOT_INITIALIZED",
+};
+// =============================================================================
+// Space URI Utilities
+// =============================================================================
+/**
+ * Parse a space URI to extract components.
+ *
+ * Full URI format: `tinycloud:pkh:eip155:{chainId}:{address}:{name}`
+ * Short name format: `{name}`
+ *
+ * @param uri - The space URI or short name
+ * @returns Parsed components or null if invalid
+ */
+export function parseSpaceUri(uri) {
+    // Full URI format: tinycloud:pkh:eip155:{chainId}:{address}:{name}
+    const fullUriMatch = uri.match(/^tinycloud:pkh:eip155:(\d+):(0x[a-fA-F0-9]{40}):(.+)$/);
+    if (fullUriMatch) {
+        const [, chainId, address, name] = fullUriMatch;
+        return {
+            owner: `did:pkh:eip155:${chainId}:${address}`,
+            name,
+            chainId,
+            address,
+        };
+    }
+    // Short name format - just return the name, owner will be inferred
+    if (/^[a-zA-Z0-9_-]+$/.test(uri)) {
+        return {
+            owner: "", // Will be filled in from session
+            name: uri,
+        };
+    }
+    return null;
+}
+/**
+ * Build a full space URI from components.
+ *
+ * @param owner - Owner DID (did:pkh:eip155:{chainId}:{address})
+ * @param name - Space name
+ * @returns Full space URI
+ */
+export function buildSpaceUri(owner, name) {
+    // Extract chain ID and address from PKH DID
+    const pkhMatch = owner.match(/^did:pkh:eip155:(\d+):(0x[a-fA-F0-9]{40})$/);
+    if (pkhMatch) {
+        const [, chainId, address] = pkhMatch;
+        return `tinycloud:pkh:eip155:${chainId}:${address}:${name}`;
+    }
+    // Fallback - shouldn't happen with valid PKH DIDs
+    return `tinycloud:${owner}:${name}`;
+}
+// =============================================================================
+// Server Response Transformation
+// =============================================================================
+/**
+ * Transform validated server delegation response to SDK's Delegation[] format.
+ *
+ * Server returns { [cid: string]: DelegationInfo } where:
+ * - Key is the delegation CID
+ * - Value is DelegationInfo with delegator, delegate, capabilities, etc.
+ *
+ * SDK expects Delegation[] with cid field included.
+ *
+ * @param validatedData - Pre-validated server response from validateServerDelegationsResponse()
+ * @param defaultSpaceId - Default space ID to use if not extractable from resource
+ */
+function transformServerDelegations(validatedData, defaultSpaceId) {
+    const result = [];
+    for (const [cid, info] of Object.entries(validatedData)) {
+        // Extract path from capabilities (use first capability's resource path)
+        const capabilities = info.capabilities;
+        let path = "";
+        let spaceId = defaultSpaceId;
+        const actions = [];
+        for (const cap of capabilities) {
+            actions.push(cap.ability);
+            // Parse resource to extract space and path
+            // Resource format: tinycloud:pkh:eip155:{chainId}:{address}:{spaceName}/{service}/{path}
+            const resourceMatch = cap.resource.match(/^(tinycloud:pkh:eip155:\d+:0x[a-fA-F0-9]+:[^/]+)\/[^/]+\/(.*)$/);
+            if (resourceMatch) {
+                spaceId = resourceMatch[1];
+                path = resourceMatch[2] || "";
+            }
+        }
+        // Extract first string parent CID (server may return byte arrays for some CIDs)
+        const firstStringParent = info.parents?.find((p) => typeof p === 'string');
+        result.push({
+            cid,
+            delegateDID: info.delegate,
+            delegatorDID: info.delegator,
+            spaceId,
+            path,
+            actions,
+            expiry: info.expiry ? new Date(info.expiry) : new Date(Date.now() + 24 * 60 * 60 * 1000),
+            isRevoked: false,
+            createdAt: info.issued_at ? new Date(info.issued_at) : undefined,
+            parentCid: firstStringParent,
+        });
+    }
+    return result;
+}
+// =============================================================================
+// Implementation
+// =============================================================================
+/**
+ * SpaceService - Global singleton for managing spaces.
+ *
+ * @example
+ * ```typescript
+ * const spaceService = new SpaceService({
+ *   hosts: ['https://node.tinycloud.xyz'],
+ *   session,
+ *   invoke,
+ * });
+ *
+ * // List all accessible spaces
+ * const result = await spaceService.list();
+ * if (result.ok) {
+ *   for (const space of result.data) {
+ *     console.log(`${space.name} (${space.type})`);
+ *   }
+ * }
+ *
+ * // Create a new space
+ * const createResult = await spaceService.create('photos');
+ *
+ * // Get a space object for operations
+ * const space = spaceService.get('photos');
+ * await space.kv.put('album/vacation', { photos: [...] });
+ * ```
+ */
+export class SpaceService {
+    /**
+     * Create a new SpaceService instance.
+     *
+     * @param config - Service configuration
+     */
+    constructor(config) {
+        /** Cache of created Space objects */
+        this.spaceCache = new Map();
+        /** Cache of space info */
+        this.infoCache = new Map();
+        /** Cache TTL in milliseconds (5 minutes) */
+        this.cacheTTL = 5 * 60 * 1000;
+        this.hosts = config.hosts;
+        this.session = config.session;
+        this.invoke = config.invoke;
+        this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+        this.capabilityRegistry = config.capabilityRegistry;
+        this.createKVServiceFn = config.createKVService;
+        this._userDid = config.userDid;
+        this.sharingService = config.sharingService;
+        this.createDelegationFn = config.createDelegation;
+    }
+    /**
+     * Update the service configuration.
+     */
+    updateConfig(config) {
+        if (config.hosts)
+            this.hosts = config.hosts;
+        if (config.session)
+            this.session = config.session;
+        if (config.invoke)
+            this.invoke = config.invoke;
+        if (config.fetch)
+            this.fetchFn = config.fetch;
+        if (config.capabilityRegistry)
+            this.capabilityRegistry = config.capabilityRegistry;
+        if (config.createKVService)
+            this.createKVServiceFn = config.createKVService;
+        if (config.userDid !== undefined)
+            this._userDid = config.userDid;
+        if (config.sharingService)
+            this.sharingService = config.sharingService;
+        if (config.createDelegation)
+            this.createDelegationFn = config.createDelegation;
+        // Clear caches when config changes
+        this.spaceCache.clear();
+        this.infoCache.clear();
+    }
+    /**
+     * Get the current user's primary space ID.
+     */
+    getCurrentSpaceId() {
+        return this.session?.spaceId;
+    }
+    /**
+     * Get the primary host URL.
+     */
+    get host() {
+        return this.hosts[0];
+    }
+    /**
+     * Get the current user's PKH DID.
+     */
+    get userDid() {
+        // Return explicitly set user DID, or try to derive from verificationMethod
+        if (this._userDid) {
+            return this._userDid;
+        }
+        // verificationMethod might be did:key format - cannot derive PKH from it
+        // The caller should provide userDid explicitly for full functionality
+        return undefined;
+    }
+    // ===========================================================================
+    // List Spaces
+    // ===========================================================================
+    /**
+     * List all spaces the user has access to.
+     *
+     * Combines owned spaces (from the server) with delegated spaces
+     * (from the capability registry).
+     */
+    async list() {
+        if (!this.session) {
+            return err(serviceError(SpaceErrorCodes.AUTH_REQUIRED, "Authentication required", SERVICE_NAME));
+        }
+        try {
+            const spaces = [];
+            // 1. Get owned spaces from the server
+            const ownedResult = await this.listOwnedSpaces();
+            if (ownedResult.ok) {
+                spaces.push(...ownedResult.data);
+            }
+            // 2. Get delegated spaces from capability registry
+            if (this.capabilityRegistry) {
+                const delegatedSpaces = this.discoverDelegatedSpaces();
+                spaces.push(...delegatedSpaces);
+            }
+            // Remove duplicates (prefer owned over delegated)
+            const uniqueSpaces = this.deduplicateSpaces(spaces);
+            return ok(uniqueSpaces);
+        }
+        catch (error) {
+            return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, `Failed to list spaces: ${String(error)}`, SERVICE_NAME, { cause: error instanceof Error ? error : undefined }));
+        }
+    }
+    /**
+     * List owned spaces from the server.
+     */
+    async listOwnedSpaces() {
+        try {
+            const headers = this.invoke(this.session, "space", "", "tinycloud.space/list");
+            const response = await this.fetchFn(`${this.host}/invoke`, {
+                method: "POST",
+                headers,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, `Failed to list owned spaces: ${response.status} - ${errorText}`, SERVICE_NAME, { meta: { status: response.status } }));
+            }
+            const rawData = await response.json();
+            // Validate server response
+            const validationResult = validateServerOwnedSpacesResponse(rawData);
+            if (!validationResult.ok) {
+                return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, validationResult.error.message, SERVICE_NAME, { meta: validationResult.error.meta }));
+            }
+            const spaces = validationResult.data.map((item) => ({
+                id: item.id,
+                name: item.name ?? this.extractNameFromId(item.id),
+                owner: item.owner,
+                type: "owned",
+                permissions: ["*"], // Full permissions for owned spaces
+            }));
+            return ok(spaces);
+        }
+        catch (error) {
+            return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, `Network error listing owned spaces: ${String(error)}`, SERVICE_NAME, { cause: error instanceof Error ? error : undefined }));
+        }
+    }
+    /**
+     * Discover delegated spaces from the capability registry.
+     */
+    discoverDelegatedSpaces() {
+        if (!this.capabilityRegistry) {
+            return [];
+        }
+        const spaces = new Map();
+        // Get all capabilities and extract unique space IDs
+        const capabilities = this.capabilityRegistry.getAllCapabilities();
+        for (const capability of capabilities) {
+            const spaceId = capability.delegation.spaceId;
+            // Skip if we already have this space
+            if (spaces.has(spaceId)) {
+                const existing = spaces.get(spaceId);
+                // Merge permissions
+                if (existing.permissions) {
+                    const actions = capability.delegation.actions;
+                    for (const action of actions) {
+                        if (!existing.permissions.includes(action)) {
+                            existing.permissions.push(action);
+                        }
+                    }
+                }
+                continue;
+            }
+            // Skip if this is the user's own space
+            if (spaceId === this.session?.spaceId) {
+                continue;
+            }
+            const parsed = parseSpaceUri(spaceId);
+            spaces.set(spaceId, {
+                id: spaceId,
+                name: parsed?.name ?? this.extractNameFromId(spaceId),
+                owner: capability.delegation.delegatorDID ?? parsed?.owner ?? "",
+                type: "delegated",
+                permissions: [...capability.delegation.actions],
+                expiresAt: capability.expiresAt,
+            });
+        }
+        return Array.from(spaces.values());
+    }
+    /**
+     * Extract space name from a full space ID.
+     */
+    extractNameFromId(id) {
+        const parsed = parseSpaceUri(id);
+        if (parsed) {
+            return parsed.name;
+        }
+        // Fallback: take last segment
+        const parts = id.split(":");
+        return parts[parts.length - 1] || id;
+    }
+    /**
+     * Deduplicate spaces, preferring owned over delegated.
+     */
+    deduplicateSpaces(spaces) {
+        const seen = new Map();
+        for (const space of spaces) {
+            const existing = seen.get(space.id);
+            if (!existing || (existing.type === "delegated" && space.type === "owned")) {
+                seen.set(space.id, space);
+            }
+        }
+        return Array.from(seen.values());
+    }
+    // ===========================================================================
+    // Create Space
+    // ===========================================================================
+    /**
+     * Create a new space.
+     *
+     * @param name - The name for the new space
+     */
+    async create(name) {
+        if (!this.session) {
+            return err(serviceError(SpaceErrorCodes.AUTH_REQUIRED, "Authentication required", SERVICE_NAME));
+        }
+        // Validate name
+        if (!name || !/^[a-zA-Z0-9_-]+$/.test(name)) {
+            return err(serviceError(SpaceErrorCodes.INVALID_NAME, "Space name must contain only alphanumeric characters, underscores, and hyphens", SERVICE_NAME));
+        }
+        try {
+            const headers = this.invoke(this.session, "space", name, "tinycloud.space/create");
+            const response = await this.fetchFn(`${this.host}/invoke`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ name }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                if (response.status === 409) {
+                    return err(serviceError(SpaceErrorCodes.ALREADY_EXISTS, `Space "${name}" already exists`, SERVICE_NAME));
+                }
+                return err(serviceError(SpaceErrorCodes.CREATION_FAILED, `Failed to create space: ${response.status} - ${errorText}`, SERVICE_NAME, { meta: { status: response.status } }));
+            }
+            const rawData = await response.json();
+            // Validate server response
+            const validationResult = validateServerCreateSpaceResponse(rawData);
+            if (!validationResult.ok) {
+                return err(serviceError(SpaceErrorCodes.CREATION_FAILED, validationResult.error.message, SERVICE_NAME, { meta: validationResult.error.meta }));
+            }
+            const spaceInfo = {
+                id: validationResult.data.id,
+                name: validationResult.data.name || name,
+                owner: validationResult.data.owner || this.userDid || "",
+                type: "owned",
+                permissions: ["*"],
+            };
+            // Cache the info
+            this.infoCache.set(spaceInfo.id, { info: spaceInfo, cachedAt: Date.now() });
+            return ok(spaceInfo);
+        }
+        catch (error) {
+            return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, `Network error creating space: ${String(error)}`, SERVICE_NAME, { cause: error instanceof Error ? error : undefined }));
+        }
+    }
+    // ===========================================================================
+    // Get Space
+    // ===========================================================================
+    /**
+     * Get a Space object by name or full URI.
+     *
+     * @param nameOrUri - Short name or full URI
+     */
+    get(nameOrUri) {
+        // Resolve the full space ID
+        const spaceId = this.resolveSpaceId(nameOrUri);
+        // Check cache
+        const cached = this.spaceCache.get(spaceId);
+        if (cached) {
+            return cached;
+        }
+        // Create new Space object
+        const parsed = parseSpaceUri(spaceId);
+        const name = parsed?.name ?? this.extractNameFromId(spaceId);
+        const config = {
+            id: spaceId,
+            name,
+            createKV: this.createSpaceScopedKV.bind(this),
+            createDelegations: this.createSpaceScopedDelegations.bind(this),
+            createSharing: this.createSpaceScopedSharing.bind(this),
+            getInfo: this.getSpaceInfo.bind(this),
+        };
+        const space = new Space(config);
+        this.spaceCache.set(spaceId, space);
+        return space;
+    }
+    /**
+     * Resolve a name or URI to a full space ID.
+     */
+    resolveSpaceId(nameOrUri) {
+        const parsed = parseSpaceUri(nameOrUri);
+        if (!parsed) {
+            // Invalid format, return as-is
+            return nameOrUri;
+        }
+        if (parsed.owner) {
+            // Full URI - return as-is
+            return nameOrUri;
+        }
+        // Short name - build full URI from user's DID
+        if (this.userDid) {
+            return buildSpaceUri(this.userDid, parsed.name);
+        }
+        // No user DID available, return as-is
+        return nameOrUri;
+    }
+    // ===========================================================================
+    // Exists Check
+    // ===========================================================================
+    /**
+     * Check if a space exists and the user has access.
+     */
+    async exists(nameOrUri) {
+        const spaceId = this.resolveSpaceId(nameOrUri);
+        // Check info cache first
+        const cached = this.infoCache.get(spaceId);
+        if (cached && Date.now() - cached.cachedAt < this.cacheTTL) {
+            return ok(true);
+        }
+        // Query the server
+        const infoResult = await this.getSpaceInfo(spaceId);
+        return ok(infoResult.ok);
+    }
+    // ===========================================================================
+    // Space Info
+    // ===========================================================================
+    /**
+     * Get space info from server or cache.
+     */
+    async getSpaceInfo(spaceId) {
+        // Check cache
+        const cached = this.infoCache.get(spaceId);
+        if (cached && Date.now() - cached.cachedAt < this.cacheTTL) {
+            return ok(cached.info);
+        }
+        if (!this.session) {
+            return err(serviceError(SpaceErrorCodes.AUTH_REQUIRED, "Authentication required", SERVICE_NAME));
+        }
+        try {
+            const headers = this.invoke(this.session, "space", spaceId, "tinycloud.space/info");
+            const response = await this.fetchFn(`${this.host}/invoke`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ spaceId }),
+            });
+            if (!response.ok) {
+                if (response.status === 404) {
+                    return err(serviceError(SpaceErrorCodes.NOT_FOUND, `Space not found: ${spaceId}`, SERVICE_NAME));
+                }
+                const errorText = await response.text();
+                return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, `Failed to get space info: ${response.status} - ${errorText}`, SERVICE_NAME));
+            }
+            const rawData = await response.json();
+            // Validate server response
+            const validationResult = validateServerSpaceInfoResponse(rawData);
+            if (!validationResult.ok) {
+                return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, validationResult.error.message, SERVICE_NAME, { meta: validationResult.error.meta }));
+            }
+            const data = validationResult.data;
+            const spaceInfo = {
+                id: data.id,
+                name: data.name ?? this.extractNameFromId(data.id),
+                owner: data.owner,
+                type: data.type ?? (data.owner === this.userDid ? "owned" : "delegated"),
+                permissions: data.permissions,
+                expiresAt: data.expiresAt ? new Date(data.expiresAt) : undefined,
+            };
+            // Cache the info
+            this.infoCache.set(spaceId, { info: spaceInfo, cachedAt: Date.now() });
+            return ok(spaceInfo);
+        }
+        catch (error) {
+            return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, `Network error getting space info: ${String(error)}`, SERVICE_NAME, { cause: error instanceof Error ? error : undefined }));
+        }
+    }
+    // ===========================================================================
+    // Space-Scoped Service Factories
+    // ===========================================================================
+    /**
+     * Create a space-scoped KV service.
+     */
+    createSpaceScopedKV(spaceId) {
+        if (this.createKVServiceFn) {
+            return this.createKVServiceFn(spaceId);
+        }
+        // Return a proxy that throws a helpful error
+        return new Proxy({}, {
+            get: () => {
+                throw new Error("KV service factory not configured. Provide createKVService in SpaceServiceConfig.");
+            },
+        });
+    }
+    /**
+     * Create space-scoped delegation operations.
+     */
+    createSpaceScopedDelegations(spaceId) {
+        const self = this;
+        return {
+            async list() {
+                // List outgoing delegations (created by user) using tinycloud.capabilities/read
+                try {
+                    // Facts contain the query params for the capabilities/read capability
+                    const facts = [
+                        {
+                            capabilitiesReadParams: {
+                                type: "list",
+                                filters: { direction: "created" },
+                            },
+                        },
+                    ];
+                    // The capabilities/read endpoint requires path="all" to match server routing
+                    const headers = self.invoke(self.session, "capabilities", "all", "tinycloud.capabilities/read", facts);
+                    const response = await self.fetchFn(`${self.host}/invoke`, {
+                        method: "POST",
+                        headers,
+                    });
+                    if (!response.ok) {
+                        const errorText = await response.text();
+                        return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, `Failed to list delegations: ${response.status} - ${errorText}`, SERVICE_NAME));
+                    }
+                    // Server returns { [cid: string]: DelegationInfo } - validate and transform to Delegation[]
+                    const rawData = await response.json();
+                    // Validate server response
+                    const validationResult = validateServerDelegationsResponse(rawData);
+                    if (!validationResult.ok) {
+                        return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, validationResult.error.message, SERVICE_NAME, { meta: validationResult.error.meta }));
+                    }
+                    const delegations = transformServerDelegations(validationResult.data, spaceId);
+                    return ok(delegations);
+                }
+                catch (error) {
+                    return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, `Network error listing delegations: ${String(error)}`, SERVICE_NAME));
+                }
+            },
+            async listReceived() {
+                // List incoming delegations (received by user) using tinycloud.capabilities/read
+                try {
+                    // Facts contain the query params for the capabilities/read capability
+                    const facts = [
+                        {
+                            capabilitiesReadParams: {
+                                type: "list",
+                                filters: { direction: "received" },
+                            },
+                        },
+                    ];
+                    // The capabilities/read endpoint requires path="all" to match server routing
+                    const headers = self.invoke(self.session, "capabilities", "all", "tinycloud.capabilities/read", facts);
+                    const response = await self.fetchFn(`${self.host}/invoke`, {
+                        method: "POST",
+                        headers,
+                    });
+                    if (!response.ok) {
+                        const errorText = await response.text();
+                        return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, `Failed to list received delegations: ${response.status} - ${errorText}`, SERVICE_NAME));
+                    }
+                    // Server returns { [cid: string]: DelegationInfo } - validate and transform to Delegation[]
+                    const rawData = await response.json();
+                    // Validate server response
+                    const validationResult = validateServerDelegationsResponse(rawData);
+                    if (!validationResult.ok) {
+                        return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, validationResult.error.message, SERVICE_NAME, { meta: validationResult.error.meta }));
+                    }
+                    const delegations = transformServerDelegations(validationResult.data, spaceId);
+                    return ok(delegations);
+                }
+                catch (error) {
+                    return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, `Network error listing received delegations: ${String(error)}`, SERVICE_NAME));
+                }
+            },
+            async create(params) {
+                // Use the platform-provided createDelegation function (SIWE-based flow)
+                if (self.createDelegationFn) {
+                    return self.createDelegationFn({ ...params, spaceId });
+                }
+                // Fallback: return error if no createDelegation function provided
+                // The old invoke-based approach doesn't work because /delegate expects
+                // SIWE delegation headers, not invocation headers
+                return err(serviceError(SpaceErrorCodes.NOT_INITIALIZED, "Delegation creation requires a createDelegation function. " +
+                    "This should be provided by the platform SDK (web-sdk or node-sdk).", SERVICE_NAME));
+            },
+            async revoke(cid) {
+                try {
+                    const headers = self.invoke(self.session, "delegation", cid, "tinycloud.delegation/revoke");
+                    const response = await self.fetchFn(`${self.host}/revoke`, {
+                        method: "POST",
+                        headers,
+                        body: JSON.stringify({ cid, spaceId }),
+                    });
+                    if (!response.ok) {
+                        const errorText = await response.text();
+                        return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, `Failed to revoke delegation: ${response.status} - ${errorText}`, SERVICE_NAME));
+                    }
+                    return ok(undefined);
+                }
+                catch (error) {
+                    return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, `Network error revoking delegation: ${String(error)}`, SERVICE_NAME));
+                }
+            },
+        };
+    }
+    /**
+     * Create space-scoped sharing operations.
+     *
+     * When a SharingService is configured, delegates to client-side v2 sharing.
+     * V2 sharing links are self-contained with embedded private keys - no server tracking.
+     */
+    createSpaceScopedSharing(spaceId) {
+        const self = this;
+        return {
+            async generate(params) {
+                // Use v2 SharingService when available (client-side sharing links)
+                if (self.sharingService) {
+                    // Note: SharingService uses session.spaceId for the space.
+                    // For space-scoped sharing on delegated spaces, ensure the session
+                    // is configured for the correct space before calling generate().
+                    const result = await self.sharingService.generate(params);
+                    if (!result.ok) {
+                        return err(serviceError(SpaceErrorCodes.NETWORK_ERROR, result.error.message || "Failed to generate share link", SERVICE_NAME));
+                    }
+                    return ok(result.data);
+                }
+                // Fallback: return error since server endpoint doesn't exist
+                return err(serviceError(SpaceErrorCodes.NOT_INITIALIZED, "SharingService not configured. V2 sharing requires a SharingService instance.", SERVICE_NAME));
+            },
+            async list() {
+                // V2 sharing links are self-contained (not server-tracked)
+                // This operation is not supported in the v2 spec
+                return err(serviceError(SpaceErrorCodes.NOT_INITIALIZED, "Listing share links is not supported in v2. Share links are self-contained tokens that are not tracked on the server.", SERVICE_NAME));
+            },
+            async revoke(token) {
+                // V2 sharing links are revoked by revoking the underlying delegation
+                // This requires the delegation CID, not the share token
+                return err(serviceError(SpaceErrorCodes.NOT_INITIALIZED, "Revoking share links by token is not supported in v2. To revoke access, revoke the underlying delegation using space.delegations.revoke(cid).", SERVICE_NAME));
+            },
+        };
+    }
+}
+/**
+ * Create a new SpaceService instance.
+ *
+ * @param config - Service configuration
+ * @returns A new SpaceService instance
+ */
+export function createSpaceService(config) {
+    return new SpaceService(config);
+}
+//# sourceMappingURL=SpaceService.js.map