@agentunion/fastaun-browser 0.4.13 → 0.5.1

package/dist/group-fs.d.ts

@@ -0,0 +1,120 @@
+import { StorageLowLevel } from './storage/lowlevel.js';
+import type { RpcParams } from './types.js';
+export interface GroupFSRpcClient {
+    aid?: string | null;
+    call(method: string, params?: RpcParams): Promise<unknown>;
+}
+type GroupFSSigningAID = {
+    aid?: string;
+    privateKeyPem?: string;
+    certPem?: string;
+};
+type GroupFSAIDStoreResult = {
+    ok?: boolean;
+    data?: {
+        aid?: GroupFSSigningAID;
+    };
+    error?: {
+        message?: string;
+    };
+};
+type GroupFSAIDStore = {
+    load?: (aid: string) => GroupFSAIDStoreResult | Promise<GroupFSAIDStoreResult>;
+    loadAsync?: (aid: string) => Promise<GroupFSAIDStoreResult>;
+};
+export type GroupFSParams = Record<string, unknown>;
+export type GroupFSBinarySource = Uint8Array | ArrayBuffer | ArrayBufferView | Blob;
+export type GroupFSCpSource = string | GroupFSBinarySource;
+export type GroupFSCpDestination = string | {
+    type?: 'blob' | 'bytes';
+    path?: string;
+    localPath?: string;
+};
+export interface GroupFSCpOptions extends GroupFSParams {
+    force?: boolean;
+    recursive?: boolean;
+    parents?: boolean;
+    followSymlinks?: boolean | null;
+    follow_symlinks?: boolean | null;
+    contentType?: string | null;
+    content_type?: string | null;
+    metadata?: Record<string, unknown> | null;
+    expectedVersion?: number | null;
+    expected_version?: number | null;
+    verifyHash?: boolean;
+    verify_hash?: boolean;
+    groupId?: string | null;
+    groupAid?: string | null;
+    group_id?: string | null;
+    group_aid?: string | null;
+    srcGroupId?: string | null;
+    srcGroupAid?: string | null;
+    src_group_id?: string | null;
+    src_group_aid?: string | null;
+    dstGroupId?: string | null;
+    dstGroupAid?: string | null;
+    dst_group_id?: string | null;
+    dst_group_aid?: string | null;
+    sourceType?: 'data' | 'path';
+    source_type?: 'data' | 'path';
+    localPath?: boolean;
+    local_path?: boolean;
+    signAs?: string;
+    sign_as?: string;
+    aidStore?: GroupFSAIDStore;
+    aid_store?: GroupFSAIDStore;
+}
+export interface GroupFSDownloadResult {
+    path: string;
+    localPath?: string;
+    size: number;
+    sha256: string;
+    verified: boolean;
+    data: Uint8Array;
+    blob?: Blob;
+    wroteLocalFile?: boolean;
+}
+export declare function isGroupRemotePath(value: string): boolean;
+export declare class GroupFSVFS {
+    readonly lowlevel: StorageLowLevel;
+    private readonly client;
+    constructor(client: GroupFSRpcClient, options?: {
+        lowlevel?: StorageLowLevel;
+    });
+    private call;
+    private prepareParams;
+    ls(path: string, options?: GroupFSParams): Promise<unknown>;
+    find(path: string, options?: GroupFSParams): Promise<unknown>;
+    stat(path: string, options?: GroupFSParams): Promise<unknown>;
+    lstat(path: string, options?: GroupFSParams): Promise<unknown>;
+    mkdir(path: string, options?: GroupFSParams & {
+        parents?: boolean;
+    }): Promise<unknown>;
+    setAcl(path: string, options?: GroupFSParams & {
+        granteeAid?: string;
+        grantee_aid?: string;
+        perms?: string;
+    }): Promise<unknown>;
+    removeAcl(path: string, options?: GroupFSParams & {
+        granteeAid?: string;
+        grantee_aid?: string;
+    }): Promise<unknown>;
+    getAcl(path: string, options?: GroupFSParams): Promise<unknown>;
+    listAcl(path: string, options?: GroupFSParams): Promise<unknown>;
+    rm(path: string, options?: GroupFSParams & {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<unknown>;
+    cp(src: GroupFSCpSource, dst: GroupFSCpDestination, options?: GroupFSCpOptions): Promise<unknown>;
+    mv(src: string, dst: string, options?: GroupFSCpOptions): Promise<unknown>;
+    df(pathOrGroup?: string | null, options?: GroupFSParams): Promise<unknown>;
+    mount(path: string, options?: GroupFSParams): Promise<unknown>;
+    umount(path: string, options?: GroupFSParams): Promise<unknown>;
+    private remoteCopyParams;
+    private copyRemoteToRemote;
+    private sourceBytes;
+    private uploadToGroup;
+    private downloadFromGroup;
+}
+export {};
+//# sourceMappingURL=group-fs.d.ts.map

package/dist/group-fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-fs.d.ts","sourceRoot":"","sources":["../src/group-fs.ts"],"names":[],"mappings":"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"}

package/dist/group-fs.js

@@ -0,0 +1,539 @@
+import { StorageConflictError, StorageError, StorageExistsError, mapStorageError } from './storage/errors.js';
+import { StorageLowLevel } from './storage/lowlevel.js';
+const WINDOWS_DRIVE_RE = /^[A-Za-z]:[\\/]/;
+const GROUP_REF_RE = /^[^:/\\][^:]*:\//;
+const LOCAL_PREFIX = 'local:';
+function isExplicitLocalPath(value) {
+    return String(value || '').trim().toLowerCase().startsWith(LOCAL_PREFIX);
+}
+function stripLocalPathPrefix(value) {
+    const text = String(value || '').trim();
+    return text.toLowerCase().startsWith(LOCAL_PREFIX) ? text.slice(LOCAL_PREFIX.length) : text;
+}
+function isGroupRemoteCopyPath(value, ...groupHints) {
+    if (isExplicitLocalPath(value))
+        return false;
+    return isGroupRemotePath(value) || groupHints.some(Boolean);
+}
+export function isGroupRemotePath(value) {
+    const text = String(value || '').trim();
+    if (!text)
+        return false;
+    if (isExplicitLocalPath(text))
+        return false;
+    if (WINDOWS_DRIVE_RE.test(text))
+        return false;
+    if (text.startsWith('http://') || text.startsWith('https://'))
+        return true;
+    return GROUP_REF_RE.test(text);
+}
+function stripNil(params) {
+    const out = {};
+    for (const [key, value] of Object.entries(params ?? {})) {
+        if (value !== undefined && value !== null)
+            out[key] = value;
+    }
+    return out;
+}
+async function loadSigningAID(store, signAs) {
+    const loaded = store.load
+        ? await store.load(signAs)
+        : store.loadAsync
+            ? await store.loadAsync(signAs)
+            : null;
+    if (!loaded?.ok || !loaded.data?.aid) {
+        throw new Error(loaded?.error?.message || `signer identity not found: ${signAs}`);
+    }
+    if (!loaded.data.aid.privateKeyPem) {
+        throw new Error(`signer identity missing private key: ${signAs}`);
+    }
+    return loaded.data.aid;
+}
+function text(value) {
+    return value === undefined || value === null ? '' : String(value).trim();
+}
+function accessTokenFromClient(client) {
+    const authClient = client;
+    if (typeof authClient.getAccessToken === 'function') {
+        const token = text(authClient.getAccessToken());
+        if (token)
+            return token;
+    }
+    const directToken = text(authClient.accessToken ?? authClient.access_token);
+    if (directToken)
+        return directToken;
+    const identityToken = text(authClient._identity?.access_token);
+    if (identityToken)
+        return identityToken;
+    return text(authClient._sessionParams?.access_token);
+}
+function bearerHeaders(client) {
+    const token = accessTokenFromClient(client);
+    return token ? { Authorization: `Bearer ${token}` } : undefined;
+}
+function toExactArrayBuffer(bytes) {
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+async function sha256Hex(data) {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle?.digest)
+        throw new StorageError('SHA-256 unavailable', 'EUNSUPPORTED');
+    const digest = await subtle.digest('SHA-256', toExactArrayBuffer(data));
+    return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+async function blobToBytes(blob) {
+    if (typeof blob.arrayBuffer === 'function') {
+        return new Uint8Array(await blob.arrayBuffer());
+    }
+    if (typeof blob.stream === 'function' && typeof Response !== 'undefined') {
+        return new Uint8Array(await new Response(blob).arrayBuffer());
+    }
+    if (typeof FileReader !== 'undefined') {
+        return await new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => resolve(new Uint8Array(reader.result));
+            reader.onerror = () => reject(reader.error ?? new StorageError('Blob read failed', 'ESTORAGE'));
+            reader.readAsArrayBuffer(blob);
+        });
+    }
+    if (typeof blob.text === 'function') {
+        return new TextEncoder().encode(await blob.text());
+    }
+    throw new StorageError('Blob reads are unavailable in this JavaScript runtime', 'EUNSUPPORTED');
+}
+async function toBytes(source) {
+    if (typeof source === 'string')
+        return new TextEncoder().encode(source);
+    if (source instanceof Uint8Array)
+        return source;
+    if (source instanceof ArrayBuffer)
+        return new Uint8Array(source);
+    if (typeof Blob !== 'undefined' && source instanceof Blob) {
+        return blobToBytes(source);
+    }
+    if (ArrayBuffer.isView(source)) {
+        return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    }
+    throw new StorageError('unsupported group fs upload source', 'EUNSUPPORTED');
+}
+async function importNodeModule(specifier) {
+    if (typeof document !== 'undefined')
+        return null;
+    const getBuiltinModule = globalThis.process?.getBuiltinModule;
+    if (typeof getBuiltinModule === 'function' && specifier.startsWith('node:')) {
+        try {
+            return getBuiltinModule(specifier.slice('node:'.length));
+        }
+        catch {
+            // 回退到动态 import。
+        }
+    }
+    try {
+        const requireFn = Function('return typeof require !== "undefined" ? require : undefined');
+        const requireModule = requireFn();
+        if (requireModule)
+            return requireModule(specifier);
+    }
+    catch {
+        // 回退到动态 import。
+    }
+    try {
+        const dynamicImport = Function(`return import(${JSON.stringify(specifier)})`);
+        return await dynamicImport();
+    }
+    catch {
+        return null;
+    }
+}
+async function readLocalFile(path) {
+    const fs = await importNodeModule('node:fs/promises');
+    if (!fs?.readFile)
+        throw new StorageError('local file reads are unavailable in this JavaScript runtime', 'EUNSUPPORTED', path);
+    return new Uint8Array(await fs.readFile(path));
+}
+async function writeLocalFile(path, data, force) {
+    const fs = await importNodeModule('node:fs/promises');
+    const pathMod = await importNodeModule('node:path');
+    if (!fs?.writeFile || !pathMod?.dirname)
+        return false;
+    await fs.mkdir(pathMod.dirname(path), { recursive: true });
+    try {
+        await fs.writeFile(path, data, force ? undefined : { flag: 'wx' });
+        return true;
+    }
+    catch (exc) {
+        const code = text(exc.code);
+        if (code === 'EEXIST')
+            throw new StorageExistsError(`local path already exists: ${path}`, 'EEXIST', path);
+        throw exc;
+    }
+}
+async function localFileStatus(path) {
+    const fs = await importNodeModule('node:fs/promises');
+    if (!fs?.stat)
+        return 'unavailable';
+    try {
+        const info = await fs.stat(path);
+        return info.isDirectory() ? 'dir' : 'file';
+    }
+    catch (exc) {
+        const code = text(exc.code);
+        if (code === 'ENOENT')
+            return 'missing';
+        throw exc;
+    }
+}
+function guessContentType(path) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith('.md'))
+        return 'text/markdown';
+    if (lower.endsWith('.txt'))
+        return 'text/plain';
+    if (lower.endsWith('.json'))
+        return 'application/json';
+    if (lower.endsWith('.html') || lower.endsWith('.htm'))
+        return 'text/html';
+    if (lower.endsWith('.png'))
+        return 'image/png';
+    if (lower.endsWith('.jpg') || lower.endsWith('.jpeg'))
+        return 'image/jpeg';
+    return 'application/octet-stream';
+}
+function downloadTarget(dst) {
+    if (typeof dst === 'string') {
+        if (dst === 'blob:')
+            return { mode: 'blob' };
+        if (dst === 'bytes:')
+            return { mode: 'bytes' };
+        return { mode: 'local', localPath: stripLocalPathPrefix(dst) };
+    }
+    const mode = dst.type === 'blob' ? 'blob' : dst.type === 'bytes' ? 'bytes' : dst.path || dst.localPath ? 'local' : 'bytes';
+    const localPath = dst.path ?? dst.localPath;
+    return { mode, localPath: localPath ? stripLocalPathPrefix(localPath) : localPath };
+}
+export class GroupFSVFS {
+    lowlevel;
+    client;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.lowlevel = options.lowlevel ?? new StorageLowLevel(client);
+    }
+    async call(method, params, path = '') {
+        try {
+            return await this.client.call(method, await this.prepareParams(params));
+        }
+        catch (exc) {
+            throw mapStorageError(exc, path);
+        }
+    }
+    async prepareParams(params) {
+        const next = { ...(params ?? {}) };
+        const signAs = text(next.sign_as ?? next.signAs);
+        const aidStore = (next.aid_store ?? next.aidStore);
+        delete next.sign_as;
+        delete next.signAs;
+        delete next.aid_store;
+        delete next.aidStore;
+        if (signAs) {
+            const currentAid = text(this.client.aid ?? this.client._aid);
+            if (currentAid.toLowerCase() !== signAs.toLowerCase()) {
+                if (!aidStore) {
+                    throw new Error(`group.fs operation requires aidStore to sign as ${signAs}`);
+                }
+                next._client_signature_identity = await loadSigningAID(aidStore, signAs);
+            }
+        }
+        return stripNil(next);
+    }
+    ls(path, options = {}) {
+        return this.call('group.fs.ls', { path, ...options }, path);
+    }
+    find(path, options = {}) {
+        return this.call('group.fs.find', { path, ...options }, path);
+    }
+    stat(path, options = {}) {
+        return this.call('group.fs.stat', { path, ...options }, path);
+    }
+    lstat(path, options = {}) {
+        return this.call('group.fs.lstat', { path, ...options }, path);
+    }
+    mkdir(path, options = {}) {
+        return this.call('group.fs.mkdir', { path, parents: options.parents ?? false, ...options }, path);
+    }
+    setAcl(path, options = {}) {
+        const grantee = options.grantee_aid ?? options.granteeAid ?? 'role:admin';
+        const params = { ...options, path, grantee_aid: grantee, perms: options.perms ?? 'rwx' };
+        delete params.granteeAid;
+        return this.call('group.fs.set_acl', params, path);
+    }
+    removeAcl(path, options = {}) {
+        const grantee = options.grantee_aid ?? options.granteeAid ?? 'role:admin';
+        const params = { ...options, path, grantee_aid: grantee };
+        delete params.granteeAid;
+        return this.call('group.fs.remove_acl', params, path);
+    }
+    getAcl(path, options = {}) {
+        return this.call('group.fs.get_acl', { path, ...options }, path);
+    }
+    listAcl(path, options = {}) {
+        return this.call('group.fs.list_acl', { path, ...options }, path);
+    }
+    rm(path, options = {}) {
+        return this.call('group.fs.rm', {
+            path,
+            recursive: options.recursive ?? false,
+            force: options.force ?? false,
+            ...options,
+        }, path);
+    }
+    async cp(src, dst, options = {}) {
+        const groupRef = options.group_aid ?? options.groupAid ?? options.group_id ?? options.groupId;
+        const srcGroupRef = options.src_group_aid ?? options.srcGroupAid ?? options.src_group_id ?? options.srcGroupId;
+        const dstGroupRef = options.dst_group_aid ?? options.dstGroupAid ?? options.dst_group_id ?? options.dstGroupId;
+        const srcRemote = typeof src === 'string' && isGroupRemoteCopyPath(src, srcGroupRef, groupRef);
+        const dstRemote = typeof dst === 'string' && isGroupRemoteCopyPath(dst, dstGroupRef, groupRef);
+        if (srcRemote && dstRemote)
+            return this.copyRemoteToRemote(src, dst, options);
+        if (!srcRemote && dstRemote)
+            return this.uploadToGroup(src, dst, options);
+        if (srcRemote && !dstRemote)
+            return this.downloadFromGroup(src, dst, options);
+        throw new StorageError('local-to-local copy is not handled by group.fs', 'EINVAL', typeof src === 'string' ? src : '');
+    }
+    async mv(src, dst, options = {}) {
+        const groupRef = options.group_aid ?? options.groupAid ?? options.group_id ?? options.groupId;
+        const srcGroupRef = options.src_group_aid ?? options.srcGroupAid ?? options.src_group_id ?? options.srcGroupId;
+        const dstGroupRef = options.dst_group_aid ?? options.dstGroupAid ?? options.dst_group_id ?? options.dstGroupId;
+        if (!isGroupRemoteCopyPath(src, srcGroupRef, groupRef) || !isGroupRemoteCopyPath(dst, dstGroupRef, groupRef)) {
+            throw new StorageError('group.fs.mv only supports group remote paths', 'EINVAL', src);
+        }
+        const params = this.remoteCopyParams(src, dst, options);
+        return this.call('group.fs.mv', params, src);
+    }
+    df(pathOrGroup, options = {}) {
+        const params = { ...options };
+        if (pathOrGroup !== undefined && pathOrGroup !== null)
+            params.path = pathOrGroup;
+        return this.call('group.fs.df', params, pathOrGroup ?? '');
+    }
+    mount(path, options = {}) {
+        return this.call('group.fs.mount', { path, ...options }, path);
+    }
+    umount(path, options = {}) {
+        return this.call('group.fs.umount', { path, ...options }, path);
+    }
+    remoteCopyParams(src, dst, options) {
+        const params = { ...options, src, dst };
+        delete params.contentType;
+        delete params.content_type;
+        delete params.metadata;
+        delete params.expectedVersion;
+        delete params.expected_version;
+        delete params.parents;
+        delete params.verifyHash;
+        delete params.verify_hash;
+        delete params.sourceType;
+        delete params.source_type;
+        delete params.localPath;
+        delete params.local_path;
+        if (options.groupAid !== undefined)
+            params.group_aid = options.groupAid;
+        if (options.groupId !== undefined)
+            params.group_id = options.groupId;
+        if (options.srcGroupAid !== undefined)
+            params.src_group_aid = options.srcGroupAid;
+        if (options.srcGroupId !== undefined)
+            params.src_group_id = options.srcGroupId;
+        if (options.dstGroupAid !== undefined)
+            params.dst_group_aid = options.dstGroupAid;
+        if (options.dstGroupId !== undefined)
+            params.dst_group_id = options.dstGroupId;
+        if (options.followSymlinks !== undefined)
+            params.follow_symlinks = options.followSymlinks;
+        delete params.groupAid;
+        delete params.srcGroupAid;
+        delete params.dstGroupAid;
+        delete params.followSymlinks;
+        if (!options.force)
+            delete params.force;
+        if (!options.recursive)
+            delete params.recursive;
+        return stripNil(params);
+    }
+    copyRemoteToRemote(src, dst, options) {
+        return this.call('group.fs.cp', this.remoteCopyParams(src, dst, options), src);
+    }
+    async sourceBytes(src, options) {
+        if (typeof src === 'string') {
+            const sourceType = text(options.source_type ?? options.sourceType);
+            if (isExplicitLocalPath(src) || sourceType === 'path' || options.localPath === true || options.local_path === true) {
+                const localPath = stripLocalPathPrefix(src);
+                return { data: await readLocalFile(localPath), contentType: guessContentType(localPath) };
+            }
+            return { data: await toBytes(src), contentType: 'text/plain;charset=utf-8' };
+        }
+        const data = await toBytes(src);
+        const blobType = typeof Blob !== 'undefined' && src instanceof Blob ? text(src.type) : '';
+        const fileName = text(src.name);
+        return { data, contentType: blobType || (fileName ? guessContentType(fileName) : 'application/octet-stream') };
+    }
+    async uploadToGroup(src, dst, options) {
+        const { data, contentType } = await this.sourceBytes(src, options);
+        const digest = await sha256Hex(data);
+        const groupAid = options.group_aid ?? options.groupAid ?? options.dst_group_aid ?? options.dstGroupAid;
+        const groupId = options.group_id ?? options.groupId ?? options.dst_group_id ?? options.dstGroupId;
+        const baseParams = stripNil({
+            ...options,
+            path: dst,
+            group_aid: groupAid,
+            group_id: groupAid ? undefined : groupId,
+            size_bytes: data.byteLength,
+            sha256: digest,
+            content_type: options.content_type ?? options.contentType ?? contentType,
+            force: options.force ?? false,
+            parents: options.parents ?? true,
+            metadata: options.metadata,
+            expected_version: options.expected_version ?? options.expectedVersion,
+        });
+        delete baseParams.groupId;
+        delete baseParams.groupAid;
+        delete baseParams.dstGroupId;
+        delete baseParams.dstGroupAid;
+        delete baseParams.dst_group_aid;
+        delete baseParams.dst_group_id;
+        delete baseParams.srcGroupId;
+        delete baseParams.srcGroupAid;
+        delete baseParams.src_group_aid;
+        delete baseParams.src_group_id;
+        delete baseParams.contentType;
+        delete baseParams.expectedVersion;
+        delete baseParams.verifyHash;
+        delete baseParams.verify_hash;
+        delete baseParams.recursive;
+        delete baseParams.followSymlinks;
+        delete baseParams.follow_symlinks;
+        delete baseParams.sourceType;
+        delete baseParams.source_type;
+        delete baseParams.localPath;
+        delete baseParams.local_path;
+        const check = await this.call('group.fs.check_upload', baseParams, dst);
+        if (check && typeof check === 'object') {
+            const raw = check;
+            if (raw.within_limit === false)
+                throw new StorageError('file size exceeds group fs upload limit', 'E2BIG', dst, raw);
+            if (raw.target_exists && !options.force && options.expected_version === undefined && options.expectedVersion === undefined) {
+                throw new StorageExistsError('group fs target already exists', 'EEXIST', dst, raw.target);
+            }
+            if (raw.instant || raw.dedup_hit || raw.skip_upload) {
+                return this.call('group.fs.complete_upload', {
+                    ...baseParams,
+                    skip_blob: true,
+                    session_id: raw.session_id,
+                }, dst);
+            }
+        }
+        const session = await this.call('group.fs.create_upload_session', baseParams, dst);
+        if (!session || typeof session !== 'object') {
+            throw new StorageError(`group.fs.create_upload_session returned invalid response`, 'ESTORAGE', dst, session);
+        }
+        const rawSession = session;
+        const uploadUrl = text(rawSession.upload_url ?? rawSession.url);
+        if (!uploadUrl)
+            throw new StorageError('group.fs.create_upload_session did not return upload_url', 'ESTORAGE', dst, session);
+        const headers = {};
+        if (rawSession.headers && typeof rawSession.headers === 'object' && !Array.isArray(rawSession.headers)) {
+            for (const [key, value] of Object.entries(rawSession.headers)) {
+                if (value !== undefined && value !== null)
+                    headers[key] = String(value);
+            }
+        }
+        if (!Object.keys(headers).some((key) => key.toLowerCase() === 'content-type')) {
+            headers['Content-Type'] = text(baseParams.content_type) || 'application/octet-stream';
+        }
+        await this.lowlevel.httpPut(uploadUrl, data, headers);
+        return this.call('group.fs.complete_upload', {
+            ...baseParams,
+            session_id: rawSession.session_id ?? rawSession.id,
+        }, dst);
+    }
+    async downloadFromGroup(src, dst, options) {
+        const target = downloadTarget(dst);
+        if (target.mode === 'local' && target.localPath) {
+            const status = await localFileStatus(target.localPath);
+            if (status === 'file' && !options.force) {
+                throw new StorageExistsError(`local path already exists: ${target.localPath}`, 'EEXIST', target.localPath);
+            }
+        }
+        const groupAid = options.group_aid ?? options.groupAid ?? options.src_group_aid ?? options.srcGroupAid;
+        const groupId = options.group_id ?? options.groupId ?? options.src_group_id ?? options.srcGroupId;
+        const params = stripNil({
+            ...options,
+            path: src,
+            group_aid: groupAid,
+            group_id: groupAid ? undefined : groupId,
+        });
+        delete params.groupId;
+        delete params.groupAid;
+        delete params.srcGroupId;
+        delete params.srcGroupAid;
+        delete params.src_group_aid;
+        delete params.src_group_id;
+        delete params.dstGroupId;
+        delete params.dstGroupAid;
+        delete params.dst_group_aid;
+        delete params.dst_group_id;
+        delete params.force;
+        delete params.recursive;
+        delete params.parents;
+        delete params.contentType;
+        delete params.content_type;
+        delete params.expectedVersion;
+        delete params.expected_version;
+        delete params.verifyHash;
+        delete params.verify_hash;
+        delete params.sourceType;
+        delete params.source_type;
+        delete params.localPath;
+        delete params.local_path;
+        const ticket = await this.call('group.fs.create_download_ticket', params, src);
+        if (!ticket || typeof ticket !== 'object') {
+            throw new StorageError('group.fs.create_download_ticket returned invalid response', 'ESTORAGE', src, ticket);
+        }
+        const rawTicket = ticket;
+        const downloadUrl = text(rawTicket.download_url ?? rawTicket.url);
+        if (!downloadUrl)
+            throw new StorageError('group.fs.create_download_ticket did not return download_url', 'ESTORAGE', src, ticket);
+        const data = await this.lowlevel.httpGet(downloadUrl, bearerHeaders(this.client));
+        const expectedSha = text(rawTicket.sha256);
+        const verifyHash = options.verify_hash ?? options.verifyHash ?? true;
+        const verified = !verifyHash || !expectedSha || (await sha256Hex(data)) === expectedSha.toLowerCase();
+        if (verifyHash && !verified) {
+            throw new StorageConflictError('download hash verification failed', 'ECONFLICT', src, ticket);
+        }
+        if (target.mode === 'local' && target.localPath) {
+            const status = await localFileStatus(target.localPath);
+            if (status === 'dir') {
+                throw new StorageError('directory download target is not supported in this JavaScript runtime', 'EISDIR', target.localPath);
+            }
+            if (status === 'file' && !options.force) {
+                throw new StorageExistsError(`local path already exists: ${target.localPath}`, 'EEXIST', target.localPath);
+            }
+        }
+        const result = {
+            path: src,
+            localPath: target.localPath,
+            size: data.byteLength,
+            sha256: expectedSha,
+            verified,
+            data,
+        };
+        if (target.mode === 'blob' && typeof Blob !== 'undefined') {
+            result.blob = new Blob([toExactArrayBuffer(data)], { type: text(rawTicket.content_type) || 'application/octet-stream' });
+        }
+        if (target.mode === 'local' && target.localPath) {
+            result.wroteLocalFile = await writeLocalFile(target.localPath, data, Boolean(options.force));
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=group-fs.js.map