@aigne/afs-gcs 1.11.0-beta.6

package/dist/index.mjs

@@ -0,0 +1,1055 @@
+import { AFSBaseProvider, AFSError, AFSNotFoundError, Actions, Delete, List, Meta, Read, Stat, Write } from "@aigne/afs";
+import { camelize, optionalize, zodParse } from "@aigne/afs/utils/zod";
+import { Storage } from "@google-cloud/storage";
+import { z } from "zod";
+
+//#region src/cache.ts
+/**
+* LRU Cache with TTL support
+*/
+var LRUCache = class {
+	cache = /* @__PURE__ */ new Map();
+	maxSize;
+	defaultTtl;
+	/**
+	* Create a new LRU cache
+	*
+	* @param maxSize - Maximum number of entries (default: 1000)
+	* @param defaultTtl - Default TTL in seconds (default: 60)
+	*/
+	constructor(maxSize = 1e3, defaultTtl = 60) {
+		this.maxSize = maxSize;
+		this.defaultTtl = defaultTtl;
+	}
+	/**
+	* Get a value from the cache
+	*
+	* @param key - Cache key
+	* @returns Cached value or undefined if not found/expired
+	*/
+	get(key) {
+		const entry = this.cache.get(key);
+		if (!entry) return;
+		if (Date.now() > entry.expiresAt) {
+			this.cache.delete(key);
+			return;
+		}
+		this.cache.delete(key);
+		this.cache.set(key, entry);
+		return entry.value;
+	}
+	/**
+	* Set a value in the cache
+	*
+	* @param key - Cache key
+	* @param value - Value to cache
+	* @param ttl - TTL in seconds (optional, uses default)
+	*/
+	set(key, value, ttl) {
+		if (this.cache.has(key)) this.cache.delete(key);
+		while (this.cache.size >= this.maxSize) {
+			const oldestKey = this.cache.keys().next().value;
+			if (oldestKey) this.cache.delete(oldestKey);
+		}
+		const expiresAt = Date.now() + (ttl ?? this.defaultTtl) * 1e3;
+		this.cache.set(key, {
+			value,
+			expiresAt
+		});
+	}
+	/**
+	* Delete a value from the cache
+	*
+	* @param key - Cache key
+	*/
+	delete(key) {
+		this.cache.delete(key);
+	}
+	/**
+	* Delete all entries matching a prefix
+	*
+	* @param prefix - Key prefix to match
+	*/
+	deleteByPrefix(prefix) {
+		for (const key of this.cache.keys()) if (key.startsWith(prefix)) this.cache.delete(key);
+	}
+	/**
+	* Clear all entries
+	*/
+	clear() {
+		this.cache.clear();
+	}
+	/**
+	* Get the number of entries in the cache
+	*/
+	get size() {
+		return this.cache.size;
+	}
+	/**
+	* Prune expired entries
+	*/
+	prune() {
+		const now = Date.now();
+		for (const [key, entry] of this.cache.entries()) if (now > entry.expiresAt) this.cache.delete(key);
+	}
+};
+/**
+* Create a cache key from bucket, prefix, and path
+*/
+function createCacheKey(bucket, prefix, path, suffix) {
+	const base = `${bucket}:${prefix}:${path}`;
+	return suffix ? `${base}:${suffix}` : base;
+}
+
+//#endregion
+//#region src/client.ts
+/**
+* GCS Client Factory
+*
+* Creates configured Google Cloud Storage clients.
+*/
+/**
+* Create a GCS Storage client from options
+*
+* @param options - AFSGCS options
+* @returns Configured Storage client
+*/
+function createGCSClient(options) {
+	const storageOptions = {};
+	if (options.projectId) storageOptions.projectId = options.projectId;
+	if (options.endpoint) storageOptions.apiEndpoint = options.endpoint;
+	if (options.keyFilename) storageOptions.keyFilename = options.keyFilename;
+	if (options.credentials) storageOptions.credentials = {
+		client_email: options.credentials.clientEmail,
+		private_key: options.credentials.privateKey
+	};
+	return new Storage(storageOptions);
+}
+
+//#endregion
+//#region src/errors.ts
+/**
+* GCS Provider Error Handling
+*
+* Maps GCS SDK errors to AFS error types.
+*/
+/**
+* AFS error codes
+*/
+const AFSErrorCode = {
+	ENTRY_NOT_FOUND: "ENTRY_NOT_FOUND",
+	MODULE_NOT_FOUND: "MODULE_NOT_FOUND",
+	PERMISSION_DENIED: "PERMISSION_DENIED",
+	AUTH_ERROR: "AUTH_ERROR",
+	RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+	INVALID_OPERATION: "INVALID_OPERATION",
+	ALREADY_EXISTS: "ALREADY_EXISTS",
+	SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+	UNKNOWN: "UNKNOWN"
+};
+/**
+* AFS Error class
+*/
+var AFSError$1 = class extends Error {
+	code;
+	retryAfter;
+	constructor(code, message, options) {
+		super(message);
+		this.name = "AFSError";
+		this.code = code;
+		this.retryAfter = options?.retryAfter;
+	}
+};
+/**
+* Custom GCS error class for internal use
+*/
+var GCSError = class extends Error {
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "GCSError";
+	}
+};
+/**
+* Map GCS HTTP status codes to AFS error codes
+*/
+const STATUS_TO_AFS_ERROR = {
+	400: AFSErrorCode.INVALID_OPERATION,
+	401: AFSErrorCode.AUTH_ERROR,
+	403: AFSErrorCode.PERMISSION_DENIED,
+	404: AFSErrorCode.ENTRY_NOT_FOUND,
+	409: AFSErrorCode.ALREADY_EXISTS,
+	429: AFSErrorCode.RATE_LIMIT_EXCEEDED,
+	503: AFSErrorCode.SERVICE_UNAVAILABLE
+};
+/**
+* Map GCS error to AFS error
+*
+* @param error - GCS SDK error or generic error
+* @returns AFSError with appropriate error code
+*/
+function mapGCSError(error) {
+	if (error instanceof GCSError) return new AFSError$1(STATUS_TO_AFS_ERROR[error.code] ?? AFSErrorCode.UNKNOWN, error.message);
+	if (typeof error === "object" && error !== null && "code" in error) {
+		const err = error;
+		const statusCode = typeof err.code === "number" ? err.code : 500;
+		const message = err.message ?? "Unknown GCS error";
+		return new AFSError$1(STATUS_TO_AFS_ERROR[statusCode] ?? AFSErrorCode.UNKNOWN, message);
+	}
+	if (error instanceof Error) return new AFSError$1(AFSErrorCode.UNKNOWN, error.message);
+	return new AFSError$1(AFSErrorCode.UNKNOWN, String(error));
+}
+
+//#endregion
+//#region src/platform-ref.ts
+/**
+* Generate platform reference with GCP Console URL
+*
+* @param bucket - GCS bucket name
+* @param prefix - Object prefix/key (without leading slash)
+* @param isDirectory - Whether this is a directory (prefix)
+* @returns Platform reference with console URL
+*/
+function generatePlatformRef(bucket, prefix, isDirectory) {
+	if (isDirectory) return { consoleUrl: `https://console.cloud.google.com/storage/browser/${bucket}/${prefix.endsWith("/") ? prefix : prefix ? `${prefix}/` : ""}` };
+	return { consoleUrl: `https://console.cloud.google.com/storage/browser/_details/${bucket}/${encodeURIComponent(prefix).replace(/%2F/g, "/")}` };
+}
+
+//#endregion
+//#region src/types.ts
+/**
+* AFS GCS Provider Types
+*/
+/**
+* GCS bucket name validation regex
+* - 3-63 characters
+* - lowercase letters, numbers, hyphens, dots (but not consecutive dots)
+* - must start and end with letter or number
+*/
+const BUCKET_NAME_REGEX = /^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/;
+/**
+* Additional validation for bucket names
+*/
+function isValidBucketName(name) {
+	if (!BUCKET_NAME_REGEX.test(name)) return false;
+	if (name.includes("..")) return false;
+	if (name.includes("_")) return false;
+	return true;
+}
+/**
+* Zod schema for options validation
+*/
+const afsgcsOptionsSchema = camelize(z.object({
+	name: optionalize(z.string()),
+	description: optionalize(z.string()),
+	bucket: z.string().refine(isValidBucketName, "Invalid GCS bucket name"),
+	prefix: optionalize(z.string()),
+	projectId: optionalize(z.string()),
+	accessMode: optionalize(z.enum(["readonly", "readwrite"])),
+	endpoint: optionalize(z.string().url()),
+	keyFilename: optionalize(z.string()),
+	credentials: optionalize(z.object({
+		clientEmail: z.string(),
+		privateKey: z.string()
+	})),
+	cacheTtl: optionalize(z.number().int().min(0))
+}).strict());
+
+//#endregion
+//#region \0@oxc-project+runtime@0.108.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+//#region src/gcs-afs.ts
+/**
+* AFS GCS Provider
+*
+* GCS provider using AFSBaseProvider decorator routing pattern.
+* Provides access to Google Cloud Storage through AFS.
+*/
+/**
+* Default URL expiration time (1 hour)
+*/
+const DEFAULT_EXPIRES_IN = 3600;
+/**
+* Maximum expiration time (7 days)
+*/
+const MAX_EXPIRES_IN = 604800;
+/**
+* Maximum sources for compose operation
+*/
+const MAX_COMPOSE_SOURCES = 32;
+/**
+* AFSGCS Provider using Base Provider pattern
+*
+* Provides access to Google Cloud Storage through AFS.
+* Uses decorator routing (@List, @Read, @Write, @Delete, @Meta, @Actions).
+*
+* @example
+* ```typescript
+* const gcs = new AFSGCS({
+*   bucket: "my-bucket",
+*   prefix: "data",
+*   projectId: "my-project",
+* });
+*
+* // Mount to AFS
+* afs.mount(gcs);
+*
+* // List objects
+* const result = await afs.list("/modules/my-bucket/data");
+*
+* // Read object
+* const content = await afs.read("/modules/my-bucket/data/file.json");
+* ```
+*/
+var AFSGCS = class AFSGCS extends AFSBaseProvider {
+	name;
+	description;
+	accessMode;
+	options;
+	storage;
+	bucket;
+	listCache;
+	statCache;
+	constructor(options) {
+		super();
+		const parsed = afsgcsOptionsSchema.parse(options);
+		this.options = {
+			...parsed,
+			bucket: parsed.bucket,
+			prefix: parsed.prefix ?? "",
+			accessMode: parsed.accessMode ?? "readonly"
+		};
+		this.name = parsed.name ?? parsed.bucket;
+		this.description = parsed.description ?? `GCS bucket: ${parsed.bucket}`;
+		this.accessMode = this.options.accessMode ?? "readonly";
+		this.storage = createGCSClient(this.options);
+		this.bucket = this.storage.bucket(parsed.bucket);
+		if (parsed.cacheTtl && parsed.cacheTtl > 0) {
+			this.listCache = new LRUCache(1e3, parsed.cacheTtl);
+			this.statCache = new LRUCache(5e3, parsed.cacheTtl);
+		}
+	}
+	/**
+	* Schema for configuration validation
+	*/
+	static schema() {
+		return afsgcsOptionsSchema;
+	}
+	/**
+	* Load from configuration file
+	*/
+	static async load(params) {
+		return new AFSGCS(zodParse(afsgcsOptionsSchema, params.parsed, { prefix: params.filepath }));
+	}
+	/**
+	* Build the full GCS key from a path
+	*/
+	buildGCSKey(path) {
+		const normalizedPath = path.replace(/^\/+/, "").replace(/\/+$/, "");
+		return this.options.prefix ? `${this.options.prefix}/${normalizedPath}` : normalizedPath;
+	}
+	/**
+	* Generate a unique ID for a GCS object
+	*/
+	generateId(key) {
+		return `gs://${this.options.bucket}/${key}`;
+	}
+	/**
+	* Invalidate caches for a given path
+	*/
+	invalidateCache(path) {
+		if (this.statCache) {
+			const statKey = createCacheKey(this.options.bucket, this.options.prefix ?? "", path);
+			this.statCache.delete(statKey);
+		}
+		if (this.listCache) {
+			const parentPath = path.split("/").slice(0, -1).join("/") || "/";
+			const listPrefix = createCacheKey(this.options.bucket, this.options.prefix ?? "", parentPath);
+			this.listCache.deleteByPrefix(listPrefix);
+		}
+	}
+	/**
+	* Clear all caches
+	*/
+	clearCache() {
+		this.listCache?.clear();
+		this.statCache?.clear();
+	}
+	async listHandler(ctx) {
+		try {
+			const normalizedPath = (ctx.params.path ?? "").replace(/^\/+/, "").replace(/\/+$/, "");
+			const fullPrefix = this.options.prefix ? normalizedPath ? `${this.options.prefix}/${normalizedPath}/` : `${this.options.prefix}/` : normalizedPath ? `${normalizedPath}/` : "";
+			const maxChildren = ctx.options?.limit ?? 1e3;
+			if (this.listCache) {
+				const cacheKey = createCacheKey(this.options.bucket, this.options.prefix ?? "", normalizedPath, JSON.stringify(ctx.options ?? {}));
+				const cached = this.listCache.get(cacheKey);
+				if (cached) return cached;
+			}
+			const result = await this.listWithDelimiter(fullPrefix, normalizedPath, maxChildren);
+			if (this.listCache) {
+				const cacheKey = createCacheKey(this.options.bucket, this.options.prefix ?? "", normalizedPath, JSON.stringify(ctx.options ?? {}));
+				this.listCache.set(cacheKey, result);
+				if (this.statCache) for (const entry of result.data) {
+					const statKey = createCacheKey(this.options.bucket, this.options.prefix ?? "", entry.path);
+					this.statCache.set(statKey, entry);
+				}
+			}
+			return result;
+		} catch (error) {
+			if (error instanceof AFSNotFoundError) throw error;
+			throw mapGCSError(error);
+		}
+	}
+	/**
+	* List with delimiter (single level)
+	*/
+	async listWithDelimiter(prefix, basePath, maxChildren) {
+		const childEntries = [];
+		const bucketName = this.options.bucket;
+		const [files, , apiResponse] = await this.bucket.getFiles({
+			prefix,
+			delimiter: "/",
+			maxResults: maxChildren
+		});
+		const prefixes = apiResponse?.prefixes;
+		if (prefixes) for (const dirPrefix of prefixes) {
+			if (!dirPrefix) continue;
+			const dirName = dirPrefix.slice(prefix.length).replace(/\/$/, "");
+			if (!dirName) continue;
+			const entryPath = basePath ? `${basePath}/${dirName}` : dirName;
+			const normalizedPath = entryPath.startsWith("/") ? entryPath : `/${entryPath}`;
+			childEntries.push({
+				id: this.generateId(dirPrefix),
+				path: normalizedPath,
+				metadata: {
+					kind: "afs:node",
+					childrenCount: void 0,
+					platformRef: generatePlatformRef(bucketName, dirPrefix, true)
+				}
+			});
+			if (childEntries.length >= maxChildren) break;
+		}
+		for (const file of files) {
+			if (!file.name) continue;
+			if (file.name === prefix) continue;
+			if (file.name.endsWith("/")) {
+				const dirName = file.name.slice(prefix.length).replace(/\/$/, "");
+				if (!dirName) continue;
+				const entryPath$1 = basePath ? `${basePath}/${dirName}` : dirName;
+				const normalizedPath$1 = entryPath$1.startsWith("/") ? entryPath$1 : `/${entryPath$1}`;
+				childEntries.push({
+					id: this.generateId(file.name),
+					path: normalizedPath$1,
+					updatedAt: file.metadata.updated ? new Date(file.metadata.updated) : void 0,
+					metadata: {
+						kind: "afs:node",
+						childrenCount: void 0,
+						platformRef: generatePlatformRef(bucketName, file.name, true)
+					}
+				});
+				if (childEntries.length >= maxChildren) break;
+				continue;
+			}
+			const fileName = file.name.slice(prefix.length);
+			if (!fileName || fileName.includes("/")) continue;
+			const entryPath = basePath ? `${basePath}/${fileName}` : fileName;
+			const normalizedPath = entryPath.startsWith("/") ? entryPath : `/${entryPath}`;
+			childEntries.push({
+				id: this.generateId(file.name),
+				path: normalizedPath,
+				updatedAt: file.metadata.updated ? new Date(file.metadata.updated) : void 0,
+				metadata: {
+					size: file.metadata.size ? Number(file.metadata.size) : void 0,
+					contentType: file.metadata.contentType,
+					lastModified: file.metadata.updated,
+					etag: file.metadata.etag,
+					storageClass: file.metadata.storageClass,
+					platformRef: generatePlatformRef(bucketName, file.name, false)
+				}
+			});
+			if (childEntries.length >= maxChildren) break;
+		}
+		const selfPath = basePath ? basePath.startsWith("/") ? basePath : `/${basePath}` : "/";
+		if (childEntries.length === 0 && basePath) {
+			const key = this.options.prefix ? `${this.options.prefix}/${basePath}` : basePath;
+			const file = this.bucket.file(key);
+			const [fileExists] = await file.exists();
+			if (fileExists) {
+				const [metadata] = await file.getMetadata();
+				return { data: [{
+					id: this.generateId(key),
+					path: selfPath,
+					updatedAt: metadata.updated ? new Date(metadata.updated) : void 0,
+					metadata: {
+						size: metadata.size ? Number(metadata.size) : void 0,
+						contentType: metadata.contentType,
+						lastModified: metadata.updated,
+						etag: metadata.etag,
+						childrenCount: 0,
+						platformRef: generatePlatformRef(bucketName, key, false)
+					}
+				}] };
+			}
+			const [dirExists] = await this.bucket.file(`${key}/`).exists();
+			if (!dirExists) throw new AFSNotFoundError(selfPath);
+		}
+		return { data: [{
+			id: this.generateId(prefix || "/"),
+			path: selfPath,
+			metadata: {
+				kind: "afs:node",
+				childrenCount: childEntries.length,
+				platformRef: generatePlatformRef(bucketName, prefix, true)
+			}
+		}, ...childEntries] };
+	}
+	async listVersionsHandler(ctx) {
+		try {
+			const normalizedPath = ctx.params.path.replace(/^\/+/, "").replace(/\/+$/, "");
+			const key = this.options.prefix ? `${this.options.prefix}/${normalizedPath}` : normalizedPath;
+			const [files] = await this.bucket.getFiles({
+				prefix: key,
+				versions: true
+			});
+			const entries = [];
+			for (const versionFile of files) {
+				if (versionFile.name !== key) continue;
+				const generation = versionFile.metadata.generation;
+				if (!generation) continue;
+				const versionPath = `/${normalizedPath}/@versions/${generation}`;
+				const isLive = !versionFile.metadata.timeDeleted;
+				entries.push({
+					id: `${this.generateId(key)}:${generation}`,
+					path: versionPath,
+					updatedAt: versionFile.metadata.timeCreated ? new Date(versionFile.metadata.timeCreated) : void 0,
+					metadata: {
+						generation,
+						isLive,
+						timeCreated: versionFile.metadata.timeCreated,
+						size: versionFile.metadata.size ? Number(versionFile.metadata.size) : 0,
+						etag: versionFile.metadata.etag
+					}
+				});
+			}
+			return { data: entries };
+		} catch (error) {
+			throw mapGCSError(error);
+		}
+	}
+	async readHandler(ctx) {
+		try {
+			const key = this.buildGCSKey(ctx.params.path);
+			const normalizedOutputPath = ctx.path.startsWith("/") ? ctx.path : `/${ctx.path}`;
+			const bucketName = this.options.bucket;
+			if (!key) {
+				const [files$1, , apiResponse$1] = await this.bucket.getFiles({
+					prefix: this.options.prefix ? `${this.options.prefix}/` : "",
+					delimiter: "/",
+					maxResults: 1e3
+				});
+				const childrenCount = ((apiResponse$1?.prefixes)?.length ?? 0) + files$1.length;
+				return {
+					id: this.generateId("/"),
+					path: "/",
+					content: "",
+					metadata: {
+						kind: "afs:node",
+						childrenCount,
+						platformRef: generatePlatformRef(bucketName, "", true)
+					}
+				};
+			}
+			const file = this.bucket.file(key);
+			const [exists] = await file.exists();
+			if (exists) {
+				const [metadata] = await file.getMetadata();
+				if (key.endsWith("/") || metadata.contentType === "application/x-directory") return {
+					id: this.generateId(key),
+					path: normalizedOutputPath,
+					content: "",
+					updatedAt: metadata.updated ? new Date(metadata.updated) : void 0,
+					metadata: {
+						kind: "afs:node",
+						childrenCount: void 0,
+						platformRef: generatePlatformRef(bucketName, key, true)
+					}
+				};
+				const [content] = await file.download();
+				return {
+					id: this.generateId(key),
+					path: normalizedOutputPath,
+					content: content.toString("utf-8"),
+					updatedAt: metadata.updated ? new Date(metadata.updated) : void 0,
+					metadata: {
+						size: metadata.size ? Number(metadata.size) : void 0,
+						mimeType: metadata.contentType,
+						contentType: metadata.contentType,
+						lastModified: metadata.updated,
+						etag: metadata.etag
+					}
+				};
+			}
+			const [files, , apiResponse] = await this.bucket.getFiles({
+				prefix: `${key}/`,
+				delimiter: "/",
+				maxResults: 1e3
+			});
+			const prefixes = apiResponse?.prefixes;
+			if (files.length > 0 || prefixes && prefixes.length > 0) {
+				const childrenCount = (prefixes?.length ?? 0) + files.length;
+				return {
+					id: this.generateId(`${key}/`),
+					path: normalizedOutputPath,
+					content: "",
+					metadata: {
+						kind: "afs:node",
+						childrenCount,
+						platformRef: generatePlatformRef(bucketName, key, true)
+					}
+				};
+			}
+			const dirMarker = this.bucket.file(`${key}/`);
+			const [dirExists] = await dirMarker.exists();
+			if (dirExists) {
+				const [dirMetadata] = await dirMarker.getMetadata();
+				return {
+					id: this.generateId(`${key}/`),
+					path: normalizedOutputPath,
+					content: "",
+					updatedAt: dirMetadata.updated ? new Date(dirMetadata.updated) : void 0,
+					metadata: {
+						kind: "afs:node",
+						childrenCount: void 0,
+						platformRef: generatePlatformRef(bucketName, key, true)
+					}
+				};
+			}
+			throw new AFSNotFoundError(`/${ctx.params.path}`);
+		} catch (error) {
+			if (error instanceof AFSError || error instanceof AFSNotFoundError) throw error;
+			throw mapGCSError(error);
+		}
+	}
+	async readVersionHandler(ctx) {
+		try {
+			const normalizedPath = ctx.params.path.replace(/^\/+/, "").replace(/\/+$/, "");
+			const key = this.options.prefix ? `${this.options.prefix}/${normalizedPath}` : normalizedPath;
+			const generation = ctx.params.generation;
+			const file = this.bucket.file(key, { generation: parseInt(generation, 10) });
+			const [exists] = await file.exists();
+			if (!exists) throw new AFSNotFoundError(`/${normalizedPath}/@versions/${generation}`);
+			const [content] = await file.download();
+			const [metadata] = await file.getMetadata();
+			return {
+				id: `${this.generateId(key)}:${generation}`,
+				path: ctx.path,
+				content: content.toString("utf-8"),
+				updatedAt: metadata.timeCreated ? new Date(metadata.timeCreated) : void 0,
+				metadata: {
+					size: metadata.size ? Number(metadata.size) : void 0,
+					contentType: metadata.contentType,
+					timeCreated: metadata.timeCreated,
+					etag: metadata.etag,
+					generation: metadata.generation
+				}
+			};
+		} catch (error) {
+			if (error instanceof AFSNotFoundError) throw error;
+			throw mapGCSError(error);
+		}
+	}
+	async metaHandler(ctx) {
+		try {
+			const path = ctx.params.path ?? "";
+			const normalizedPath = path.replace(/^\/+/, "").replace(/\/+$/, "");
+			const key = this.options.prefix ? normalizedPath ? `${this.options.prefix}/${normalizedPath}` : this.options.prefix : normalizedPath;
+			const bucketName = this.options.bucket;
+			if (!key) {
+				const [files$1, , apiResponse] = await this.bucket.getFiles({
+					prefix: this.options.prefix ? `${this.options.prefix}/` : "",
+					delimiter: "/",
+					maxResults: 1e3
+				});
+				const childrenCount = ((apiResponse?.prefixes)?.length ?? 0) + files$1.length;
+				return {
+					id: this.generateId("/"),
+					path: "/.meta",
+					metadata: {
+						kind: "afs:node",
+						childrenCount,
+						platformRef: generatePlatformRef(bucketName, "", true)
+					}
+				};
+			}
+			if (this.statCache) {
+				const cacheKey = createCacheKey(bucketName, this.options.prefix ?? "", path);
+				const cached = this.statCache.get(cacheKey);
+				if (cached) return {
+					id: cached.id,
+					path: ctx.path,
+					metadata: cached.metadata
+				};
+			}
+			const file = this.bucket.file(key);
+			const [exists] = await file.exists();
+			if (exists) {
+				const [metadata] = await file.getMetadata();
+				if (key.endsWith("/") || metadata.contentType === "application/x-directory") return {
+					id: this.generateId(key),
+					path: ctx.path,
+					updatedAt: metadata.updated ? new Date(metadata.updated) : void 0,
+					metadata: {
+						kind: "afs:node",
+						childrenCount: void 0,
+						platformRef: generatePlatformRef(bucketName, key, true)
+					}
+				};
+				const result = {
+					id: this.generateId(key),
+					path: ctx.path,
+					updatedAt: metadata.updated ? new Date(metadata.updated) : void 0,
+					metadata: {
+						kind: "afs:document",
+						size: metadata.size ? Number(metadata.size) : void 0,
+						contentType: metadata.contentType,
+						lastModified: metadata.updated,
+						etag: metadata.etag,
+						storageClass: metadata.storageClass,
+						generation: metadata.generation,
+						metageneration: metadata.metageneration,
+						crc32c: metadata.crc32c,
+						md5Hash: metadata.md5Hash,
+						platformRef: generatePlatformRef(bucketName, key, false)
+					}
+				};
+				if (this.statCache) {
+					const cacheKey = createCacheKey(bucketName, this.options.prefix ?? "", path);
+					this.statCache.set(cacheKey, result);
+				}
+				return result;
+			}
+			const [files] = await this.bucket.getFiles({
+				prefix: `${key}/`,
+				maxResults: 1
+			});
+			if (files.length > 0) return {
+				id: this.generateId(`${key}/`),
+				path: ctx.path,
+				metadata: {
+					kind: "afs:node",
+					childrenCount: void 0,
+					platformRef: generatePlatformRef(bucketName, key, true)
+				}
+			};
+			const dirMarker = this.bucket.file(`${key}/`);
+			const [dirExists] = await dirMarker.exists();
+			if (dirExists) {
+				const [dirMetadata] = await dirMarker.getMetadata();
+				return {
+					id: this.generateId(`${key}/`),
+					path: ctx.path,
+					updatedAt: dirMetadata.updated ? new Date(dirMetadata.updated) : void 0,
+					metadata: {
+						kind: "afs:node",
+						childrenCount: void 0,
+						platformRef: generatePlatformRef(bucketName, key, true)
+					}
+				};
+			}
+			throw new AFSNotFoundError(path.startsWith("/") ? path : `/${path}`);
+		} catch (error) {
+			if (error instanceof AFSNotFoundError) throw error;
+			throw mapGCSError(error);
+		}
+	}
+	async statHandler(ctx) {
+		const metaEntry = await this.metaHandler({
+			...ctx,
+			path: ctx.path.endsWith("/.meta") ? ctx.path : `${ctx.path}/.meta`
+		});
+		return { data: {
+			path: ctx.path,
+			size: metaEntry.metadata?.size,
+			childrenCount: metaEntry.metadata?.childrenCount,
+			meta: metaEntry.metadata
+		} };
+	}
+	async writeHandler(ctx, payload) {
+		try {
+			const key = this.buildGCSKey(ctx.params.path);
+			const file = this.bucket.file(key);
+			let content;
+			if (typeof payload.content === "string") content = payload.content;
+			else if (Buffer.isBuffer(payload.content)) content = payload.content;
+			else if (payload.content !== void 0) content = JSON.stringify(payload.content);
+			else content = "";
+			const saveOptions = { validation: false };
+			if (payload.metadata?.mimeType || payload.metadata?.contentType) saveOptions.contentType = payload.metadata.mimeType ?? payload.metadata.contentType;
+			await file.save(content, saveOptions);
+			const [metadata] = await file.getMetadata();
+			const normalizedOutputPath = ctx.path.startsWith("/") ? ctx.path : `/${ctx.path}`;
+			this.invalidateCache(ctx.params.path);
+			return { data: {
+				id: this.generateId(key),
+				path: normalizedOutputPath,
+				content: payload.content,
+				updatedAt: metadata.updated ? new Date(metadata.updated) : /* @__PURE__ */ new Date(),
+				metadata: {
+					size: metadata.size ? Number(metadata.size) : 0,
+					etag: metadata.etag,
+					generation: metadata.generation,
+					...payload.metadata
+				}
+			} };
+		} catch (error) {
+			throw mapGCSError(error);
+		}
+	}
+	async deleteHandler(ctx) {
+		try {
+			const key = this.buildGCSKey(ctx.params.path);
+			const file = this.bucket.file(key);
+			const [exists] = await file.exists();
+			if (exists) {
+				await file.delete();
+				this.invalidateCache(ctx.params.path);
+				return { message: `Successfully deleted: ${ctx.params.path}` };
+			}
+			const [files] = await this.bucket.getFiles({
+				prefix: `${key}/`,
+				maxResults: 1
+			});
+			if (files.length === 0) throw new AFSNotFoundError(`/${ctx.params.path}`);
+			throw new AFSError(`Cannot delete non-empty directory: ${ctx.params.path}. Use recursive option.`, "AFS_INVALID_OPERATION");
+		} catch (error) {
+			if (error instanceof AFSError || error instanceof AFSNotFoundError) throw error;
+			throw mapGCSError(error);
+		}
+	}
+	async listActionsHandler(ctx) {
+		const basePath = ctx.path.replace(/\/\.actions$/, "");
+		return { data: [
+			{
+				id: "presign-download",
+				path: `${basePath}/.actions/presign-download`,
+				summary: "Generate signed download URL",
+				metadata: {
+					kind: "afs:executable",
+					kinds: ["afs:executable", "afs:node"]
+				}
+			},
+			{
+				id: "presign-upload",
+				path: `${basePath}/.actions/presign-upload`,
+				summary: "Generate signed upload URL",
+				metadata: {
+					kind: "afs:executable",
+					kinds: ["afs:executable", "afs:node"]
+				}
+			},
+			{
+				id: "compose",
+				path: `${basePath}/.actions/compose`,
+				summary: "Compose multiple objects into one",
+				metadata: {
+					kind: "afs:executable",
+					kinds: ["afs:executable", "afs:node"]
+				}
+			},
+			{
+				id: "rewrite",
+				path: `${basePath}/.actions/rewrite`,
+				summary: "Rewrite object to new location",
+				metadata: {
+					kind: "afs:executable",
+					kinds: ["afs:executable", "afs:node"]
+				}
+			}
+		] };
+	}
+	async signDownloadActionHandler(ctx, args) {
+		const normalizedPath = ctx.params.path.replace(/^\/+/, "").replace(/\/+$/, "");
+		const key = this.options.prefix ? `${this.options.prefix}/${normalizedPath}` : normalizedPath;
+		const file = this.bucket.file(key);
+		let expiresIn = args.expiresIn ?? DEFAULT_EXPIRES_IN;
+		if (expiresIn > MAX_EXPIRES_IN) expiresIn = MAX_EXPIRES_IN;
+		if (expiresIn < 1) expiresIn = 1;
+		const expiresAt = Date.now() + expiresIn * 1e3;
+		const [url] = await file.getSignedUrl({
+			action: "read",
+			expires: expiresAt
+		});
+		return {
+			success: true,
+			data: {
+				url,
+				expiresAt: new Date(expiresAt).toISOString()
+			}
+		};
+	}
+	async signUploadActionHandler(ctx, args) {
+		const normalizedPath = ctx.params.path.replace(/^\/+/, "").replace(/\/+$/, "");
+		const key = this.options.prefix ? `${this.options.prefix}/${normalizedPath}` : normalizedPath;
+		const file = this.bucket.file(key);
+		let expiresIn = args.expiresIn ?? DEFAULT_EXPIRES_IN;
+		if (expiresIn > MAX_EXPIRES_IN) expiresIn = MAX_EXPIRES_IN;
+		if (expiresIn < 1) expiresIn = 1;
+		const expiresAt = Date.now() + expiresIn * 1e3;
+		const contentType = args.contentType ?? "application/octet-stream";
+		const [url] = await file.getSignedUrl({
+			action: "write",
+			expires: expiresAt,
+			contentType
+		});
+		return {
+			success: true,
+			data: {
+				url,
+				expiresAt: new Date(expiresAt).toISOString()
+			}
+		};
+	}
+	async composeActionHandler(ctx, args) {
+		const normalizedPath = ctx.params.path.replace(/^\/+/, "").replace(/\/+$/, "");
+		const destinationKey = this.options.prefix ? `${this.options.prefix}/${normalizedPath}` : normalizedPath;
+		const sources = args.sources;
+		if (!sources || !Array.isArray(sources) || sources.length < 2) throw new AFSError("compose requires at least 2 source objects", "AFS_INVALID_ARGUMENT");
+		if (sources.length > MAX_COMPOSE_SOURCES) throw new AFSError(`compose supports maximum ${MAX_COMPOSE_SOURCES} sources`, "AFS_INVALID_ARGUMENT");
+		const sourceFiles = sources.map((source) => {
+			const sourcePath = source.replace(/^\/+/, "").replace(/\/+$/, "");
+			const sourceKey = this.options.prefix ? `${this.options.prefix}/${sourcePath}` : sourcePath;
+			return this.bucket.file(sourceKey);
+		});
+		const destinationFile = this.bucket.file(destinationKey);
+		await this.bucket.combine(sourceFiles, destinationFile);
+		const [metadata] = await destinationFile.getMetadata();
+		this.invalidateCache(ctx.params.path);
+		return {
+			success: true,
+			data: {
+				generation: metadata.generation,
+				size: metadata.size ? Number(metadata.size) : 0,
+				etag: metadata.etag
+			}
+		};
+	}
+	async rewriteActionHandler(ctx, args) {
+		const normalizedPath = ctx.params.path.replace(/^\/+/, "").replace(/\/+$/, "");
+		const sourceKey = this.options.prefix ? `${this.options.prefix}/${normalizedPath}` : normalizedPath;
+		const destination = args.destination;
+		if (!destination) throw new AFSError("rewrite requires destination path", "AFS_INVALID_ARGUMENT");
+		const destPath = destination.replace(/^\/+/, "").replace(/\/+$/, "");
+		const destKey = this.options.prefix ? `${this.options.prefix}/${destPath}` : destPath;
+		const sourceFile = this.bucket.file(sourceKey);
+		const destFile = this.bucket.file(destKey);
+		const copyOptions = {};
+		if (args.storageClass) copyOptions.metadata = { storageClass: args.storageClass };
+		if (args.contentType) copyOptions.contentType = args.contentType;
+		await sourceFile.copy(destFile, copyOptions);
+		const [metadata] = await destFile.getMetadata();
+		this.invalidateCache(destPath);
+		return {
+			success: true,
+			data: {
+				destination: `/${destPath}`,
+				generation: metadata.generation,
+				size: metadata.size ? Number(metadata.size) : 0,
+				etag: metadata.etag,
+				storageClass: metadata.storageClass
+			}
+		};
+	}
+	/**
+	* Generate a signed URL for downloading an object
+	* @deprecated Use action /.actions/sign-download instead
+	*/
+	async getSignedDownloadUrl(path, options) {
+		return (await this.signDownloadActionHandler({
+			path: `/${path}`,
+			params: { path },
+			options: {}
+		}, { expiresIn: options?.expiresIn })).data.url;
+	}
+	/**
+	* Generate a signed URL for uploading an object
+	* @deprecated Use action /.actions/sign-upload instead
+	*/
+	async getSignedUploadUrl(path, options) {
+		return (await this.signUploadActionHandler({
+			path: `/${path}`,
+			params: { path },
+			options: {}
+		}, {
+			expiresIn: options?.expiresIn,
+			contentType: options?.contentType
+		})).data.url;
+	}
+	/**
+	* List all versions (generations) of an object
+	* @deprecated Use list on /:path/@versions instead
+	*/
+	async listVersions(path) {
+		return (await this.listVersionsHandler({
+			path: `/${path}/@versions`,
+			params: { path },
+			options: {}
+		})).data.map((entry) => ({
+			generation: entry.metadata?.generation,
+			isLive: entry.metadata?.isLive,
+			timeCreated: entry.updatedAt,
+			size: entry.metadata?.size ?? 0,
+			etag: entry.metadata?.etag
+		}));
+	}
+	/**
+	* Read a specific version (generation) of an object
+	* @deprecated Use read on /:path/@versions/:generation instead
+	*/
+	async readVersion(path, generation) {
+		const result = await this.readVersionHandler({
+			path: `/${path}/@versions/${generation}`,
+			params: {
+				path,
+				generation
+			},
+			options: {}
+		});
+		return {
+			content: result.content,
+			metadata: result.metadata
+		};
+	}
+	/**
+	* Create a directory marker
+	* @deprecated Use write with empty content instead
+	*/
+	async mkdir(path) {
+		const key = this.buildGCSKey(path);
+		const dirKey = key.endsWith("/") ? key : `${key}/`;
+		await this.bucket.file(dirKey).save("", { contentType: "application/x-directory" });
+	}
+};
+__decorate([List("/"), List("/:path*")], AFSGCS.prototype, "listHandler", null);
+__decorate([List("/:path*/@versions")], AFSGCS.prototype, "listVersionsHandler", null);
+__decorate([Read("/:path*")], AFSGCS.prototype, "readHandler", null);
+__decorate([Read("/:path*/@versions/:generation")], AFSGCS.prototype, "readVersionHandler", null);
+__decorate([Meta("/"), Meta("/:path*")], AFSGCS.prototype, "metaHandler", null);
+__decorate([Stat("/"), Stat("/:path*")], AFSGCS.prototype, "statHandler", null);
+__decorate([Write("/:path*")], AFSGCS.prototype, "writeHandler", null);
+__decorate([Delete("/:path*")], AFSGCS.prototype, "deleteHandler", null);
+__decorate([Actions("/:path*")], AFSGCS.prototype, "listActionsHandler", null);
+__decorate([Actions.Exec("/:path*", "presign-download")], AFSGCS.prototype, "signDownloadActionHandler", null);
+__decorate([Actions.Exec("/:path*", "presign-upload")], AFSGCS.prototype, "signUploadActionHandler", null);
+__decorate([Actions.Exec("/:path*", "compose")], AFSGCS.prototype, "composeActionHandler", null);
+__decorate([Actions.Exec("/:path*", "rewrite")], AFSGCS.prototype, "rewriteActionHandler", null);
+
+//#endregion
+export { AFSGCS };
+//# sourceMappingURL=index.mjs.map