alchemy 0.3.1 → 0.4.1

package/lib/cloudflare/index.js

@@ -1,8 +1,13 @@
+export * from "./account-api-token";
+export * from "./api";
+export * from "./assets";
 export * from "./bindings";
 export * from "./bucket";
-export * from "./dns";
+export * from "./custom-domain";
+export * from "./dns-records";
 export * from "./durable-object-namespace";
 export * from "./kv-namespace";
+export * from "./permission-groups";
 export * from "./r2-rest-state-store";
 export * from "./static-site";
 export * from "./worker";

package/lib/cloudflare/permission-groups.d.ts

@@ -0,0 +1,78 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { type CloudflareApiOptions } from "./api";
+/**
+ * Cloudflare permission group as returned by the API
+ */
+export interface PermissionGroup {
+    /**
+     * Unique identifier for the permission group
+     */
+    id: string;
+    /**
+     * Human-readable name of the permission group
+     */
+    name: string;
+    /**
+     * Scopes included in this permission group
+     */
+    scopes: string[];
+}
+/**
+ * All Cloudflare permission groups mapped by name to ID
+ *
+ * @see https://developers.cloudflare.com/r2/api/tokens/#permissions
+ */
+export type PermissionGroups = Resource<"cloudflare::PermissionGroups"> & {
+    /**
+     * Admin Read & Write - Allows create, list, delete buckets and edit bucket configurations
+     * plus list, write, and read object access
+     */
+    "Workers R2 Storage Write": PermissionGroup;
+    /**
+     * Admin Read only - Allows list buckets and view bucket configuration
+     * plus list and read object access
+     */
+    "Workers R2 Storage Read": PermissionGroup;
+    /**
+     * Object Read & Write - Allows read, write, and list objects in specific buckets
+     */
+    "Workers R2 Storage Bucket Item Write": PermissionGroup;
+    /**
+     * Object Read only - Allows read and list objects in specific buckets
+     */
+    "Workers R2 Storage Bucket Item Read": PermissionGroup;
+    /**
+     * Dynamically discovered permission groups
+     */
+    [name: string]: PermissionGroup;
+};
+/**
+ * Lists all permission groups available for the Cloudflare account
+ * and returns a typed map of permission names to their IDs.
+ *
+ * This is primarily used when creating API tokens for Cloudflare services like R2.
+ *
+ * @example
+ * // Get all permission groups including those for R2
+ * const permissions = await PermissionGroups("cloudflare-permissions");
+ *
+ * // Use with AccountApiToken to create a token with proper permissions
+ * const token = await AccountApiToken("r2-token", {
+ *   name: "R2 Read-Only Token",
+ *   policies: [
+ *     {
+ *       effect: "allow",
+ *       resources: {
+ *         "com.cloudflare.edge.r2.bucket.abc123_default_my-bucket": "*"
+ *       },
+ *       permissionGroups: [
+ *         {
+ *           id: permissions["Workers R2 Storage Bucket Item Read"]
+ *         }
+ *       ]
+ *     }
+ *   ]
+ * });
+ */
+export declare const PermissionGroups: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<PermissionGroups>, id: string, options?: CloudflareApiOptions) => Promise<PermissionGroups>);

package/lib/cloudflare/permission-groups.js

@@ -0,0 +1,48 @@
+import { Resource } from "../resource";
+import { createCloudflareApi } from "./api";
+/**
+ * Lists all permission groups available for the Cloudflare account
+ * and returns a typed map of permission names to their IDs.
+ *
+ * This is primarily used when creating API tokens for Cloudflare services like R2.
+ *
+ * @example
+ * // Get all permission groups including those for R2
+ * const permissions = await PermissionGroups("cloudflare-permissions");
+ *
+ * // Use with AccountApiToken to create a token with proper permissions
+ * const token = await AccountApiToken("r2-token", {
+ *   name: "R2 Read-Only Token",
+ *   policies: [
+ *     {
+ *       effect: "allow",
+ *       resources: {
+ *         "com.cloudflare.edge.r2.bucket.abc123_default_my-bucket": "*"
+ *       },
+ *       permissionGroups: [
+ *         {
+ *           id: permissions["Workers R2 Storage Bucket Item Read"]
+ *         }
+ *       ]
+ *     }
+ *   ]
+ * });
+ */
+export const PermissionGroups = Resource("cloudflare::PermissionGroups", async function (id, options) {
+    // Only create and update phases are supported
+    if (this.phase === "delete") {
+        return this.destroy();
+    }
+    // Initialize API client
+    const api = await createCloudflareApi(options);
+    // Fetch permission groups from Cloudflare API
+    const response = await api.get(`/accounts/${api.accountId}/tokens/permission_groups`);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch permission groups: ${response.statusText}`);
+    }
+    const data = (await response.json());
+    if (!data.success || !data.result) {
+        throw new Error(`API returned error: ${data.errors?.[0]?.message || "Unknown error"}`);
+    }
+    return this(Object.fromEntries(data.result.map((group) => [group.name, group])));
+});

package/lib/cloudflare/r2-rest-state-store.d.ts

@@ -1,4 +1,5 @@
 import type { Scope } from "../scope";
+import type { Secret } from "../secret";
 import type { State, StateStore } from "../state";
 /**
  * Options for CloudflareR2StateStore
@@ -17,7 +18,7 @@ export interface CloudflareR2StateStoreOptions {
     /**
      * API key to use (overrides CLOUDFLARE_API_KEY env var)
      */
-    apiKey?: string;
+    apiKey?: Secret;
     /**
      * Account ID to use (overrides CLOUDFLARE_ACCOUNT_ID env var)
      */

package/lib/cloudflare/r2-rest-state-store.js

@@ -1,5 +1,5 @@
+import { deserialize, serialize } from "../serde";
 import { withExponentialBackoff } from "../util/retry";
-import { deserialize, serialize } from "../util/serde";
 import { createCloudflareApi } from "./api";
 /**
  * State store implementation using Cloudflare R2 API
@@ -74,13 +74,22 @@ export class R2RestStateStore {
                 params.append("cursor", cursor);
             }
             const listPath = `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects?${params.toString()}`;
-            const response = await this.api.get(listPath);
-            if (!response.ok) {
-                const errorData = await response.json().catch(() => ({
-                    errors: [{ message: response.statusText }],
-                }));
-                throw new Error(`Error listing R2 objects: ${errorData.errors?.[0]?.message || response.statusText}`);
-            }
+            const response = await withExponentialBackoff(async () => {
+                const response = await this.api.get(listPath);
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({
+                        errors: [{ message: response.statusText }],
+                    }));
+                    throw new Error(`Error listing R2 objects: ${errorData.errors?.[0]?.message || response.statusText}`);
+                }
+                return response;
+            }, 
+            // Retry on transient errors
+            (error) => error.message?.includes("502") ||
+                error.message?.includes("503") ||
+                error.message?.includes("timeout"), 5, // 5 retry attempts
+            1000 // Start with 1 second delay
+            );
             const data = (await response.json());
             // The result structure may be under "result" key in Cloudflare's API
             const result = data.result || data;
@@ -114,15 +123,27 @@ export class R2RestStateStore {
     async get(key) {
         await this.ensureInitialized();
         try {
-            const response = await this.api.get(`/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`);
-            if (!response.ok) {
-                if (response.status === 404) {
-                    return undefined;
+            const response = await withExponentialBackoff(async () => {
+                const response = await this.api.get(`/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`);
+                if (!response.ok) {
+                    if (response.status === 404) {
+                        return response;
+                    }
+                    const errorData = await response.json().catch(() => ({
+                        errors: [{ message: response.statusText }],
+                    }));
+                    throw new Error(`Error getting R2 object: ${errorData.errors?.[0]?.message || response.statusText}`);
                 }
-                const errorData = await response.json().catch(() => ({
-                    errors: [{ message: response.statusText }],
-                }));
-                throw new Error(`Error getting R2 object: ${errorData.errors?.[0]?.message || response.statusText}`);
+                return response;
+            }, 
+            // Retry on transient errors
+            (error) => error.message?.includes("502") ||
+                error.message?.includes("503") ||
+                error.message?.includes("timeout"), 5, // 5 retry attempts
+            1000 // Start with 1 second delay
+            );
+            if (response.status === 404) {
+                return undefined;
             }
             // Parse and deserialize the state data
             const rawData = await response.json();
@@ -198,7 +219,8 @@ export class R2RestStateStore {
         }, 
         // Retry on transient errors
         (error) => error.message?.includes("503") || error.message?.includes("timeout"), 5, // 5 retry attempts
-        1000);
+        1000 // Start with 1 second delay
+        );
     }
     /**
      * Delete a state by key
@@ -207,13 +229,22 @@ export class R2RestStateStore {
      */
     async delete(key) {
         await this.ensureInitialized();
-        const response = await this.api.delete(`/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`);
-        if (!response.ok && response.status !== 404) {
-            const errorData = await response.json().catch(() => ({
-                errors: [{ message: response.statusText }],
-            }));
-            throw new Error(`Error deleting from R2: ${errorData.errors?.[0]?.message || response.statusText}`);
-        }
+        await withExponentialBackoff(async () => {
+            const response = await this.api.delete(`/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`);
+            if (!response.ok && response.status !== 404) {
+                const errorData = await response.json().catch(() => ({
+                    errors: [{ message: response.statusText }],
+                }));
+                throw new Error(`Error deleting from R2: ${errorData.errors?.[0]?.message || response.statusText}`);
+            }
+            return response;
+        }, 
+        // Retry on transient errors
+        (error) => error.message?.includes("502") ||
+            error.message?.includes("503") ||
+            error.message?.includes("timeout"), 5, // 5 retry attempts
+        1000 // Start with 1 second delay
+        );
     }
     /**
      * Convert key for storage by replacing slashes with colons

package/lib/cloudflare/static-site.d.ts

@@ -72,13 +72,6 @@ export interface StaticSiteProps {
      * @default true
      */
     production?: boolean;
-    /**
-     * Custom domain for the site
-     */
-    domain?: string | {
-        name: string;
-        redirects?: string[];
-    };
     build?: {
         /**
          * Command to run before deploying the site
@@ -137,13 +130,6 @@ export interface StaticSite extends Resource<"cloudflare::StaticSite"> {
      * List of uploaded asset files
      */
     assets: string[];
-    /**
-     * Custom domain for the site
-     */
-    domain?: string | {
-        name: string;
-        redirects?: string[];
-    };
     /**
      * Whether the site is deployed to production
      */
@@ -198,13 +184,26 @@ export interface StaticSite extends Resource<"cloudflare::StaticSite"> {
  * });
  *
  * @example
- * // Create a static site with custom error page and index
- * const customSite = await StaticSite("custom-site", {
+ * // Create a static site with a custom domain using the CustomDomain resource
+ * const site = await StaticSite("custom-site", {
  *   name: "custom-site",
  *   dir: "./www",
  *   errorPage: "404.html",
- *   indexPage: "home.html",
- *   domain: "www.example.com"
+ *   indexPage: "home.html"
+ * });
+ *
+ * // Then configure the custom domain separately
+ * const domain = await CustomDomain("custom-domain", {
+ *   name: "www.example.com",
+ *   zoneId: "abcdef123456789",
+ *   workerName: site.name
+ * });
+ *
+ * @example
+ * // Create a static site with multiple domains (primary + redirects)
+ * const site = await StaticSite("multi-domain-site", {
+ *   name: "multi-domain-site",
+ *   dir: "./public"
  * });
  *
  * @see https://developers.cloudflare.com/workers/platform/sites

package/lib/cloudflare/static-site.js

@@ -50,13 +50,26 @@ const __dirname = import.meta.dirname;
  * });
  *
  * @example
- * // Create a static site with custom error page and index
- * const customSite = await StaticSite("custom-site", {
+ * // Create a static site with a custom domain using the CustomDomain resource
+ * const site = await StaticSite("custom-site", {
  *   name: "custom-site",
  *   dir: "./www",
  *   errorPage: "404.html",
- *   indexPage: "home.html",
- *   domain: "www.example.com"
+ *   indexPage: "home.html"
+ * });
+ *
+ * // Then configure the custom domain separately
+ * const domain = await CustomDomain("custom-domain", {
+ *   name: "www.example.com",
+ *   zoneId: "abcdef123456789",
+ *   workerName: site.name
+ * });
+ *
+ * @example
+ * // Create a static site with multiple domains (primary + redirects)
+ * const site = await StaticSite("multi-domain-site", {
+ *   name: "multi-domain-site",
+ *   dir: "./public"
  * });
  *
  * @see https://developers.cloudflare.com/workers/platform/sites
@@ -64,6 +77,8 @@ const __dirname = import.meta.dirname;
 export const StaticSite = Resource("cloudflare::StaticSite", {
     alwaysUpdate: true,
 }, async function (id, props) {
+    // Create Cloudflare API client with automatic account discovery
+    const api = await createCloudflareApi();
     if (this.phase === "delete") {
         // For delete operations, we'll rely on the Worker delete to clean up
         // Return empty output for deleted state
@@ -113,8 +128,6 @@ export const StaticSite = Resource("cloudflare::StaticSite", {
     // Use the provided name
     const siteName = props.name;
     const indexPage = props.indexPage || "index.html";
-    // Create Cloudflare API client with automatic account discovery
-    const api = await createCloudflareApi();
     // Step 1: Create or get the KV namespace for assets
     const [kv, assetManifest] = await Promise.all([
         KVNamespace("assets", {
@@ -122,9 +135,6 @@ export const StaticSite = Resource("cloudflare::StaticSite", {
         }),
         generateAssetManifest(props.dir),
     ]);
-    console.log({
-        assetManifest,
-    });
     // Step 3: Upload assets to KV
     await uploadAssetManifest(api, kv.namespaceId, assetManifest);
     // Prepare the bindings for the worker
@@ -196,7 +206,6 @@ export const StaticSite = Resource("cloudflare::StaticSite", {
         assets: assetManifest.map((item) => item.key),
         createdAt: this.output?.createdAt || now,
         updatedAt: now,
-        domain: props.domain,
         production: props.production !== false,
         url: worker.url,
         routes,

package/lib/cloudflare/worker.d.ts

@@ -166,6 +166,20 @@ export interface Worker<B extends Bindings = Bindings> extends Resource<"cloudfl
  *   }
  * });
  *
+ * @example
+ * // Create a worker with static assets:
+ * const staticAssets = await Assets("static", {
+ *   path: "./src/assets"
+ * });
+ *
+ * const frontendWorker = await Worker("frontend", {
+ *   name: "frontend-worker",
+ *   entrypoint: "./src/worker.ts",
+ *   bindings: {
+ *     ASSETS: staticAssets
+ *   }
+ * });
+ *
  * @see https://developers.cloudflare.com/workers/
  */
 export declare const Worker: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | (<const B extends Bindings>(this: Context<Worker<NoInfer<B>>>, id: string, props: WorkerProps<B>) => Promise<Worker<B>>);

package/lib/cloudflare/worker.js

@@ -1,11 +1,13 @@
+import * as crypto from "crypto";
 import * as fs from "fs/promises";
 import { Bundle } from "../esbuild/bundle";
 import { Resource } from "../resource";
 import { isSecret } from "../secret";
+import { getContentType } from "../util/content-type";
 import { withExponentialBackoff } from "../util/retry";
 import { slugify } from "../util/slugify";
 import { createCloudflareApi } from "./api";
-import { isDurableObjectNamespace, } from "./bindings";
+import { isAssets, isDurableObjectNamespace, } from "./bindings";
 import { isKVNamespace } from "./kv-namespace";
 /**
  * A Cloudflare Worker is a serverless function that can be deployed to the Cloudflare network.
@@ -68,6 +70,20 @@ import { isKVNamespace } from "./kv-namespace";
  *   }
  * });
  *
+ * @example
+ * // Create a worker with static assets:
+ * const staticAssets = await Assets("static", {
+ *   path: "./src/assets"
+ * });
+ *
+ * const frontendWorker = await Worker("frontend", {
+ *   name: "frontend-worker",
+ *   entrypoint: "./src/worker.ts",
+ *   bindings: {
+ *     ASSETS: staticAssets
+ *   }
+ * });
+ *
  * @see https://developers.cloudflare.com/workers/
  */
 export const Worker = Resource("cloudflare::Worker", {
@@ -89,9 +105,28 @@ export const Worker = Resource("cloudflare::Worker", {
         await assertWorkerDoesNotExist(this, api, workerName);
     }
     const oldBindings = await this.get("bindings");
-    const scriptMetadata = await prepareWorkerMetadata(this, oldBindings, props);
     // Get the script content - either from props.script, or by bundling
     const scriptContent = props.script ?? (await bundleWorkerScript(props));
+    // Find any assets bindings
+    const assetsBindings = [];
+    if (props.bindings) {
+        for (const [bindingName, binding] of Object.entries(props.bindings)) {
+            if (isAssets(binding)) {
+                assetsBindings.push({ name: bindingName, assets: binding });
+            }
+        }
+    }
+    // Upload any assets and get completion tokens
+    let assetUploadResult;
+    if (assetsBindings.length > 0) {
+        // We'll use the first asset binding for now
+        // In the future, we might want to support multiple asset bindings
+        const assetBinding = assetsBindings[0];
+        // Upload the assets and get the completion token
+        assetUploadResult = await uploadAssets(api, workerName, assetBinding.assets);
+    }
+    // Prepare metadata with bindings
+    const scriptMetadata = await prepareWorkerMetadata(this, oldBindings, props, assetUploadResult);
     // Upload the worker script
     await putWorker(api, workerName, scriptContent, scriptMetadata);
     // TODO: it is less than ideal that this can fail, resulting in state problem
@@ -206,7 +241,7 @@ class NotFoundError extends Error {
         this.name = "NotFoundError";
     }
 }
-async function prepareWorkerMetadata(ctx, oldBindings, props) {
+async function prepareWorkerMetadata(ctx, oldBindings, props, assetUploadResult) {
     // Prepare metadata with bindings
     const meta = {
         bindings: [],
@@ -223,6 +258,15 @@ async function prepareWorkerMetadata(ctx, oldBindings, props) {
             new_sqlite_classes: props.migrations?.new_sqlite_classes ?? [],
         },
     };
+    // If we have asset upload results, add them to the metadata
+    if (assetUploadResult) {
+        meta.assets = {
+            jwt: assetUploadResult.completionToken,
+        };
+        if (assetUploadResult.assetConfig) {
+            meta.assets.config = assetUploadResult.assetConfig;
+        }
+    }
     const bindings = (props.bindings ?? {});
     // Convert bindings to the format expected by the API
     for (const [bindingName, binding] of Object.entries(bindings)) {
@@ -284,6 +328,12 @@ async function prepareWorkerMetadata(ctx, oldBindings, props) {
                 bucket_name: binding.name,
             });
         }
+        else if (isAssets(binding)) {
+            meta.bindings.push({
+                type: "assets",
+                name: bindingName,
+            });
+        }
         else if (isSecret(binding)) {
             meta.bindings.push({
                 type: "secret_text",
@@ -468,3 +518,100 @@ async function getWorkerBindings(api, workerName, environment = "production") {
     const data = await response.json();
     return data.result;
 }
+/**
+ * Uploads assets to Cloudflare and returns a completion token
+ *
+ * @param api CloudflareApi instance
+ * @param workerName Name of the worker
+ * @param assets Assets resource containing files to upload
+ * @returns Completion token for the assets upload
+ */
+async function uploadAssets(api, workerName, assets) {
+    // Generate the file manifest
+    const fileMetadata = {};
+    // Process each file in the assets
+    for (const file of assets.files) {
+        const { hash, size } = await calculateFileMetadata(file.filePath);
+        // Use the relative path as the key, ensuring it starts with a slash
+        const key = file.path.startsWith("/") ? file.path : `/${file.path}`;
+        fileMetadata[key] = { hash, size };
+    }
+    // Start the upload session
+    const uploadSessionUrl = `/accounts/${api.accountId}/workers/scripts/${workerName}/assets-upload-session`;
+    const uploadSessionResponse = await api.post(uploadSessionUrl, JSON.stringify({ manifest: fileMetadata }), {
+        headers: { "Content-Type": "application/json" },
+    });
+    if (!uploadSessionResponse.ok) {
+        throw new Error(`Failed to start assets upload session: ${uploadSessionResponse.status} ${uploadSessionResponse.statusText}`);
+    }
+    const sessionData = (await uploadSessionResponse.json());
+    // If there are no buckets, assets are already uploaded or empty
+    if (!sessionData.result.buckets || sessionData.result.buckets.length === 0) {
+        return { completionToken: sessionData.result.jwt };
+    }
+    // Upload the files in batches as specified by the API
+    let completionToken = sessionData.result.jwt;
+    const buckets = sessionData.result.buckets;
+    // Process each bucket of files
+    for (const bucket of buckets) {
+        const formData = new FormData();
+        // Add each file in the bucket to the form
+        for (const fileHash of bucket) {
+            // Find the file with this hash
+            const file = assets.files.find((f) => {
+                const filePath = f.path.startsWith("/") ? f.path : `/${f.path}`;
+                return fileMetadata[filePath]?.hash === fileHash;
+            });
+            if (!file) {
+                throw new Error(`Could not find file with hash ${fileHash}`);
+            }
+            // Read the file content
+            const fileContent = await fs.readFile(file.filePath);
+            // Convert to base64 as required by the API when using base64=true
+            const base64Content = fileContent.toString("base64");
+            // Add the file to the form with the hash as the key and set the correct content type
+            const blob = new Blob([base64Content], {
+                type: getContentType(file.filePath),
+            });
+            formData.append(fileHash, blob, fileHash);
+        }
+        // Upload this batch of files
+        const uploadResponse = await api.post(`/accounts/${api.accountId}/workers/assets/upload?base64=true`, formData, {
+            headers: {
+                Authorization: `Bearer ${completionToken}`,
+                "Content-Type": "multipart/form-data",
+            },
+        });
+        if (!uploadResponse.ok) {
+            throw new Error(`Failed to upload asset files: ${uploadResponse.status} ${uploadResponse.statusText}`);
+        }
+        const uploadData = (await uploadResponse.json());
+        // Update the completion token for the next batch
+        if (uploadData.result.jwt) {
+            completionToken = uploadData.result.jwt;
+        }
+    }
+    // Return the final completion token
+    return {
+        completionToken,
+        assetConfig: {
+            html_handling: "auto-trailing-slash",
+        },
+    };
+}
+/**
+ * Calculate the SHA-256 hash and size of a file
+ *
+ * @param filePath Path to the file
+ * @returns Hash (first 32 chars of SHA-256) and size of the file
+ */
+async function calculateFileMetadata(filePath) {
+    const hash = crypto.createHash("sha256");
+    const fileContent = await fs.readFile(filePath);
+    hash.update(fileContent);
+    const fileHash = hash.digest("hex").substring(0, 32); // First 32 chars of hash
+    return {
+        hash: fileHash,
+        size: fileContent.length,
+    };
+}

package/lib/{util/encrypt.d.ts → encrypt.d.ts}

@@ -5,7 +5,7 @@
  * @param key - The encryption key
  * @returns The base64-encoded encrypted value with nonce
  */
-export declare function encryptWithKey(value: string, key: string): Promise<string>;
+export declare function encrypt(value: string, key: string): Promise<string>;
 /**
  * Decrypt a value encrypted with a symmetric key
  *

package/lib/{util/encrypt.js → encrypt.js}

@@ -6,7 +6,7 @@ import sodium from "libsodium-wrappers";
  * @param key - The encryption key
  * @returns The base64-encoded encrypted value with nonce
  */
-export async function encryptWithKey(value, key) {
+export async function encrypt(value, key) {
     // Initialize libsodium
     await sodium.ready;
     // Derive a key from the passphrase

package/lib/fs/file-system-state-store.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { deserialize, serialize } from "../serde";
 import { ignore } from "../util/ignore";
-import { deserialize, serialize } from "../util/serde";
 const stateRootDir = path.join(process.cwd(), ".alchemy");
 export class FileSystemStateStore {
     scope;