@sst-community/sst 4.20.0 → 5.0.0-alpha.1

package/platform/js/components/cloudflare/index.js

@@ -0,0 +1,3246 @@
+import {
+  URL_UNAVAILABLE,
+  buildApp,
+  buildApp2,
+  getContentType,
+  isALteB,
+  prepare,
+  toMilliseconds,
+  toSeconds
+} from "../../chunks/chunk-ONNI4XNK.js";
+import {
+  rpc
+} from "../../chunks/chunk-VIFHC73J.js";
+import {
+  Link
+} from "../../chunks/chunk-HIZZCEDS.js";
+import {
+  Component,
+  VisibleError,
+  logicalName,
+  prefixName,
+  transform
+} from "../../chunks/chunk-KOKHGKJ2.js";
+import {
+  __export
+} from "../../chunks/chunk-WJ6BVA46.js";
+
+// platform/src/components/cloudflare/bucket.ts
+import * as cloudflare from "@pulumi/cloudflare";
+
+// platform/src/components/cloudflare/binding.ts
+function binding(input) {
+  return {
+    type: "cloudflare.binding",
+    binding: input.type,
+    properties: input.properties
+  };
+}
+
+// platform/src/components/cloudflare/account-id.ts
+var DEFAULT_ACCOUNT_ID = process.env.CLOUDFLARE_DEFAULT_ACCOUNT_ID;
+
+// platform/src/components/cloudflare/bucket.ts
+var Bucket = class extends Component {
+  bucket;
+  constructor(name, args, opts) {
+    super(__pulumiType, name, args, opts);
+    const parent = this;
+    const bucket = createBucket();
+    this.bucket = bucket;
+    function createBucket() {
+      return new cloudflare.R2Bucket(
+        ...transform(
+          args?.transform?.bucket,
+          `${name}Bucket`,
+          {
+            name: "",
+            accountId: args?.accountId ?? DEFAULT_ACCOUNT_ID
+          },
+          { parent }
+        )
+      );
+    }
+  }
+  /**
+   * When you link a bucket to a worker, you can interact with it using these
+   * [Bucket methods](https://developers.cloudflare.com/r2/api/workers/workers-api-reference/#bucket-method-definitions).
+   *
+   * @example
+   * ```ts title="index.ts" {3}
+   * import { Resource } from "sst";
+   *
+   * await Resource.MyBucket.list();
+   * ```
+   *
+   * @internal
+   */
+  getSSTLink() {
+    return {
+      properties: {
+        name: this.bucket.name
+      },
+      include: [
+        binding({
+          type: "r2BucketBindings",
+          properties: {
+            bucketName: this.bucket.name
+          }
+        })
+      ]
+    };
+  }
+  /**
+   * The generated name of the R2 Bucket.
+   */
+  get name() {
+    return this.bucket.name;
+  }
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  get nodes() {
+    return {
+      /**
+       * The Cloudflare R2 Bucket.
+       */
+      bucket: this.bucket
+    };
+  }
+};
+var __pulumiType = "sst:cloudflare:Bucket";
+Bucket.__pulumiType = __pulumiType;
+
+// platform/src/components/cloudflare/kv.ts
+import * as cloudflare2 from "@pulumi/cloudflare";
+var Kv = class _Kv extends Component {
+  namespace;
+  constructor(name, args, opts) {
+    super(__pulumiType2, name, args, opts);
+    const parent = this;
+    if (args && "ref" in args) {
+      const ref = args;
+      this.namespace = ref.namespace;
+      return;
+    }
+    const namespace = createNamespace();
+    this.namespace = namespace;
+    function createNamespace() {
+      return new cloudflare2.WorkersKvNamespace(
+        ...transform(
+          args?.transform?.namespace,
+          `${name}Namespace`,
+          {
+            title: "",
+            accountId: args?.accountId ?? DEFAULT_ACCOUNT_ID
+          },
+          { parent }
+        )
+      );
+    }
+  }
+  /**
+   * Reference an existing KV namespace with the given name. This is useful when you
+   * create a KV namespace in one stage and want to share it in another.
+   *
+   * :::tip
+   * You can use the `static get` method to share KV namespaces across stages.
+   * :::
+   *
+   * @param name The name of the component.
+   * @param args The arguments to get the KV namespace.
+   * @param opts Resource options.
+   *
+   * @example
+   * Imagine you create a KV namespace in the `dev` stage. And in your personal stage `frank`,
+   * instead of creating a new namespace, you want to share the same one from `dev`.
+   *
+   * ```ts title="sst.config.ts"
+   * const storage = $app.stage === "frank"
+   *   ? sst.cloudflare.Kv.get("MyStorage", {
+   *       namespaceId: "a1b2c3d4e5f6",
+   *     })
+   *   : new sst.cloudflare.Kv("MyStorage");
+   * ```
+   */
+  static get(name, args, opts) {
+    const namespace = cloudflare2.WorkersKvNamespace.get(
+      `${name}Namespace`,
+      `${args.accountId ?? DEFAULT_ACCOUNT_ID}/${args.namespaceId}`,
+      void 0,
+      opts
+    );
+    return new _Kv(
+      name,
+      {
+        ref: true,
+        namespace
+      },
+      opts
+    );
+  }
+  /**
+   * When you link a KV storage, the storage will be available to the worker and you can
+   * interact with it using its [API methods](https://developers.cloudflare.com/kv/api/).
+   *
+   * @example
+   * ```ts title="index.ts" {3}
+   * import { Resource } from "sst";
+   *
+   * await Resource.MyStorage.get("someKey");
+   * ```
+   *
+   * @internal
+   */
+  getSSTLink() {
+    return {
+      properties: {
+        namespaceId: this.namespaceId
+      },
+      include: [
+        binding({
+          type: "kvNamespaceBindings",
+          properties: {
+            namespaceId: this.namespaceId
+          }
+        })
+      ]
+    };
+  }
+  /**
+   * The generated ID of the KV namespace.
+   * @deprecated Use `namespaceId` instead.
+   */
+  get id() {
+    return this.namespaceId;
+  }
+  /**
+   * The generated ID of the KV namespace.
+   */
+  get namespaceId() {
+    return this.namespace.id.apply(
+      (id) => id.includes("/") ? id.split("/")[1] : id
+    );
+  }
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  get nodes() {
+    return {
+      /**
+       * The Cloudflare KV namespace.
+       */
+      namespace: this.namespace
+    };
+  }
+};
+var __pulumiType2 = "sst:cloudflare:Kv";
+Kv.__pulumiType = __pulumiType2;
+
+// platform/src/components/cloudflare/d1.ts
+import * as cloudflare3 from "@pulumi/cloudflare";
+var D1 = class _D1 extends Component {
+  database;
+  constructor(name, args, opts) {
+    super(__pulumiType3, name, args, opts);
+    if (args && "ref" in args) {
+      const ref = args;
+      this.database = ref.database;
+      return;
+    }
+    const parent = this;
+    const db = createDB();
+    this.database = db;
+    function createDB() {
+      return new cloudflare3.D1Database(
+        ...transform(
+          args?.transform?.database,
+          `${name}Database`,
+          {
+            name: "",
+            accountId: args?.accountId ?? DEFAULT_ACCOUNT_ID
+          },
+          { parent }
+        )
+      );
+    }
+  }
+  /**
+   * When you link a D1 database, the database will be available to the worker and you can
+   * query it using its [API methods](https://developers.cloudflare.com/d1/build-with-d1/d1-client-api/).
+   *
+   * @example
+   * ```ts title="index.ts" {1} "Resource.MyDatabase.prepare"
+   * import { Resource } from "sst";
+   *
+   * await Resource.MyDatabase.prepare(
+   *   "SELECT id FROM todo ORDER BY id DESC LIMIT 1",
+   * ).first();
+   * ```
+   *
+   * @internal
+   */
+  getSSTLink() {
+    return {
+      properties: {
+        databaseId: this.databaseId
+      },
+      include: [
+        binding({
+          type: "d1DatabaseBindings",
+          properties: {
+            id: this.databaseId
+          }
+        })
+      ]
+    };
+  }
+  /**
+   * The generated ID of the D1 database.
+   */
+  get databaseId() {
+    return this.database.id.apply(
+      (id) => id.includes("/") ? id.split("/")[1] : id
+    );
+  }
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  get nodes() {
+    return {
+      /**
+       * The Cloudflare D1 database.
+       */
+      database: this.database
+    };
+  }
+  static get(name, argsOrDatabaseId, opts) {
+    if (typeof argsOrDatabaseId === "string") {
+      const database2 = cloudflare3.D1Database.get(
+        `${name}Database`,
+        `${DEFAULT_ACCOUNT_ID}/${argsOrDatabaseId}`,
+        void 0,
+        opts
+      );
+      return new _D1(name, {
+        ref: true,
+        database: database2
+      });
+    }
+    const database = cloudflare3.D1Database.get(
+      `${name}Database`,
+      `${argsOrDatabaseId.accountId ?? DEFAULT_ACCOUNT_ID}/${argsOrDatabaseId.databaseId}`,
+      void 0,
+      opts
+    );
+    return new _D1(name, {
+      ref: true,
+      database
+    });
+  }
+};
+var __pulumiType3 = "sst:cloudflare:D1";
+D1.__pulumiType = __pulumiType3;
+
+// platform/src/components/cloudflare/dns.ts
+import * as cloudflare4 from "@pulumi/cloudflare";
+
+// platform/src/components/cloudflare/providers/zone-lookup.ts
+import { dynamic } from "@pulumi/pulumi";
+
+// platform/src/components/cloudflare/helpers/fetch.ts
+var CLOUDFLARE_API_BASE_URL = process.env.CLOUDFLARE_API_BASE_URL ?? "https://api.cloudflare.com/client/v4";
+var apiToken = () => $app.providers?.cloudflare?.apiToken || process.env.CLOUDFLARE_API_TOKEN;
+async function cfFetch(resource, init = {}) {
+  const maxRetries = 3;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const ret = await fetch(`${CLOUDFLARE_API_BASE_URL}${resource}`, {
+        ...init,
+        headers: {
+          Authorization: `Bearer ${apiToken()}`,
+          ...init.headers
+        }
+      });
+      const json = await ret.json();
+      if (json.success) {
+        return json;
+      }
+      lastError = new Error(
+        `A request to the Cloudflare API (${resource}) failed.`
+      );
+      lastError.errors = json.errors;
+      lastError.messages = json.messages;
+    } catch (error) {
+      lastError = error;
+    }
+    if (attempt < maxRetries) {
+      await new Promise(
+        (resolve) => setTimeout(resolve, Math.pow(2, attempt) * 200)
+      );
+    }
+  }
+  throw lastError;
+}
+
+// platform/src/components/cloudflare/providers/zone-lookup.ts
+var Provider = class {
+  async create(inputs) {
+    const { zoneId, zoneName } = await this.lookup(inputs);
+    return { id: zoneId, outs: { zoneId, zoneName } };
+  }
+  async update(id, olds, news) {
+    const { zoneId, zoneName } = await this.lookup(news);
+    return { outs: { zoneId, zoneName } };
+  }
+  async lookup(inputs, page = 1) {
+    try {
+      const qs = new URLSearchParams({
+        per_page: "50",
+        page: String(page),
+        "account.id": inputs.accountId
+      }).toString();
+      const ret = await cfFetch(
+        `/zones?${qs}`,
+        { headers: { "Content-Type": "application/json" } }
+      );
+      const zone = ret.result.find(
+        // ensure `example.com` does not match `myexample.com`
+        (z) => inputs.domain === z.name || inputs.domain.endsWith(`.${z.name}`)
+      );
+      if (zone) return { zoneId: zone.id, zoneName: zone.name };
+      if (ret.result.length < ret.result_info.per_page)
+        throw new Error(
+          `Could not find hosted zone for domain ${inputs.domain}`
+        );
+      return this.lookup(inputs, page + 1);
+    } catch (error) {
+      console.log(error);
+      throw error;
+    }
+  }
+};
+var ZoneLookup = class extends dynamic.Resource {
+  constructor(name, args, opts) {
+    super(
+      new Provider(),
+      `${name}.sst.cloudflare.ZoneLookup`,
+      { ...args, zoneId: void 0, zoneName: void 0 },
+      opts
+    );
+  }
+};
+
+// platform/src/components/cloudflare/dns.ts
+import { output } from "@pulumi/pulumi";
+
+// platform/src/components/cloudflare/providers/dns-record.ts
+import { dynamic as dynamic2 } from "@pulumi/pulumi";
+var DnsRecord = class extends dynamic2.Resource {
+  constructor(name, args, opts) {
+    super(
+      new rpc.Provider("Cloudflare.DnsRecord"),
+      `${name}.sst.cloudflare.DnsRecord`,
+      {
+        ...args,
+        recordId: void 0,
+        accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+        apiToken: $app.providers?.cloudflare?.apiToken || process.env.CLOUDFLARE_API_TOKEN
+      },
+      opts
+    );
+  }
+};
+
+// platform/src/components/cloudflare/dns.ts
+function dns(args = {}) {
+  return {
+    provider: "cloudflare",
+    createAlias,
+    createCaa,
+    createRecord
+  };
+  function lookupZone(namePrefix, recordType, recordName, opts) {
+    if (args.zone) {
+      const zone2 = cloudflare4.getZoneOutput({
+        zoneId: args.zone
+      });
+      return {
+        id: output(args.zone),
+        name: zone2.name
+      };
+    }
+    const zone = new ZoneLookup(
+      `${namePrefix}${recordType}${recordName}ZoneLookup`,
+      {
+        accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+        domain: recordName.replace(/\.$/, "")
+      },
+      opts
+    );
+    return {
+      id: zone.zoneId,
+      name: zone.zoneName
+    };
+  }
+  function createAlias(namePrefix, record, opts) {
+    return handleCreate(
+      namePrefix,
+      {
+        name: record.name,
+        type: "CNAME",
+        value: record.aliasName,
+        isAlias: true
+      },
+      opts
+    );
+  }
+  function createCaa(namePrefix, recordName, opts) {
+    const zone = lookupZone(namePrefix, "CAA", recordName, opts);
+    return [
+      new DnsRecord(
+        `${namePrefix}CAA${recordName}Record`,
+        {
+          zoneId: zone.id,
+          type: "CAA",
+          name: zone.name,
+          accountId: args.accountId,
+          data: {
+            flags: "0",
+            tag: "issue",
+            value: "amazonaws.com"
+          }
+        },
+        opts
+      ),
+      new DnsRecord(
+        `${namePrefix}CAAWildcard${recordName}Record`,
+        {
+          zoneId: zone.id,
+          type: "CAA",
+          name: zone.name,
+          accountId: args.accountId,
+          data: {
+            flags: "0",
+            tag: "issuewild",
+            value: "amazonaws.com"
+          }
+        },
+        opts
+      )
+    ];
+  }
+  function createRecord(namePrefix, record, opts) {
+    return handleCreate(namePrefix, record, opts);
+  }
+  function handleCreate(namePrefix, record, opts) {
+    return output(record).apply((record2) => {
+      const zone = lookupZone(namePrefix, record2.type, record2.name, opts);
+      const proxy = output(args.proxy).apply(
+        (proxy2) => (proxy2 && record2.isAlias) ?? false
+      );
+      const nameSuffix = logicalName(record2.name);
+      const type = record2.type.toUpperCase();
+      return new cloudflare4.DnsRecord(
+        ...transform(
+          args.transform?.record,
+          `${namePrefix}${record2.type}Record${nameSuffix}`,
+          {
+            zoneId: zone.id,
+            proxied: output(proxy),
+            type,
+            name: record2.name,
+            ...type === "TXT" ? {
+              content: record2.value.startsWith(`"`) ? record2.value : `"${record2.value}"`
+            } : {
+              content: record2.value
+            },
+            ...record2.priority !== void 0 ? { priority: record2.priority } : {},
+            ttl: output(proxy).apply((proxy2) => proxy2 ? 1 : 60)
+          },
+          opts
+        )
+      );
+    });
+  }
+}
+
+// platform/src/components/cloudflare/durable-object.ts
+import { output as output2 } from "@pulumi/pulumi";
+var DurableObject = class extends Component {
+  /**
+   * The exported Durable Object class name.
+   */
+  className;
+  constructor(name, args, opts) {
+    super(__pulumiType4, name, args, opts);
+    this.className = output2(args.className);
+  }
+  /**
+   * When you link a Durable Object to a worker, SST adds a Cloudflare Durable
+   * Object namespace binding.
+   *
+   * @internal
+   */
+  getSSTLink() {
+    const properties = {
+      className: this.className
+    };
+    return {
+      properties,
+      include: [
+        binding({
+          type: "durableObjectNamespaceBindings",
+          properties
+        }),
+        {
+          type: "cloudflare.durableObject",
+          ...properties
+        }
+      ]
+    };
+  }
+};
+var __pulumiType4 = "sst:cloudflare:DurableObject";
+DurableObject.__pulumiType = __pulumiType4;
+
+// platform/src/components/cloudflare/static-site.ts
+import fs3 from "fs";
+import path2 from "path";
+import crypto2 from "crypto";
+import { all as all3, output as output5 } from "@pulumi/pulumi";
+import { globSync } from "glob";
+
+// platform/src/components/cloudflare/providers/kv-data.ts
+import fs from "fs";
+import { dynamic as dynamic3 } from "@pulumi/pulumi";
+var Provider2 = class {
+  async create(inputs) {
+    await this.upload(inputs.accountId, inputs.namespaceId, inputs.entries, []);
+    return { id: "data" };
+  }
+  async update(id, olds, news) {
+    await this.upload(
+      news.accountId,
+      news.namespaceId,
+      news.entries,
+      news.namespaceId === olds.namespaceId ? olds.entries : []
+    );
+    return {};
+  }
+  async upload(accountId, namespaceId, entries, oldEntries) {
+    const oldFilesMap = new Map(oldEntries.map((f) => [f.key, f]));
+    const changedEntries = entries.filter((entry) => {
+      const old = oldFilesMap.get(entry.key);
+      return old?.hash !== entry.hash || old?.contentType !== entry.contentType || old?.cacheControl !== entry.cacheControl;
+    });
+    const htmlEntries = changedEntries.filter((e) => e.key.endsWith(".html"));
+    const nonHtmlEntries = changedEntries.filter(
+      (e) => !e.key.endsWith(".html")
+    );
+    const uploadEntry = async (entry) => {
+      const formData = new FormData();
+      formData.append(
+        "metadata",
+        JSON.stringify({
+          contentType: entry.contentType,
+          cacheControl: entry.cacheControl
+        })
+      );
+      formData.append(
+        "value",
+        await fs.promises.readFile(entry.source, "base64")
+      );
+      try {
+        await cfFetch(
+          `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${entry.key}`,
+          {
+            method: "PUT",
+            body: formData
+          }
+        );
+      } catch (error) {
+        console.log(error);
+        throw error;
+      }
+    };
+    await Promise.all(nonHtmlEntries.map(uploadEntry));
+    await Promise.all(htmlEntries.map(uploadEntry));
+  }
+};
+var KvData = class extends dynamic3.Resource {
+  constructor(name, args, opts) {
+    super(new Provider2(), `${name}.sst.cloudflare.KvPairs`, args, opts);
+  }
+};
+
+// platform/src/components/cloudflare/worker.ts
+import fs2 from "fs/promises";
+import path from "path";
+import crypto from "crypto";
+import {
+  output as output4,
+  all as all2,
+  jsonStringify,
+  interpolate
+} from "@pulumi/pulumi";
+import * as cf from "@pulumi/cloudflare";
+
+// platform/src/components/cloudflare/providers/worker-url.ts
+import { dynamic as dynamic4 } from "@pulumi/pulumi";
+var Provider3 = class {
+  async create(inputs) {
+    const url = await this.process(inputs);
+    return {
+      id: inputs.scriptName,
+      outs: url ? { url } : {}
+    };
+  }
+  async update(id, olds, news) {
+    const url = await this.process(news);
+    return {
+      outs: url ? { url } : {}
+    };
+  }
+  async process(inputs) {
+    if (inputs.enabled === false) {
+      await this.setEnabledFlag(inputs);
+      return void 0;
+    }
+    const [userSubdomain] = await Promise.all([
+      this.getWorkerDevSubdomain(inputs),
+      this.setEnabledFlag(inputs)
+    ]);
+    return `${inputs.scriptName}.${userSubdomain}.workers.dev`;
+  }
+  async getWorkerDevSubdomain(inputs) {
+    try {
+      const ret = await cfFetch(
+        `/accounts/${inputs.accountId}/workers/subdomain`,
+        {
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+      return ret.result.subdomain;
+    } catch (error) {
+      console.log(error);
+      throw error;
+    }
+  }
+  async setEnabledFlag(inputs) {
+    try {
+      await cfFetch(
+        `/accounts/${inputs.accountId}/workers/scripts/${inputs.scriptName}/subdomain`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ enabled: inputs.enabled })
+        }
+      );
+      await new Promise((resolve) => setTimeout(resolve, 3e3));
+    } catch (error) {
+      console.log(error);
+      throw error;
+    }
+  }
+};
+var WorkerUrl = class extends dynamic4.Resource {
+  constructor(name, args, opts) {
+    super(
+      new Provider3(),
+      `${name}.sst.cloudflare.WorkerUrl`,
+      { ...args, url: void 0 },
+      opts
+    );
+  }
+};
+
+// platform/src/components/cloudflare/providers/worker-placement.ts
+import { dynamic as dynamic5 } from "@pulumi/pulumi";
+function buildPlacement(inputs) {
+  if (inputs.mode) return { mode: inputs.mode };
+  if (inputs.region) return { region: inputs.region };
+  if (inputs.host) return { host: inputs.host };
+  if (inputs.hostname) return { hostname: inputs.hostname };
+  return {};
+}
+var Provider4 = class {
+  async create(inputs) {
+    await this.patch(inputs, buildPlacement(inputs));
+    return {
+      id: inputs.scriptName,
+      outs: { scriptName: inputs.scriptName }
+    };
+  }
+  async update(id, olds, news) {
+    await this.patch(news, buildPlacement(news));
+    return {
+      outs: { scriptName: news.scriptName }
+    };
+  }
+  async delete(id, inputs) {
+    await this.patch(inputs, {});
+  }
+  async patch(inputs, placement) {
+    const accountId = inputs.accountId || DEFAULT_ACCOUNT_ID;
+    const formData = new FormData();
+    formData.append(
+      "settings",
+      new Blob([JSON.stringify({ placement })], {
+        type: "application/json"
+      })
+    );
+    await cfFetch(
+      `/accounts/${accountId}/workers/scripts/${inputs.scriptName}/settings`,
+      {
+        method: "PATCH",
+        body: formData
+      }
+    );
+  }
+};
+var WorkerPlacement = class extends dynamic5.Resource {
+  constructor(name, args, opts) {
+    super(
+      new Provider4(),
+      `${name}.sst.cloudflare.WorkerPlacement`,
+      { ...args, scriptName: args.scriptName },
+      opts
+    );
+  }
+};
+
+// platform/src/components/cloudflare/worker.ts
+import { iam } from "@pulumi/aws";
+
+// platform/src/components/cloudflare/helpers/compatibility.ts
+import { all, output as output3 } from "@pulumi/pulumi";
+var DEFAULT_COMPATIBILITY_DATE = "2025-05-05";
+var DEFAULT_COMPATIBILITY_FLAGS = ["nodejs_compat"];
+function normalizeCompatibility(args) {
+  const compatibility = output3(args?.compatibility);
+  const workerTransform = typeof args?.transform?.worker === "function" ? void 0 : args?.transform?.worker;
+  return output3({
+    date: all([
+      compatibility.apply((value) => value?.date),
+      workerTransform?.compatibilityDate
+    ]).apply(
+      ([argValue, transformValue]) => transformValue ?? argValue ?? DEFAULT_COMPATIBILITY_DATE
+    ),
+    flags: all([
+      compatibility.apply((value) => value?.flags),
+      workerTransform?.compatibilityFlags
+    ]).apply(
+      ([argValue, transformValue]) => transformValue ?? argValue ?? DEFAULT_COMPATIBILITY_FLAGS
+    )
+  });
+}
+
+// platform/src/components/cloudflare/worker.ts
+var Worker = class extends Component {
+  script;
+  workerUrl;
+  workerPlacement;
+  workerDomain;
+  constructor(name, args, opts) {
+    super(__pulumiType5, name, args, opts);
+    const parent = this;
+    const accountId = args.accountId ?? DEFAULT_ACCOUNT_ID;
+    const dev = normalizeDev();
+    const urlEnabled = normalizeUrl();
+    const compatibility = normalizeCompatibility(args);
+    const domain = normalizeDomain();
+    const bindings = buildBindings();
+    const iamCredentials = createAwsCredentials();
+    const buildInput = all2([
+      name,
+      args.handler,
+      args.build,
+      compatibility
+    ]).apply(async ([name2, handler, build2, compatibility2]) => {
+      return {
+        functionID: name2,
+        links: {},
+        handler,
+        runtime: "worker",
+        properties: {
+          accountID: accountId,
+          build: build2,
+          compatibility: compatibility2
+        }
+      };
+    });
+    const build = buildHandler();
+    const script = createScript();
+    const workerUrl = createWorkersUrl();
+    const workerPlacement = createWorkerPlacement();
+    const workerDomain = createWorkersDomain();
+    createAliases();
+    createRedirects();
+    this.script = script;
+    this.workerUrl = workerUrl;
+    this.workerPlacement = workerPlacement;
+    this.workerDomain = workerDomain;
+    all2([dev, buildInput, script.scriptName]).apply(
+      async ([dev2, buildInput2, scriptName]) => {
+        if (!dev2) return void 0;
+        await rpc.call("Runtime.AddTarget", {
+          ...buildInput2,
+          properties: {
+            ...buildInput2.properties,
+            scriptName
+          }
+        });
+      }
+    );
+    this.registerOutputs({
+      _live: all2([name, args.handler, args.build, compatibility, dev]).apply(
+        ([name2, handler, build2, compatibility2, dev2]) => {
+          if (!dev2) return void 0;
+          return {
+            functionID: name2,
+            links: [],
+            handler,
+            runtime: "worker",
+            properties: {
+              accountID: accountId,
+              scriptName: script.scriptName,
+              build: build2,
+              compatibility: compatibility2
+            }
+          };
+        }
+      ),
+      _metadata: {
+        handler: args.handler
+      }
+    });
+    function normalizeDev() {
+      return output4(args.dev).apply((v) => $dev && v !== false);
+    }
+    function normalizeUrl() {
+      return output4(args.url).apply((v) => v ?? false);
+    }
+    function normalizeDomain() {
+      if (!args.domain) return;
+      if (typeof args.domain === "object" && args.domain !== null && "name" in args.domain) {
+        return {
+          name: args.domain.name,
+          aliases: args.domain.aliases ?? [],
+          redirects: args.domain.redirects ?? []
+        };
+      }
+      return {
+        name: args.domain,
+        aliases: [],
+        redirects: []
+      };
+    }
+    function buildBindings() {
+      const result = [
+        {
+          type: "plain_text",
+          name: "SST_RESOURCE_App",
+          text: jsonStringify({
+            name: $app.name,
+            stage: $app.stage
+          })
+        }
+      ];
+      if (!args.link) return result;
+      return output4(args.link).apply((links) => {
+        for (let link of links) {
+          if (!Link.isLinkable(link)) continue;
+          const name2 = output4(link.urn).apply((uri) => uri.split("::").at(-1));
+          const item = link.getSSTLink();
+          const b = item.include?.find(
+            (i) => i.type === "cloudflare.binding"
+          );
+          result.push(
+            b ? {
+              type: {
+                aiBindings: "ai",
+                plainTextBindings: "plain_text",
+                secretTextBindings: "secret_text",
+                queueBindings: "queue",
+                serviceBindings: "service",
+                durableObjectNamespaceBindings: "durable_object_namespace",
+                kvNamespaceBindings: "kv_namespace",
+                d1DatabaseBindings: "d1",
+                r2BucketBindings: "r2_bucket",
+                hyperdriveBindings: "hyperdrive",
+                versionMetadataBindings: "version_metadata",
+                workflowBindings: "workflow",
+                rateLimitBindings: "ratelimit"
+              }[b.binding],
+              name: name2,
+              ...b.properties
+            } : {
+              type: "secret_text",
+              name: output4(name2).apply((name3) => `SST_RESOURCE_${name3}`),
+              text: jsonStringify(item.properties)
+            }
+          );
+        }
+        return result;
+      });
+    }
+    function createAwsCredentials() {
+      return output4(
+        Link.getInclude("aws.permission", args.link)
+      ).apply((permissions) => {
+        if (permissions.length === 0) return;
+        const user = new iam.User(
+          `${name}AwsUser`,
+          { forceDestroy: true },
+          { parent }
+        );
+        new iam.UserPolicy(
+          `${name}AwsPolicy`,
+          {
+            user: user.name,
+            policy: jsonStringify({
+              Statement: permissions.map((p) => ({
+                Effect: (() => {
+                  const effect = p.effect ?? "allow";
+                  return effect.charAt(0).toUpperCase() + effect.slice(1);
+                })(),
+                Action: p.actions,
+                Resource: p.resources,
+                ..."conditions" in p && p.conditions ? {
+                  Condition: Object.fromEntries(
+                    p.conditions.map((c) => [
+                      c.test,
+                      { [c.variable]: c.values }
+                    ])
+                  )
+                } : {}
+              }))
+            })
+          },
+          { parent }
+        );
+        const keys = new iam.AccessKey(
+          `${name}AwsCredentials`,
+          { user: user.name },
+          { parent }
+        );
+        return keys;
+      });
+    }
+    function buildHandler() {
+      const buildResult = buildInput.apply(async (input) => {
+        const result = await rpc.call("Runtime.Build", input);
+        if (result.errors.length > 0) {
+          throw new Error(result.errors.join("\n"));
+        }
+        return result;
+      });
+      return buildResult;
+    }
+    function createScript() {
+      const scriptName = prefixName(54, `${name}Script`).toLowerCase();
+      const durableObjectMigrationState = args.migrations ? all2([args.migrations, accountId]).apply(
+        async ([migrations, accountId2]) => {
+          const latest = migrations.at(-1);
+          if (!latest) {
+            return {
+              migrationTag: void 0,
+              migrations: void 0
+            };
+          }
+          let currentTag;
+          try {
+            const published = await cfFetch(`/accounts/${accountId2}/workers/scripts`);
+            currentTag = published.result.find(
+              (script2) => script2.id === scriptName
+            )?.migration_tag;
+          } catch (error) {
+            const code = typeof error === "object" && error !== null && "errors" in error && Array.isArray(error.errors) && typeof error.errors[0]?.code === "number" ? error.errors[0].code : void 0;
+            const serviceNotFound = code === 10090;
+            const environmentNotFound = code === 10092;
+            if (!serviceNotFound && !environmentNotFound) {
+              throw error;
+            }
+          }
+          if (currentTag) {
+            const foundIndex = migrations.findIndex(
+              (migration) => migration.tag === currentTag
+            );
+            if (foundIndex === migrations.length - 1) {
+              return {
+                migrationTag: currentTag,
+                migrations: void 0
+              };
+            }
+            const pending = foundIndex === -1 ? migrations : migrations.slice(foundIndex + 1);
+            const steps2 = pending.map(({ tag: _tag, ...step }) => step);
+            return {
+              migrationTag: currentTag,
+              migrations: {
+                oldTag: currentTag,
+                newTag: latest.tag,
+                steps: steps2
+              }
+            };
+          }
+          const steps = migrations.map(({ tag: _tag, ...step }) => step);
+          return {
+            migrationTag: "",
+            migrations: {
+              newTag: latest.tag,
+              steps
+            }
+          };
+        }
+      ) : void 0;
+      const contentFilePath = build.apply(
+        (build2) => path.join(build2.out, build2.handler)
+      );
+      return new cf.WorkersScript(
+        ...transform(
+          args.transform?.worker,
+          `${name}Script`,
+          {
+            scriptName,
+            mainModule: "placeholder",
+            accountId,
+            contentFile: contentFilePath,
+            contentSha256: contentFilePath.apply(
+              async (p) => crypto.createHash("sha256").update(await fs2.readFile(p, "utf-8")).digest("hex")
+            ),
+            compatibilityDate: compatibility.apply((value) => value.date),
+            compatibilityFlags: compatibility.apply((value) => value.flags),
+            ...durableObjectMigrationState ? {
+              migrations: durableObjectMigrationState.apply(
+                (state) => state.migrations
+              ),
+              migrationTag: durableObjectMigrationState.apply(
+                (state) => state.migrationTag
+              )
+            } : {},
+            assets: args.assets ? output4(args.assets).apply(async (assets) => {
+              const directory = path.isAbsolute(assets.directory) ? assets.directory : path.join($cli.paths.root, assets.directory);
+              let headers;
+              let redirects;
+              try {
+                headers = await fs2.readFile(
+                  path.join(directory, "_headers"),
+                  "utf-8"
+                );
+              } catch (e) {
+              }
+              try {
+                redirects = await fs2.readFile(
+                  path.join(directory, "_redirects"),
+                  "utf-8"
+                );
+              } catch (e) {
+              }
+              return {
+                directory,
+                config: {
+                  headers,
+                  redirects,
+                  htmlHandling: assets.htmlHandling,
+                  notFoundHandling: assets.notFoundHandling,
+                  runWorkerFirst: assets.runWorkerFirst
+                }
+              };
+            }) : void 0,
+            bindings: all2([args.environment, iamCredentials, bindings]).apply(
+              ([environment, iamCredentials2, bindings2]) => [
+                ...bindings2,
+                ...iamCredentials2 ? [
+                  {
+                    type: "plain_text",
+                    name: "AWS_ACCESS_KEY_ID",
+                    text: iamCredentials2.id
+                  },
+                  {
+                    type: "secret_text",
+                    name: "AWS_SECRET_ACCESS_KEY",
+                    text: iamCredentials2.secret
+                  }
+                ] : [],
+                ...args.assets ? [
+                  {
+                    type: "assets",
+                    name: "ASSETS"
+                  }
+                ] : [],
+                ...Object.entries(environment ?? {}).map(([key, value]) => ({
+                  type: "plain_text",
+                  name: key,
+                  text: value
+                }))
+              ]
+            )
+          },
+          { parent, ignoreChanges: ["scriptName"] }
+        )
+      );
+    }
+    function createWorkersUrl() {
+      return new WorkerUrl(
+        `${name}Url`,
+        {
+          accountId,
+          scriptName: script.scriptName,
+          enabled: urlEnabled,
+          etag: script.etag
+        },
+        { parent }
+      );
+    }
+    function createWorkerPlacement() {
+      if (!args.placement) return;
+      return new WorkerPlacement(
+        `${name}Placement`,
+        {
+          accountId,
+          scriptName: script.scriptName,
+          // Reapply placement after each script update. Asset-backed SSR workers
+          // can rewrite script settings and reset placement back to the default.
+          etag: script.etag,
+          ...args.placement
+        },
+        { parent }
+      );
+    }
+    function createWorkersDomain() {
+      if (!domain) return;
+      const zone = new ZoneLookup(
+        `${name}ZoneLookup`,
+        {
+          accountId,
+          domain: domain.name
+        },
+        { parent }
+      );
+      return new cf.WorkersCustomDomain(
+        `${name}Domain`,
+        {
+          accountId,
+          service: script.scriptName,
+          hostname: domain.name,
+          zoneId: zone.id,
+          environment: "production"
+        },
+        { parent }
+      );
+    }
+    function createAliases() {
+      if (!domain) return;
+      for (const [i, hostname] of domain.aliases.entries()) {
+        const zone = new ZoneLookup(
+          `${name}Alias${i}ZoneLookup`,
+          {
+            accountId,
+            domain: hostname
+          },
+          { parent }
+        );
+        new cf.WorkersCustomDomain(
+          `${name}Alias${i}Domain`,
+          {
+            accountId,
+            service: script.scriptName,
+            hostname,
+            zoneId: zone.id,
+            environment: "production"
+          },
+          { parent }
+        );
+      }
+    }
+    function createRedirects() {
+      if (!domain) return;
+      for (const [i, hostname] of domain.redirects.entries()) {
+        const resourceName = `${name}Redirect${i}`;
+        const zone = new ZoneLookup(
+          `${resourceName}ZoneLookup`,
+          {
+            accountId,
+            domain: hostname
+          },
+          { parent }
+        );
+        new cf.DnsRecord(
+          `${resourceName}Record`,
+          {
+            zoneId: zone.id,
+            name: hostname,
+            type: "AAAA",
+            content: "100::",
+            proxied: true,
+            ttl: 1
+          },
+          { parent }
+        );
+        new cf.PageRule(
+          `${resourceName}Rule`,
+          {
+            zoneId: zone.id,
+            target: interpolate`${hostname}/*`,
+            priority: i + 1,
+            status: "active",
+            actions: {
+              forwardingUrl: {
+                statusCode: 301,
+                url: output4(domain.name).apply(
+                  (domainName) => `https://${domainName}/$1`
+                )
+              }
+            }
+          },
+          { parent }
+        );
+      }
+    }
+  }
+  /**
+   * The Worker URL if `url` is enabled.
+   */
+  get url() {
+    return this.workerDomain ? interpolate`https://${this.workerDomain.hostname}` : this.workerUrl.url.apply((url) => url ? `https://${url}` : url);
+  }
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  get nodes() {
+    return {
+      /**
+       * The Cloudflare Worker script.
+       */
+      worker: this.script
+    };
+  }
+  /**
+   * When you link a worker, say WorkerA, to another worker, WorkerB; it automatically creates
+   * a service binding between the workers. It allows WorkerA to call WorkerB without going
+   * through a publicly-accessible URL.
+   *
+   * @example
+   * ```ts title="index.ts" {3}
+   * import { Resource } from "sst";
+   *
+   * await Resource.WorkerB.fetch(request);
+   * ```
+   *
+   * Read more about [binding Workers](https://developers.cloudflare.com/workers/runtime-apis/bindings/service-bindings/).
+   *
+   * @internal
+   */
+  getSSTLink() {
+    return {
+      properties: {
+        url: this.url
+      },
+      include: [
+        binding({
+          type: "serviceBindings",
+          properties: {
+            service: this.script.id
+          }
+        })
+      ]
+    };
+  }
+};
+var __pulumiType5 = "sst:cloudflare:Worker";
+Worker.__pulumiType = __pulumiType5;
+
+// platform/src/components/cloudflare/static-site.ts
+var StaticSite = class extends Component {
+  assets;
+  router;
+  constructor(name, args = {}, opts = {}) {
+    super(__pulumiType6, name, args, opts);
+    const parent = this;
+    const { sitePath, environment, indexPage } = prepare(args);
+    const outputPath = $dev ? path2.join($cli.paths.platform, "functions", "empty-site") : buildApp2(parent, name, args.build, sitePath, environment);
+    const storage = createKvStorage();
+    const assetManifest = generateAssetManifest();
+    const kvData = uploadAssets();
+    const worker = createRouter();
+    this.assets = storage;
+    this.router = worker;
+    this.registerOutputs({
+      _hint: this.url,
+      _dev: {
+        environment,
+        command: "npm run dev",
+        directory: sitePath,
+        autostart: true
+      },
+      _metadata: {
+        path: sitePath,
+        environment,
+        url: this.url
+      }
+    });
+    function createKvStorage() {
+      return new Kv(
+        ...transform(
+          args.transform?.assets,
+          `${name}Assets`,
+          {
+            accountId: args.accountId
+          },
+          {
+            parent,
+            retainOnDelete: false
+          }
+        )
+      );
+    }
+    function generateAssetManifest() {
+      return all3([outputPath, args.assets]).apply(
+        async ([outputPath2, assets]) => {
+          const fileOptions = assets?.fileOptions ?? [
+            {
+              files: "**",
+              cacheControl: "max-age=0,no-cache,no-store,must-revalidate"
+            },
+            {
+              files: ["**/*.js", "**/*.css"],
+              cacheControl: "max-age=31536000,public,immutable"
+            }
+          ];
+          const manifest = [];
+          const filesProcessed = [];
+          for (const fileOption of fileOptions.reverse()) {
+            const files = globSync(fileOption.files, {
+              cwd: path2.resolve(outputPath2),
+              nodir: true,
+              dot: true,
+              ignore: [
+                ".sst/**",
+                ...typeof fileOption.ignore === "string" ? [fileOption.ignore] : fileOption.ignore ?? []
+              ]
+            }).filter((file) => !filesProcessed.includes(file));
+            filesProcessed.push(...files);
+            manifest.push(
+              ...await Promise.all(
+                files.map(async (file) => {
+                  const source = path2.resolve(outputPath2, file);
+                  const content = await fs3.promises.readFile(source, "utf-8");
+                  const hash = crypto2.createHash("sha256").update(content).digest("hex");
+                  return {
+                    source,
+                    key: file,
+                    hash,
+                    cacheControl: fileOption.cacheControl,
+                    contentType: fileOption.contentType ?? getContentType(file, "UTF-8")
+                  };
+                })
+              )
+            );
+          }
+          return manifest;
+        }
+      );
+    }
+    function uploadAssets() {
+      return new KvData(
+        `${name}AssetFiles`,
+        {
+          accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+          namespaceId: storage.id,
+          entries: assetManifest.apply(
+            (manifest) => manifest.map((m) => ({
+              source: m.source,
+              key: m.key,
+              hash: m.hash,
+              cacheControl: m.cacheControl,
+              contentType: m.contentType
+            }))
+          )
+        },
+        { parent, ignoreChanges: $dev ? ["*"] : void 0 }
+      );
+    }
+    function createRouter() {
+      return new Worker(
+        `${name}Router`,
+        {
+          accountId: args.accountId,
+          handler: path2.join(
+            $cli.paths.platform,
+            "functions",
+            "cf-static-site-router-worker"
+          ),
+          url: true,
+          domain: args.domain,
+          environment: {
+            INDEX_PAGE: indexPage,
+            ...args.errorPage ? { ERROR_PAGE: args.errorPage } : {}
+          },
+          build: {
+            esbuild: assetManifest.apply((assetManifest2) => ({
+              define: {
+                SST_ASSET_MANIFEST: JSON.stringify(
+                  Object.fromEntries(assetManifest2.map((e) => [e.key, e.hash]))
+                )
+              }
+            }))
+          },
+          transform: {
+            worker: (workerArgs) => {
+              workerArgs.bindings = output5(workerArgs.bindings ?? []).apply(
+                (bindings) => [
+                  ...bindings,
+                  {
+                    type: "kv_namespace",
+                    name: "ASSETS",
+                    namespaceId: storage.id
+                  }
+                ]
+              );
+            }
+          }
+        },
+        // create worker after KV upload finishes
+        { dependsOn: kvData, parent }
+      );
+    }
+  }
+  /**
+   * The URL of the website.
+   *
+   * If the `domain` is set, this is the URL with the custom domain.
+   * Otherwise, it's the auto-generated worker URL.
+   */
+  get url() {
+    return this.router.url;
+  }
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  get nodes() {
+    return {
+      /**
+       * The KV namespace that stores the assets.
+       */
+      assets: this.assets,
+      /**
+       * The worker that serves the requests.
+       */
+      router: this.router
+    };
+  }
+  /** @internal */
+  getSSTLink() {
+    return {
+      properties: {
+        url: this.url
+      }
+    };
+  }
+};
+var __pulumiType6 = "sst:cloudflare:StaticSite";
+StaticSite.__pulumiType = __pulumiType6;
+
+// platform/src/components/cloudflare/static-site-v2.ts
+import path3 from "path";
+import { output as output6 } from "@pulumi/pulumi";
+var StaticSiteV2 = class extends Component {
+  server;
+  devUrl = output6(URL_UNAVAILABLE);
+  constructor(name, args = {}, opts = {}) {
+    super(__pulumiType7, name, args, opts);
+    const self = this;
+    const { sitePath, environment, indexPage } = prepare(args);
+    const dev = normalizeDev();
+    if (dev.enabled) {
+      this.devUrl = dev.url;
+      this.registerOutputs({
+        _hint: void 0,
+        _dev: dev.outputs,
+        _metadata: {
+          mode: "placeholder",
+          path: sitePath,
+          environment,
+          url: this.url
+        }
+      });
+      return;
+    }
+    function normalizeDev() {
+      const enabled = $dev && args.dev !== false;
+      const devArgs = args.dev || {};
+      return {
+        enabled,
+        url: output6(devArgs.url ?? URL_UNAVAILABLE),
+        outputs: {
+          title: devArgs.title,
+          environment,
+          command: output6(devArgs.command ?? "npm run dev"),
+          autostart: output6(devArgs.autostart ?? true),
+          directory: output6(devArgs.directory ?? sitePath)
+        }
+      };
+    }
+    const htmlHandling = normalizeHtmlHandling();
+    const notFound = normalizeNotFound();
+    const outputPath = buildApp2(self, name, args.build, sitePath, environment);
+    const worker = createRouter();
+    this.server = worker;
+    this.registerOutputs({
+      _hint: this.url,
+      _dev: dev.outputs,
+      _metadata: {
+        mode: "deployed",
+        path: sitePath,
+        environment,
+        url: this.url
+      }
+    });
+    function createRouter() {
+      return new Worker(
+        ...transform(
+          args.transform?.server,
+          `${name}Router`,
+          {
+            accountId: args.accountId,
+            handler: path3.join(
+              $cli.paths.platform,
+              "functions",
+              "cf-static-site-router-worker-experimental"
+            ),
+            environment: environment.apply((e) => ({
+              ...e,
+              ...args.indexPage || args.errorPage ? { INDEX_PAGE: indexPage } : {},
+              ...args.errorPage ? { ERROR_PAGE: args.errorPage } : {}
+            })),
+            url: true,
+            dev: false,
+            domain: args.domain,
+            assets: {
+              directory: outputPath,
+              htmlHandling,
+              notFoundHandling: notFound
+            }
+          },
+          { parent: self }
+        )
+      );
+    }
+    function normalizeHtmlHandling() {
+      return args.trailingSlash === "force" ? "force-trailing-slash" : args.trailingSlash === "drop" ? "drop-trailing-slash" : "auto-trailing-slash";
+    }
+    function normalizeNotFound() {
+      return args.notFound === "404" ? "404-page" : "single-page-application";
+    }
+  }
+  /**
+   * The URL of the website.
+   *
+   * If the `domain` is set, this is the URL with the custom domain.
+   * Otherwise, it's the auto-generated worker URL.
+   */
+  get url() {
+    return this.server?.url ?? this.devUrl;
+  }
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  get nodes() {
+    return {
+      /**
+       * The worker that serves the requests.
+       */
+      server: this.server
+    };
+  }
+  /** @internal */
+  getSSTLink() {
+    return {
+      properties: {
+        url: this.url
+      }
+    };
+  }
+};
+var __pulumiType7 = "sst:cloudflare:StaticSite";
+StaticSiteV2.__pulumiType = __pulumiType7;
+
+// platform/src/components/cloudflare/auth.ts
+import {
+  output as output7,
+  secret
+} from "@pulumi/pulumi";
+import { PrivateKey } from "@pulumi/tls";
+var Auth = class extends Component {
+  _key;
+  _authenticator;
+  constructor(name, args, opts) {
+    super(__pulumiType8, name, args, opts);
+    this._key = new PrivateKey(`${name}Keypair`, {
+      algorithm: "RSA"
+    });
+    this._authenticator = output7(args.authenticator).apply((args2) => {
+      return new Worker(`${name}Authenticator`, {
+        ...args2,
+        url: true,
+        environment: {
+          ...args2.environment,
+          AUTH_PRIVATE_KEY: secret(this.key.privateKeyPemPkcs8),
+          AUTH_PUBLIC_KEY: secret(this.key.publicKeyPem)
+        }
+      });
+    });
+  }
+  get key() {
+    return this._key;
+  }
+  get authenticator() {
+    return this._authenticator;
+  }
+  get url() {
+    return this._authenticator.url;
+  }
+  /** @internal */
+  getSSTLink() {
+    return {
+      properties: {
+        url: this._authenticator.url,
+        publicKey: secret(this.key.publicKeyPem)
+      }
+    };
+  }
+};
+var __pulumiType8 = "sst:cloudflare:Auth";
+Auth.__pulumiType = __pulumiType8;
+
+// platform/src/components/cloudflare/queue.ts
+import * as cloudflare6 from "@pulumi/cloudflare";
+
+// platform/src/components/cloudflare/queue-worker-subscriber.ts
+import { output as output9 } from "@pulumi/pulumi";
+import * as cloudflare5 from "@pulumi/cloudflare";
+
+// platform/src/components/cloudflare/helpers/worker-builder.ts
+import {
+  output as output8
+} from "@pulumi/pulumi";
+function workerBuilder(name, definition, argsTransform, opts, accountId) {
+  return output8(definition).apply((definition2) => {
+    if (typeof definition2 === "string") {
+      const worker = new Worker(
+        ...transform(argsTransform, name, { accountId, handler: definition2 }, opts || {})
+      );
+      return {
+        getWorker: () => worker,
+        script: worker.nodes.worker
+      };
+    } else if (definition2.handler) {
+      const worker = new Worker(
+        ...transform(
+          argsTransform,
+          name,
+          {
+            accountId,
+            ...definition2
+          },
+          opts || {}
+        )
+      );
+      return {
+        getWorker: () => worker,
+        script: worker.nodes.worker
+      };
+    }
+    throw new Error(`Invalid worker definition for the "${name}" Worker`);
+  });
+}
+
+// platform/src/components/cloudflare/queue-worker-subscriber.ts
+var QueueWorkerSubscriber = class extends Component {
+  _worker;
+  consumer;
+  constructor(name, args, opts) {
+    super(__pulumiType9, name, args, opts);
+    const self = this;
+    const queue = output9(args.queue);
+    const accountId = args.accountId ?? DEFAULT_ACCOUNT_ID;
+    const worker = createWorker();
+    const batchSize = output9(args.batch?.size ?? 10);
+    const window = output9(args.batch?.window ?? "5 seconds");
+    const retryDelay = output9(args.dlq?.retryDelay ?? "0 seconds");
+    const consumer = createConsumer();
+    this._worker = worker;
+    this.consumer = consumer;
+    function createWorker() {
+      return workerBuilder(
+        `${name}Function`,
+        args.subscriber,
+        args.transform?.worker,
+        { parent: self },
+        accountId
+      );
+    }
+    function createConsumer() {
+      return new cloudflare5.QueueConsumer(
+        ...transform(
+          args.transform?.consumer,
+          `${name}Consumer`,
+          {
+            accountId,
+            deadLetterQueue: args.dlq?.queue,
+            queueId: queue.id,
+            scriptName: worker.script.scriptName,
+            settings: {
+              batchSize,
+              maxConcurrency: args.maxConcurrency,
+              maxRetries: args.dlq?.retry,
+              retryDelay: retryDelay.apply((v) => toMilliseconds(v)),
+              maxWaitTimeMs: window.apply((v) => toMilliseconds(v))
+            },
+            type: "worker"
+          },
+          { parent: self }
+        )
+      );
+    }
+  }
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  get nodes() {
+    const self = this;
+    return {
+      /**
+       * The Worker that'll process messages from the queue.
+       */
+      get worker() {
+        return self._worker.apply((worker) => worker.getWorker());
+      },
+      /**
+       * The Cloudflare Queue Consumer.
+       */
+      consumer: this.consumer
+    };
+  }
+};
+var __pulumiType9 = "sst:cloudflare:QueueWorkerSubscriber";
+QueueWorkerSubscriber.__pulumiType = __pulumiType9;
+
+// platform/src/components/cloudflare/queue.ts
+var Queue2 = class extends Component {
+  queue;
+  isSubscribed = false;
+  constructorName;
+  constructorArgs;
+  constructorOpts;
+  constructor(name, args, opts) {
+    super(__pulumiType10, name, args, opts);
+    const parent = this;
+    this.constructorName = name;
+    this.constructorArgs = args;
+    this.constructorOpts = opts;
+    const queue = create();
+    this.queue = queue;
+    function create() {
+      return new cloudflare6.Queue(
+        ...transform(
+          args?.transform?.queue,
+          `${name}Queue`,
+          {
+            queueName: "",
+            accountId: args?.accountId ?? DEFAULT_ACCOUNT_ID
+          },
+          { parent }
+        )
+      );
+    }
+  }
+  /**
+   * Subscribe to the queue with a worker.
+   *
+   * @param subscriber The worker that'll process messages from the queue.
+   * @param args Configure the subscription.
+   * @param opts Component resource options.
+   *
+   * @example
+   *
+   * Subscribe to the queue with a worker file.
+   *
+   * ```ts title="sst.config.ts"
+   * queue.subscribe("consumer.ts");
+   * ```
+   *
+   * Pass in full worker props.
+   *
+   * ```ts title="sst.config.ts"
+   * const bucket = new sst.cloudflare.Bucket("MyBucket");
+   *
+   * queue.subscribe({
+   *   handler: "consumer.ts",
+   *   link: [bucket],
+   * });
+   * ```
+   *
+   * Configure batch settings.
+   *
+   * ```ts title="sst.config.ts"
+   * queue.subscribe("consumer.ts", {
+   *   batch: {
+   *     size: 10,
+   *     window: "20 seconds",
+   *   },
+   * });
+   * ```
+   */
+  subscribe(subscriber, args, opts) {
+    if (this.isSubscribed) {
+      throw new VisibleError(
+        `Cannot subscribe to the "${this.constructorName}" queue multiple times. A Cloudflare Queue can only have one consumer.`
+      );
+    }
+    this.isSubscribed = true;
+    const parent = this;
+    const name = this.constructorName;
+    return new QueueWorkerSubscriber(
+      `${name}Subscriber`,
+      {
+        queue: { id: this.queue.id },
+        subscriber,
+        accountId: this.constructorArgs?.accountId,
+        dlq: this.constructorArgs?.dlq,
+        maxConcurrency: this.constructorArgs?.maxConcurrency,
+        batch: args?.batch,
+        transform: args?.transform
+      },
+      { ...opts, provider: this.constructorOpts?.provider }
+    );
+  }
+  getSSTLink() {
+    return {
+      properties: {},
+      include: [
+        binding({
+          type: "queueBindings",
+          properties: {
+            queueName: this.queue.queueName
+          }
+        })
+      ]
+    };
+  }
+  /**
+   * The generated id of the queue
+   */
+  get id() {
+    return this.queue.id;
+  }
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  get nodes() {
+    return {
+      /**
+       * The Cloudflare queue.
+       */
+      queue: this.queue
+    };
+  }
+};
+var __pulumiType10 = "sst:cloudflare:Queue";
+Queue2.__pulumiType = __pulumiType10;
+
+// platform/src/components/cloudflare/cron.ts
+import { all as all4 } from "@pulumi/pulumi";
+import * as cloudflare7 from "@pulumi/cloudflare";
+var Cron = class extends Component {
+  worker;
+  trigger;
+  constructor(name, args, opts) {
+    super(__pulumiType11, name, args, opts);
+    const parent = this;
+    const workerArgs = normalizeWorker();
+    const worker = createWorker();
+    const trigger = createTrigger();
+    this.worker = worker;
+    this.trigger = trigger;
+    function normalizeWorker() {
+      if (args.job && args.worker)
+        throw new VisibleError(
+          `You cannot provide both "job" and "worker" in the "${name}" Cron component. The "job" property has been deprecated. Use "worker" instead.`
+        );
+      return args.worker ?? args.job;
+    }
+    function createWorker() {
+      if (!workerArgs)
+        throw new VisibleError(
+          `You must provide a "worker" for the "${name}" Cron component.`
+        );
+      return workerBuilder(`${name}Handler`, workerArgs, void 0, void 0, args.accountId);
+    }
+    function createTrigger() {
+      return all4([args.schedules]).apply(([schedules]) => {
+        return new cloudflare7.WorkersCronTrigger(
+          ...transform(
+            args.transform?.trigger,
+            `${name}Trigger`,
+            {
+              accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+              scriptName: worker.script.scriptName,
+              schedules: schedules.map((s) => ({ cron: s }))
+            },
+            { parent }
+          )
+        );
+      });
+    }
+  }
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  get nodes() {
+    return {
+      /**
+       * The Cloudflare Worker.
+       */
+      worker: this.worker.script,
+      /**
+       * The Cloudflare Worker Cron Trigger.
+       */
+      trigger: this.trigger
+    };
+  }
+};
+var __pulumiType11 = "sst:cloudflare:Cron";
+Cron.__pulumiType = __pulumiType11;
+
+// platform/src/components/cloudflare/ai.ts
+var Ai = class extends Component {
+  constructor(name, args, opts) {
+    super(__pulumiType12, name, args, opts);
+  }
+  /**
+   * When you link an AI binding, it will be available to the worker and you can
+   * interact with it using its [API methods](https://developers.cloudflare.com/workers-ai/).
+   *
+   * @example
+   * ```ts title="index.ts" {3}
+   * import { Resource } from "sst";
+   *
+   * const result = await Resource.MyAi.run("@cf/meta/llama-3-8b-instruct", {
+   *   prompt: "What is the origin of the phrase 'Hello, World'"
+   * });
+   * ```
+   *
+   * @internal
+   */
+  getSSTLink() {
+    return {
+      properties: {},
+      include: [
+        binding({
+          type: "aiBindings",
+          properties: {}
+        })
+      ]
+    };
+  }
+};
+var __pulumiType12 = "sst:cloudflare:Ai";
+Ai.__pulumiType = __pulumiType12;
+
+// platform/src/components/cloudflare/hyperdrive.ts
+import { output as output10 } from "@pulumi/pulumi";
+import * as cloudflare8 from "@pulumi/cloudflare";
+var Hyperdrive = class _Hyperdrive extends Component {
+  hyperdrive;
+  constructor(name, args, opts) {
+    super(__pulumiType13, name, args, opts);
+    if (args && "ref" in args) {
+      const ref = args;
+      this.hyperdrive = ref.hyperdrive;
+      return;
+    }
+    const parent = this;
+    const origin = output10(args.origin);
+    const caching = normalizeCaching();
+    this.hyperdrive = new cloudflare8.HyperdriveConfig(
+      ...transform(
+        args.transform?.hyperdrive,
+        `${name}Hyperdrive`,
+        {
+          accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+          caching,
+          mtls: args.mtls,
+          name: "",
+          origin,
+          originConnectionLimit: args.connectionLimit
+        },
+        { parent }
+      )
+    );
+    function normalizeCaching() {
+      if (args.caching === void 0) return void 0;
+      return output10(args.caching).apply((c) => {
+        if (c === false) return { disabled: true };
+        return {
+          maxAge: c.maxAge ? toSeconds(c.maxAge) : void 0,
+          staleWhileRevalidate: c.staleWhileRevalidate ? toSeconds(c.staleWhileRevalidate) : void 0
+        };
+      });
+    }
+  }
+  /**
+   * When you link Hyperdrive to a worker, the Hyperdrive binding will be available in the
+   * worker and you can use its `connectionString` to connect with a PostgreSQL or MySQL client.
+   *
+   * @example
+   * ```ts title="index.ts" {3}
+   * import postgres from "postgres"
+   * import { Resource } from "sst"
+   *
+   * const sql = postgres(Resource.PostgresDatabase.connectionString)
+   * ```
+   *
+   * For MySQL:
+   *
+   * ```ts title="index.ts" {3}
+   * import mysql from "mysql2/promise"
+   * import { Resource } from "sst"
+   *
+   * const db = await mysql.createConnection(Resource.MySQLDatabase.connectionString)
+   * ```
+   *
+   * @internal
+   */
+  getSSTLink() {
+    return {
+      properties: {
+        id: this.id
+      },
+      include: [
+        binding({
+          type: "hyperdriveBindings",
+          properties: {
+            id: this.id
+          }
+        })
+      ]
+    };
+  }
+  /**
+   * The generated ID of the Hyperdrive config.
+   */
+  get id() {
+    return this.hyperdrive.id.apply(
+      (id) => id.includes("/") ? id.split("/")[1] : id
+    );
+  }
+  /**
+   * The generated name of the Hyperdrive config.
+   */
+  get name() {
+    return this.hyperdrive.name;
+  }
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  get nodes() {
+    return {
+      /**
+       * The Cloudflare Hyperdrive config.
+       */
+      hyperdrive: this.hyperdrive
+    };
+  }
+  /**
+   * Reference an existing Hyperdrive config with the given ID. This is useful when you
+   * create a Hyperdrive config in one stage and want to share it in another.
+   *
+   * :::tip
+   * You can use the `static get` method to share Hyperdrive configs across stages.
+   * :::
+   *
+   * @param name The name of the component.
+   * @param args The arguments to get the Hyperdrive config.
+   * @param opts Resource options.
+   *
+   * @example
+   * Imagine you create a Hyperdrive config in the `dev` stage. And in your personal stage
+   * `frank`, instead of creating a new one, you want to share the same one from `dev`.
+   *
+   * ```ts title="sst.config.ts"
+   * const hyperdrive = $app.stage === "frank"
+   *   ? sst.cloudflare.Hyperdrive.get("MyDatabase", {
+   *       hyperdriveId: "a1b2c3d4e5f6",
+   *     })
+   *   : new sst.cloudflare.Hyperdrive("MyDatabase", { ... });
+   * ```
+   */
+  static get(name, args, opts) {
+    const hyperdrive = cloudflare8.HyperdriveConfig.get(
+      `${name}Hyperdrive`,
+      `${args.accountId ?? DEFAULT_ACCOUNT_ID}/${args.hyperdriveId}`,
+      void 0,
+      opts
+    );
+    return new _Hyperdrive(
+      name,
+      {
+        ref: true,
+        hyperdrive
+      },
+      opts
+    );
+  }
+};
+var __pulumiType13 = "sst:cloudflare:Hyperdrive";
+Hyperdrive.__pulumiType = __pulumiType13;
+
+// platform/src/components/cloudflare/astro.ts
+import fs9 from "fs/promises";
+import path8 from "path";
+
+// platform/src/components/cloudflare/ssr-site.ts
+import path5 from "path";
+import fs5 from "fs";
+import { output as output11, all as all5 } from "@pulumi/pulumi";
+
+// platform/src/components/cloudflare/helpers/wrangler.ts
+import fs4 from "fs";
+import path4 from "path";
+function createWranglerConfig(input) {
+  const config = {
+    ...input.frameworkConfig ?? {},
+    name: sanitizeWranglerName(`sst-${input.appStage}-${input.name}`),
+    compatibility_date: input.compatibility.date,
+    compatibility_flags: input.compatibility.flags
+  };
+  if (input.accountId) {
+    config.account_id = input.accountId;
+  }
+  const vars = {
+    ...input.environment ?? {},
+    SST_RESOURCE_App: JSON.stringify({
+      name: input.appName,
+      stage: input.appStage
+    })
+  };
+  const kvNamespaces = [];
+  const r2Buckets = [];
+  const d1Databases = [];
+  const hyperdrives = [];
+  const services = [];
+  const queueProducers = [];
+  const workflows = [];
+  const rateLimits = [];
+  let ai;
+  let versionMetadata;
+  for (const link of input.links ?? []) {
+    const binding2 = link.include.find(
+      (item) => item.type === "cloudflare.binding"
+    );
+    if (!binding2) {
+      vars[`SST_RESOURCE_${link.name}`] = JSON.stringify(link.properties ?? {});
+      continue;
+    }
+    const properties = binding2.properties ?? {};
+    switch (binding2.binding) {
+      case "aiBindings":
+        ai = {
+          binding: link.name,
+          remote: true
+        };
+        break;
+      case "kvNamespaceBindings":
+        kvNamespaces.push({
+          binding: link.name,
+          id: stringValue(properties.namespaceId),
+          remote: true
+        });
+        break;
+      case "secretTextBindings":
+      case "plainTextBindings":
+        vars[link.name] = stringValue(properties.text);
+        break;
+      case "serviceBindings":
+        services.push({
+          binding: link.name,
+          service: stringValue(properties.service),
+          remote: true
+        });
+        break;
+      case "queueBindings":
+        queueProducers.push({
+          binding: link.name,
+          queue: stringValue(properties.queueName),
+          remote: true
+        });
+        break;
+      case "r2BucketBindings":
+        r2Buckets.push({
+          binding: link.name,
+          bucket_name: stringValue(properties.bucketName),
+          remote: true
+        });
+        break;
+      case "d1DatabaseBindings":
+        d1Databases.push({
+          binding: link.name,
+          database_id: stringValue(properties.id),
+          remote: true
+        });
+        break;
+      case "hyperdriveBindings":
+        hyperdrives.push({
+          binding: link.name,
+          id: stringValue(properties.id)
+        });
+        break;
+      case "versionMetadataBindings":
+        versionMetadata = {
+          binding: link.name
+        };
+        break;
+      case "workflowBindings":
+        workflows.push({
+          binding: link.name,
+          name: stringValue(properties.workflowName),
+          class_name: stringValue(properties.className),
+          script_name: stringValue(properties.scriptName),
+          remote: true
+        });
+        break;
+      case "rateLimitBindings":
+        rateLimits.push({
+          name: link.name,
+          namespace_id: stringValue(properties.namespaceId),
+          simple: properties.simple
+        });
+        break;
+    }
+  }
+  if (Object.keys(vars).length > 0) {
+    config.vars = vars;
+  }
+  if (kvNamespaces.length > 0) {
+    config.kv_namespaces = kvNamespaces;
+  }
+  if (r2Buckets.length > 0) {
+    config.r2_buckets = r2Buckets;
+  }
+  if (d1Databases.length > 0) {
+    config.d1_databases = d1Databases;
+  }
+  if (hyperdrives.length > 0) {
+    config.hyperdrive = hyperdrives;
+  }
+  if (services.length > 0) {
+    config.services = services;
+  }
+  if (queueProducers.length > 0) {
+    config.queues = {
+      producers: queueProducers
+    };
+  }
+  if (ai) {
+    config.ai = ai;
+  }
+  if (versionMetadata) {
+    config.version_metadata = versionMetadata;
+  }
+  if (workflows.length > 0) {
+    config.workflows = workflows;
+  }
+  if (rateLimits.length > 0) {
+    config.rate_limits = rateLimits;
+  }
+  return config;
+}
+function writeWranglerConfig(args) {
+  const wranglerPath = path4.join(
+    args.workDir,
+    "wrangler",
+    args.stage,
+    `${args.name}.jsonc`
+  );
+  const contents = JSON.stringify(args.config, null, 2);
+  fs4.mkdirSync(path4.dirname(wranglerPath), { recursive: true });
+  if (!fs4.existsSync(wranglerPath) || fs4.readFileSync(wranglerPath, "utf-8") !== contents) {
+    fs4.writeFileSync(wranglerPath, contents);
+  }
+  return wranglerPath;
+}
+function stringValue(input) {
+  return typeof input === "string" ? input : "";
+}
+var wranglerNameRegex = /[^a-z0-9-]+/g;
+function sanitizeWranglerName(input) {
+  const value = input.toLowerCase().replaceAll(wranglerNameRegex, "-");
+  return value.replace(/^-+|-+$/g, "") || "sst";
+}
+
+// platform/src/components/cloudflare/ssr-site.ts
+var SsrSite = class extends Component {
+  server;
+  devUrl;
+  validate(_sitePath) {
+  }
+  buildWrangler(_sitePath) {
+    return void 0;
+  }
+  constructor(type, name, args = {}, opts = {}) {
+    super(type, name, args, opts);
+    const self = this;
+    const sitePath = normalizeSitePath();
+    const compatibility = resolveCompatibility();
+    const frameworkConfig = resolveFrameworkConfig();
+    const wranglerConfig = resolveWranglerConfig();
+    const dev = normalizeDev();
+    this.validate(sitePath);
+    if (dev.enabled) {
+      this.devUrl = dev.url;
+      this.registerOutputs({
+        _dev: dev.outputs,
+        _metadata: {
+          mode: "placeholder",
+          path: sitePath
+        }
+      });
+      return;
+    }
+    const outputPath = buildApp(
+      self,
+      name,
+      args,
+      sitePath,
+      void 0,
+      resolveBuildEnvironment()
+    );
+    const plan = this.buildPlan(outputPath);
+    const worker = createWorker();
+    this.server = worker;
+    this.registerOutputs({
+      _hint: this.url,
+      _metadata: {
+        mode: "deployed",
+        path: sitePath
+      }
+    });
+    function normalizeDev() {
+      const enabled = $dev && args.dev !== false;
+      const devArgs = args.dev || {};
+      return {
+        enabled,
+        url: output11(devArgs.url ?? URL_UNAVAILABLE),
+        outputs: {
+          title: devArgs.title,
+          environment: args.environment,
+          cloudflare: enabled ? {
+            path: resolveDevWranglerPath()
+          } : void 0,
+          command: output11(devArgs.command ?? "npm run dev"),
+          autostart: output11(devArgs.autostart ?? true),
+          directory: devArgs.directory ?? sitePath,
+          links: output11(args.link || []).apply(Link.build).apply((links) => links.map((link) => link.name))
+        }
+      };
+    }
+    function resolveFrameworkConfig() {
+      return output11(self.buildWrangler(sitePath)).apply((config) => config ?? {});
+    }
+    function resolveCompatibility() {
+      const [, workerArgs] = transform(
+        args.transform?.server,
+        `${name}Worker`,
+        {
+          environment: args.environment,
+          link: args.link,
+          accountId: args.accountId,
+          url: true,
+          dev: false,
+          domain: args.domain,
+          handler: output11(""),
+          assets: {
+            directory: output11("")
+          }
+        },
+        { parent: self }
+      );
+      return normalizeCompatibility(workerArgs);
+    }
+    function resolveBuildEnvironment() {
+      return resolveBuildWranglerPath().apply((wranglerPath) => ({
+        SST_WRANGLER_PATH: wranglerPath
+      }));
+    }
+    function resolveDevWranglerPath() {
+      return wranglerConfig.apply((config) => {
+        return writeWranglerConfig({
+          workDir: $cli.paths.work,
+          stage: $app.stage,
+          name,
+          config
+        });
+      });
+    }
+    function resolveWranglerConfig() {
+      return all5([
+        output11(args.environment ?? {}),
+        resolveLinkBindings(),
+        compatibility,
+        frameworkConfig,
+        args.accountId
+      ]).apply(([environment, links, compatibility2, frameworkConfig2, accountId]) => {
+        return createWranglerConfig({
+          appName: $app.name,
+          appStage: $app.stage,
+          name,
+          frameworkConfig: frameworkConfig2,
+          compatibility: compatibility2,
+          environment,
+          links,
+          accountId: accountId ?? DEFAULT_ACCOUNT_ID
+        });
+      });
+    }
+    function resolveBuildWranglerPath() {
+      return wranglerConfig.apply((config) => {
+        return writeWranglerConfig({
+          workDir: $cli.paths.work,
+          stage: $app.stage,
+          name,
+          config
+        });
+      });
+    }
+    function resolveLinkBindings() {
+      return output11(args.link ?? []).apply((links) => {
+        const linkBindings = links.filter(Link.isLinkable).map(
+          (link) => output11({
+            urn: link.urn,
+            link: link.getSSTLink()
+          }).apply(({ urn, link: link2 }) => ({
+            name: urn.split("::").at(-1),
+            include: link2.include ?? [],
+            properties: link2.properties
+          }))
+        );
+        return linkBindings.length > 0 ? all5(linkBindings) : [];
+      });
+    }
+    function normalizeSitePath() {
+      const sitePath2 = args.path ?? ".";
+      if (!fs5.existsSync(sitePath2)) {
+        throw new VisibleError(
+          `Site directory not found at "${path5.resolve(
+            sitePath2
+          )}". Please check the path setting in your configuration.`
+        );
+      }
+      return sitePath2;
+    }
+    function createWorker() {
+      return new Worker(
+        ...transform(
+          args.transform?.server,
+          `${name}Worker`,
+          {
+            environment: args.environment,
+            link: args.link,
+            accountId: args.accountId,
+            url: true,
+            dev: false,
+            domain: args.domain,
+            handler: all5([outputPath, plan.server]).apply(
+              ([outputPath2, server]) => path5.join(outputPath2, server)
+            ),
+            assets: {
+              directory: all5([outputPath, plan.assets]).apply(
+                ([outputPath2, assets]) => path5.join(outputPath2, assets)
+              )
+            }
+          },
+          { parent: self }
+        )
+      );
+    }
+  }
+  /**
+   * The URL of the site.
+   *
+   * If the `domain` is set, this is the URL with the custom domain.
+   * Otherwise, it's the auto-generated Worker URL.
+   */
+  get url() {
+    if (this.server) return this.server.url;
+    return this.devUrl;
+  }
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  get nodes() {
+    return {
+      /**
+       * The Cloudflare Worker that renders the site.
+       */
+      server: this.server
+    };
+  }
+  /** @internal */
+  getSSTLink() {
+    return {
+      properties: {
+        url: this.url
+      }
+    };
+  }
+};
+
+// platform/src/util/fs.ts
+import fs6 from "fs/promises";
+async function existsAsync(input) {
+  return fs6.access(input).then(() => true).catch(() => false);
+}
+
+// platform/src/util/package.ts
+import fs7 from "fs";
+import path6 from "path";
+function getPackageVersion(sitePath, packageName) {
+  try {
+    const pkgPath = path6.join(sitePath, "package.json");
+    if (!fs7.existsSync(pkgPath)) {
+      return void 0;
+    }
+    const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+    return pkg.dependencies?.[packageName] ?? pkg.devDependencies?.[packageName];
+  } catch {
+    return void 0;
+  }
+}
+
+// platform/src/components/cloudflare/helpers/validation.ts
+import fs8 from "fs";
+import path7 from "path";
+function validateNoWranglerFile(sitePath, componentName) {
+  const wranglerFiles = ["wrangler.toml", "wrangler.json", "wrangler.jsonc"];
+  for (const file of wranglerFiles) {
+    const filePath = path7.join(sitePath, file);
+    if (fs8.existsSync(filePath)) {
+      throw new VisibleError(
+        [
+          `Found ${file} in "${path7.resolve(sitePath)}" for ${componentName}.`,
+          "",
+          "Remove it to avoid interfering with SST managed wrangler configurations:",
+          `https://sst-community.github.io/sst/docs/cloudflare/#cloudflare-vite-plugin`
+        ].join("\n")
+      );
+    }
+  }
+}
+function validateFrameworkConfig(input) {
+  const { sitePath, configName, componentName } = input;
+  const extensions = [".ts", ".js", ".mjs"];
+  const configDir = sitePath;
+  let configPath;
+  for (const ext of extensions) {
+    const candidate = path7.join(configDir, `${configName}${ext}`);
+    if (fs8.existsSync(candidate)) {
+      configPath = candidate;
+      break;
+    }
+  }
+  if (!configPath) {
+    throw new VisibleError(
+      `Could not find config file for ${componentName} in "${path7.resolve(configDir)}".
+Expected one of: ${extensions.map((e) => `${configName}${e}`).join(", ")}.`
+    );
+  }
+  const content = fs8.readFileSync(configPath, "utf-8");
+  const hasWranglerPath = /configPath\s*[:=]\s*process\.env\.SST_WRANGLER_PATH/.test(content);
+  if (!hasWranglerPath) {
+    throw new VisibleError(
+      [
+        `Missing required configuration for ${componentName}.`,
+        "",
+        `The Cloudflare adapter must be configured with:`,
+        `  configPath: process.env.SST_WRANGLER_PATH,`,
+        "",
+        `This is required for linked resources to work correctly:`,
+        `https://sst-community.github.io/sst/docs/cloudflare/#cloudflare-vite-plugin`
+      ].join("\n")
+    );
+  }
+}
+
+// platform/src/components/cloudflare/astro.ts
+var Astro = class extends SsrSite {
+  constructor(name, args = {}, opts = {}) {
+    super(__pulumiType14, name, args, opts);
+  }
+  validate(sitePath) {
+    const astroVersion = getPackageVersion(sitePath, "astro");
+    const isV6Plus = !astroVersion || isALteB("6.0.0", astroVersion);
+    if (isV6Plus) {
+      validateFrameworkConfig({
+        sitePath,
+        configName: "astro.config",
+        componentName: "Astro"
+      });
+    }
+    validateNoWranglerFile(sitePath, "Astro");
+  }
+  buildPlan(outputPath) {
+    return outputPath.apply(async (outputPath2) => {
+      const distPath = path8.join(outputPath2, "dist");
+      const legacyServer = path8.join(distPath, "_worker.js", "index.js");
+      if (await existsAsync(legacyServer)) {
+        const ignorePath = path8.join(distPath, ".assetsignore");
+        const ignorePatterns = await existsAsync(ignorePath) ? (await fs9.readFile(ignorePath, "utf-8")).split("\n") : [];
+        let dirty = false;
+        ["_worker.js", "_routes.json"].forEach((pattern) => {
+          if (ignorePatterns.includes(pattern)) return;
+          ignorePatterns.push(pattern);
+          dirty = true;
+        });
+        if (dirty) {
+          await fs9.appendFile(ignorePath, "\n_worker.js\n_routes.json");
+        }
+        return {
+          server: "./dist/_worker.js/index.js",
+          assets: "./dist"
+        };
+      }
+      const wranglerPath = path8.join(distPath, "server", "wrangler.json");
+      if (await existsAsync(wranglerPath)) {
+        const serverPath = path8.dirname(wranglerPath);
+        const wrangler = JSON.parse(
+          await fs9.readFile(wranglerPath, "utf-8")
+        );
+        const main = wrangler.main ?? "entry.mjs";
+        const serverEntry = path8.resolve(serverPath, main);
+        const assetsDirectory = wrangler.assets?.directory;
+        const assetsPath = assetsDirectory ? path8.resolve(serverPath, assetsDirectory) : path8.join(distPath, "client");
+        if (await existsAsync(serverEntry)) {
+          return {
+            server: toRelativePath(serverEntry),
+            assets: toRelativePath(assetsPath)
+          };
+        }
+      }
+      throw new VisibleError(
+        `SSR server bundle not found in the build output at:
+  "${path8.resolve(distPath)}".
+
+Expected either Astro v5 output in \`dist/_worker.js/index.js\` or Astro v6+ output in \`dist/server/wrangler.json\`.
+If your Astro project is entirely pre-rendered, use the \`sst.cloudflare.StaticSite\` component instead of \`sst.cloudflare.Astro\`.`
+      );
+      function toRelativePath(filePath) {
+        const relative = path8.relative(outputPath2, filePath);
+        return relative.startsWith(".") ? relative : `./${relative}`;
+      }
+    });
+  }
+  /**
+   * The URL of the Astro site.
+   *
+   * If the `domain` is set, this is the URL with the custom domain.
+   * Otherwise, it's the auto-generated Worker URL.
+   */
+  get url() {
+    return super.url;
+  }
+};
+var __pulumiType14 = "sst:cloudflare:Astro";
+Astro.__pulumiType = __pulumiType14;
+
+// platform/src/components/cloudflare/react-router.ts
+import path9 from "path";
+var ReactRouter = class extends SsrSite {
+  constructor(name, args = {}, opts = {}) {
+    super(__pulumiType15, name, args, opts);
+  }
+  validate(sitePath) {
+    validateFrameworkConfig({
+      sitePath,
+      configName: "vite.config",
+      componentName: "ReactRouter"
+    });
+    validateNoWranglerFile(sitePath, "ReactRouter");
+  }
+  buildPlan(outputPath) {
+    return outputPath.apply(async (outputPath2) => {
+      const serverPath = path9.join(outputPath2, "build", "server", "index.js");
+      const assetsPath = path9.join(outputPath2, "build", "client");
+      if (!await existsAsync(serverPath)) {
+        throw new VisibleError(
+          [
+            `React Router server bundle not found at:
+  "${serverPath}".`,
+            "",
+            "Make sure the Cloudflare Vite plugin is configured in your `vite.config.ts`.",
+            "If your React Router project is entirely pre-rendered, use `sst.cloudflare.StaticSite` instead."
+          ].join("\n")
+        );
+      }
+      if (!await existsAsync(assetsPath)) {
+        throw new VisibleError(
+          `React Router assets directory not found at:
+  "${assetsPath}".`
+        );
+      }
+      return {
+        server: "./build/server/index.js",
+        assets: "./build/client"
+      };
+    });
+  }
+  buildWrangler(sitePath) {
+    return {
+      main: path9.resolve(sitePath, "workers/app.ts")
+    };
+  }
+  /**
+   * The URL of the React Router app.
+   *
+   * If the `domain` is set, this is the URL with the custom domain.
+   * Otherwise, it's the auto-generated Worker URL.
+   */
+  get url() {
+    return super.url;
+  }
+};
+var __pulumiType15 = "sst:cloudflare:ReactRouter";
+ReactRouter.__pulumiType = __pulumiType15;
+
+// platform/src/components/cloudflare/tan-stack-start.ts
+import fs10 from "fs/promises";
+import path10 from "path";
+var TanStackStart = class extends SsrSite {
+  constructor(name, args = {}, opts = {}) {
+    super(__pulumiType16, name, args, opts);
+  }
+  validate(sitePath) {
+    validateFrameworkConfig({
+      sitePath,
+      configName: "vite.config",
+      componentName: "TanStackStart"
+    });
+    validateNoWranglerFile(sitePath, "TanStackStart");
+  }
+  buildPlan(outputPath) {
+    return outputPath.apply(async (outputPath2) => {
+      const distPlan = await resolveDistPlan();
+      if (distPlan) return distPlan;
+      const legacyPlan = await resolveLegacyPlan();
+      if (legacyPlan) return legacyPlan;
+      throw new VisibleError(
+        [
+          `TanStack Start build output not found in "${path10.resolve(outputPath2)}".`,
+          "",
+          "Expected one of:",
+          "  - dist/server/wrangler.json and dist/client",
+          "  - dist/server/index.js and dist/client",
+          "  - .output/server/index.mjs and .output/public",
+          "",
+          "Use the Cloudflare deployment adapter in TanStack Start, or if your project is entirely pre-rendered, use `sst.cloudflare.StaticSite` instead."
+        ].join("\n")
+      );
+      async function resolveDistPlan() {
+        const wranglerPath = path10.join(
+          outputPath2,
+          "dist",
+          "server",
+          "wrangler.json"
+        );
+        if (await existsAsync(wranglerPath)) {
+          const wrangler = JSON.parse(await fs10.readFile(wranglerPath, "utf-8"));
+          if (!wrangler.main) {
+            throw new VisibleError(
+              `TanStack Start build output at "${path10.resolve(wranglerPath)}" is missing the Worker entry in \`main\`.`
+            );
+          }
+          const serverPath = path10.resolve(outputPath2, "dist", "server", wrangler.main);
+          const assetsPath = path10.resolve(
+            outputPath2,
+            "dist",
+            "server",
+            wrangler.assets?.directory ?? "../client"
+          );
+          if (!await existsAsync(serverPath)) {
+            throw new VisibleError(
+              `TanStack Start server bundle not found at:
+  "${serverPath}".`
+            );
+          }
+          if (!await existsAsync(assetsPath)) {
+            throw new VisibleError(
+              `TanStack Start assets directory not found at:
+  "${assetsPath}".`
+            );
+          }
+          return {
+            server: toPlanPath(serverPath),
+            assets: toPlanPath(assetsPath)
+          };
+        }
+        for (const serverFile of ["index.js", "index.mjs"]) {
+          const serverPath = path10.join(
+            outputPath2,
+            "dist",
+            "server",
+            serverFile
+          );
+          const assetsPath = path10.join(outputPath2, "dist", "client");
+          if (await existsAsync(serverPath) && await existsAsync(assetsPath)) {
+            return {
+              server: toPlanPath(serverPath),
+              assets: toPlanPath(assetsPath)
+            };
+          }
+        }
+      }
+      async function resolveLegacyPlan() {
+        const serverPath = path10.join(
+          outputPath2,
+          ".output",
+          "server",
+          "index.mjs"
+        );
+        const assetsPath = path10.join(outputPath2, ".output", "public");
+        if (!await existsAsync(serverPath)) return;
+        if (!await existsAsync(assetsPath)) {
+          throw new VisibleError(
+            `TanStack Start assets directory not found at:
+  "${path10.resolve(
+              assetsPath
+            )}".`
+          );
+        }
+        return {
+          server: toPlanPath(serverPath),
+          assets: toPlanPath(assetsPath)
+        };
+      }
+      function toPlanPath(filePath) {
+        const relativePath = path10.relative(outputPath2, filePath);
+        return `./${relativePath.split(path10.sep).join("/")}`;
+      }
+    });
+  }
+  buildWrangler() {
+    return {
+      main: "@tanstack/react-start/server-entry"
+    };
+  }
+  /**
+   * The URL of the TanStack Start app.
+   *
+   * If the `domain` is set, this is the URL with the custom domain.
+   * Otherwise, it's the auto-generated Worker URL.
+   */
+  get url() {
+    return super.url;
+  }
+};
+var __pulumiType16 = "sst:cloudflare:TanStackStart";
+TanStackStart.__pulumiType = __pulumiType16;
+
+// platform/src/components/cloudflare/workflow.ts
+import * as cf2 from "@pulumi/cloudflare";
+var Workflow2 = class extends Component {
+  worker;
+  workflow;
+  constructor(name, args, opts) {
+    super(__pulumiType17, name, args, opts);
+    const parent = this;
+    const worker = createWorker();
+    const workflow = createWorkflow();
+    this.worker = worker;
+    this.workflow = workflow;
+    function createWorker() {
+      return new Worker(
+        ...transform(
+          args.transform?.worker,
+          `${name}Script`,
+          {
+            handler: args.handler,
+            link: args.link,
+            environment: args.environment
+          },
+          { parent }
+        )
+      );
+    }
+    function createWorkflow() {
+      return new cf2.Workflow(
+        ...transform(
+          args.transform?.workflow,
+          `${name}Workflow`,
+          {
+            accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+            workflowName: "",
+            className: args.className,
+            scriptName: worker.nodes.worker.scriptName
+          },
+          { parent }
+        )
+      );
+    }
+  }
+  /**
+   * The name of the Cloudflare Workflow.
+   */
+  get workflowName() {
+    return this.workflow.workflowName;
+  }
+  /**
+   * The name of the workflow class.
+   */
+  get className() {
+    return this.workflow.className;
+  }
+  /**
+   * The name of the Worker script that hosts the workflow class.
+   */
+  get scriptName() {
+    return this.workflow.scriptName;
+  }
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  get nodes() {
+    return {
+      /**
+       * The Cloudflare Worker that hosts the workflow class.
+       */
+      worker: this.worker,
+      /**
+       * The Cloudflare Workflow resource.
+       */
+      workflow: this.workflow
+    };
+  }
+  /**
+   * When you link a workflow to a worker, it automatically creates a
+   * [Workflow binding](https://developers.cloudflare.com/workflows/build/workers-api/#call-workflows-from-workers)
+   * on the worker. This lets you trigger, inspect, and manage workflow instances
+   * from your worker code.
+   *
+   * @example
+   * ```ts title="src/api.ts"
+   * import { Resource } from "sst";
+   *
+   * const instance = await Resource.MyWorkflow.create({ params: { hello: "world" } });
+   * ```
+   *
+   * @internal
+   */
+  getSSTLink() {
+    return {
+      properties: {
+        workflowName: this.workflow.workflowName,
+        className: this.workflow.className,
+        scriptName: this.workflow.scriptName
+      },
+      include: [
+        binding({
+          type: "workflowBindings",
+          properties: {
+            workflowName: this.workflow.workflowName,
+            className: this.workflow.className,
+            scriptName: this.workflow.scriptName
+          }
+        })
+      ]
+    };
+  }
+};
+var __pulumiType17 = "sst:cloudflare:Workflow";
+Workflow2.__pulumiType = __pulumiType17;
+
+// platform/src/components/cloudflare/rate-limit.ts
+import {
+  output as output12
+} from "@pulumi/pulumi";
+var RateLimit = class extends Component {
+  _namespaceId;
+  _limit;
+  _period;
+  constructor(name, args, opts) {
+    super(__pulumiType18, name, args, opts);
+    const namespaceId = normalizeNamespaceId();
+    const limit = output12(args.limit);
+    const period = normalizePeriod();
+    this._namespaceId = namespaceId;
+    this._limit = limit;
+    this._period = period;
+    function normalizeNamespaceId() {
+      return output12(args.namespaceId).apply((namespaceId2) => {
+        if (!Number.isInteger(namespaceId2) || namespaceId2 <= 0) {
+          throw new VisibleError(
+            "The `namespaceId` property must be a positive integer."
+          );
+        }
+        return namespaceId2.toString();
+      });
+    }
+    function normalizePeriod() {
+      return output12(args.period).apply(toSeconds);
+    }
+  }
+  /**
+   * A unique identifier for the rate limit namespace.
+   */
+  get namespaceId() {
+    return this._namespaceId;
+  }
+  /**
+   * The number of allowed requests within the specified period of time.
+   */
+  get limit() {
+    return this._limit;
+  }
+  /**
+   * The duration of the rate limit window, in seconds.
+   */
+  get period() {
+    return this._period;
+  }
+  /**
+   * When you link a RateLimit binding, it will be available to the worker and you can
+   * interact with it using its [API methods](https://developers.cloudflare.com/workers/runtime-apis/bindings/rate-limit/).
+   *
+   * @example
+   * ```ts title="index.ts"
+   * import { Resource } from "sst/resource";
+   *
+   * export default {
+   *   async fetch(req, env): Promise<Response> {
+   *     const url = new URL(req.url);
+   *
+   *     const outcome = await Resource.MyRateLimit.limit({ key: url.pathname });
+   *     if (!outcome.success) {
+   *       return new Response(`Rate limit exceeded for ${url.pathname}`, { status: 429 });
+   *     }
+   *
+   *     return new Response("OK", { status: 200 });
+   *   }
+   * }
+   * ```
+   *
+   * @internal
+   */
+  getSSTLink() {
+    return {
+      properties: {},
+      include: [
+        binding({
+          type: "rateLimitBindings",
+          properties: {
+            namespaceId: this._namespaceId,
+            simple: {
+              limit: this._limit,
+              period: this._period
+            }
+          }
+        })
+      ]
+    };
+  }
+};
+var __pulumiType18 = "sst:cloudflare:RateLimit";
+RateLimit.__pulumiType = __pulumiType18;
+
+// platform/src/components/cloudflare/experimental/index.ts
+var experimental_exports = {};
+__export(experimental_exports, {
+  Astro: () => Astro,
+  SolidStart: () => SolidStart,
+  StaticSite: () => StaticSiteV2
+});
+
+// platform/src/components/cloudflare/experimental/solid-start.ts
+import fs11 from "fs/promises";
+import path11 from "path";
+var SolidStart = class extends SsrSite {
+  constructor(name, args = {}, opts = {}) {
+    super(__pulumiType19, name, args, opts);
+  }
+  buildPlan(outputPath) {
+    return outputPath.apply(async (outputPath2) => {
+      const nitro = JSON.parse(
+        await fs11.readFile(
+          path11.join(outputPath2, ".output", "nitro.json"),
+          "utf-8"
+        )
+      );
+      if (!["cloudflare-module"].includes(nitro.preset)) {
+        throw new VisibleError(
+          `SolidStart's nitro.config.ts must be configured to use the "cloudflare-module" preset. It is currently set to "${nitro.preset}".`
+        );
+      }
+      if (!await existsAsync(
+        path11.join(outputPath2, ".output", "server", "index.mjs")
+      )) {
+        throw new VisibleError(
+          `SSR server bundle "index.mjs" not found in the build output at:
+  "${path11.resolve(outputPath2, ".output", "server")}".
+
+If your SolidStart project is entirely pre-rendered, use the \`sst.cloudflare.StaticSite\` component instead of \`sst.cloudflare.SolidStart\`.`
+        );
+      }
+      const ignorePath = path11.join(outputPath2, ".output", ".assetsignore");
+      const ignorePatterns = await existsAsync(ignorePath) ? (await fs11.readFile(ignorePath, "utf-8")).split("\n") : [];
+      let dirty = false;
+      ["server"].forEach((pattern) => {
+        if (ignorePatterns.includes(pattern)) return;
+        ignorePatterns.push(pattern);
+        dirty = true;
+      });
+      if (dirty) {
+        await fs11.appendFile(ignorePath, "\nserver");
+      }
+      return {
+        server: "./.output/server/index.mjs",
+        assets: "./.output/public"
+      };
+    });
+  }
+  /**
+   * The URL of the SolidStart app.
+   *
+   * If the `domain` is set, this is the URL with the custom domain.
+   * Otherwise, it's the auto-generated Worker URL.
+   */
+  get url() {
+    return super.url;
+  }
+};
+var __pulumiType19 = "sst:cloudflare:SolidStart";
+SolidStart.__pulumiType = __pulumiType19;
+export {
+  Ai,
+  Astro,
+  Auth,
+  Bucket,
+  Cron,
+  D1,
+  DEFAULT_ACCOUNT_ID,
+  DurableObject,
+  Hyperdrive,
+  Kv,
+  Queue2 as Queue,
+  RateLimit,
+  ReactRouter,
+  StaticSite,
+  StaticSiteV2,
+  TanStackStart,
+  Worker,
+  Workflow2 as Workflow,
+  binding,
+  dns,
+  experimental_exports as x
+};
+//# sourceMappingURL=index.js.map