@cloudflare/deploy-helpers 0.2.1 → 0.2.2

package/dist/index.mjs

@@ -1,16 +1,16 @@
-import { __commonJS, __name, __require, __toESM, fetchListResult, logger, fetchResult, confirm, fetchPagedListResult, prompt, isNonInteractiveOrCI } from './chunk-NAAB7FBS.mjs';
-export { initDeployHelpersContext } from './chunk-NAAB7FBS.mjs';
+import { __commonJS, __name, __require, __toESM, fetchResult, fetchListResult, logger, confirm, fetchPagedListResult, prompt, isNonInteractiveOrCI, select } from './chunk-N72KNDFF.mjs';
+export { initDeployHelpersContext } from './chunk-N72KNDFF.mjs';
 import * as path3 from 'node:path';
 import path3__default, { resolve, isAbsolute, dirname, join, extname, sep } from 'node:path';
 import fs2, { readFileSync, statSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import * as z from 'zod';
 import { z as z$1 } from 'zod';
-import assert6 from 'node:assert';
+import assert5 from 'node:assert';
 import url, { URLSearchParams as URLSearchParams$1 } from 'node:url';
 import * as cli from '@cloudflare/cli-shared-helpers';
 import { cancel } from '@cloudflare/cli-shared-helpers';
-import { getEnvironmentVariableFactory, getHostFromRoute, retryOnAPIFailure, UserError as UserError$1, ParseError as ParseError$1, getComplianceRegionSubdomain, configFileName as configFileName$1, formatTime, getSubdomainMixedStateCheckDisabled, LOGGER_LEVELS, APIError, INHERIT_SYMBOL, COMPLIANCE_REGION_CONFIG_UNKNOWN, constructWranglerConfig, SERVICE_TAG_PREFIX, ENVIRONMENT_TAG_PREFIX, getWranglerTmpDir, getCIMatchTag, FatalError as FatalError$1, formatConfigSnippet as formatConfigSnippet$1, readFileSync as readFileSync$2, parseJSON as parseJSON$1, getBindingTypeFriendlyName, getBindingLocalSupport, assertNever as assertNever$1, experimental_patchConfig, getTodaysCompatDate, getDockerPath, parseNonHyphenedUuid as parseNonHyphenedUuid$1, getWorkersCIBranchName } from '@cloudflare/workers-utils';
+import { getEnvironmentVariableFactory, INHERIT_SYMBOL, APIError, UserError as UserError$1, getHostFromRoute, retryOnAPIFailure, ParseError as ParseError$1, getComplianceRegionSubdomain, configFileName as configFileName$1, formatTime, getSubdomainMixedStateCheckDisabled, LOGGER_LEVELS, COMPLIANCE_REGION_CONFIG_UNKNOWN, constructWranglerConfig, SERVICE_TAG_PREFIX, ENVIRONMENT_TAG_PREFIX, getWranglerTmpDir, getCIMatchTag, FatalError as FatalError$1, formatConfigSnippet as formatConfigSnippet$1, readFileSync as readFileSync$2, parseJSON as parseJSON$1, getBindingTypeFriendlyName, getBindingLocalSupport, assertNever as assertNever$1, experimental_readRawConfig, experimental_patchConfig, PatchConfigError, getTodaysCompatDate, getDockerPath, parseNonHyphenedUuid as parseNonHyphenedUuid$1, getWorkersCIBranchName } from '@cloudflare/workers-utils';
 import { spawnSync, execSync, spawn } from 'node:child_process';
 import { FormData, Response } from 'undici';
 import chalk5 from 'chalk';
@@ -703,10 +703,10 @@ var require_heap2 = __commonJS({
 var require_difflib = __commonJS({
   "../../node_modules/.pnpm/@ewoudenberg+difflib@0.1.0/node_modules/@ewoudenberg/difflib/lib/difflib.js"(exports) {
     (function() {
-      var Differ, Heap, IS_CHARACTER_JUNK, IS_LINE_JUNK, SequenceMatcher, _any, _arrayCmp, _calculateRatio, _countLeading, _formatRangeContext, _formatRangeUnified, _has, assert8, contextDiff, floor, getCloseMatches, max, min, ndiff, restore, unifiedDiff, indexOf = [].indexOf;
+      var Differ, Heap, IS_CHARACTER_JUNK, IS_LINE_JUNK, SequenceMatcher, _any, _arrayCmp, _calculateRatio, _countLeading, _formatRangeContext, _formatRangeUnified, _has, assert9, contextDiff, floor, getCloseMatches, max, min, ndiff, restore, unifiedDiff, indexOf = [].indexOf;
       ({ floor, max, min } = Math);
       Heap = require_heap2();
-      assert8 = __require("assert");
+      assert9 = __require("assert");
       _calculateRatio = /* @__PURE__ */ __name(function(matches, length) {
         if (length) {
           return 2 * matches / length;
@@ -1277,7 +1277,7 @@ var require_difflib = __commonJS({
         }
         _plainReplace(a, alo, ahi, b, blo, bhi) {
           var first, g, l, len, len1, line, lines, m, ref, second;
-          assert8(alo < ahi && blo < bhi);
+          assert9(alo < ahi && blo < bhi);
           if (bhi - blo < ahi - alo) {
             first = this._dump("+", b, blo, bhi);
             second = this._dump("-", a, alo, ahi);
@@ -9007,7 +9007,7 @@ var MAX_UPLOAD_ATTEMPTS = 5;
 var MAX_UPLOAD_GATEWAY_ERRORS = 5;
 var MAX_DIFF_LINES = 100;
 var syncAssets = /* @__PURE__ */ __name(async (complianceConfig, accountId, assetDirectory, scriptName, dispatchNamespace) => {
-  assert6(accountId, "Missing accountId");
+  assert5(accountId, "Missing accountId");
   logger.info("\u{1F300} Building list of assets...");
   const manifest = await buildAssetManifest(assetDirectory);
   const url2 = dispatchNamespace ? `/accounts/${accountId}/workers/dispatch/namespaces/${dispatchNamespace}/scripts/${scriptName}/assets-upload-session` : `/accounts/${accountId}/workers/scripts/${scriptName}/assets-upload-session`;
@@ -10280,10 +10280,10 @@ function populateConfigPatch(diff, patchObj, targetEnvironment) {
     return;
   }
   if (Array.isArray(diff)) {
-    assert6(Array.isArray(patchObj));
+    assert5(Array.isArray(patchObj));
     return populateConfigPatchArray(diff, patchObj);
   }
-  assert6(!Array.isArray(patchObj));
+  assert5(!Array.isArray(patchObj));
   return populateConfigPatchObject(diff, patchObj, targetEnvironment);
 }
 __name(populateConfigPatch, "populateConfigPatch");
@@ -11150,7 +11150,7 @@ function createWorkerUploadForm(worker, bindings, options) {
   const manifestModuleName = "__STATIC_CONTENT_MANIFEST";
   const hasManifest = modules?.some(({ name }) => name === manifestModuleName);
   if (hasManifest && main.type === "esm") {
-    assert6(modules !== void 0);
+    assert5(modules !== void 0);
     const subDirs = new Set(
       modules.map((module) => path3__default.posix.dirname(module.name))
     );
@@ -11384,7 +11384,7 @@ async function downloadWorkerConfig(workerName, environment, entrypoint, account
 __name(downloadWorkerConfig, "downloadWorkerConfig");
 async function getMigrationsToUpload(scriptName, props) {
   const { config, accountId } = props;
-  assert6(accountId, "Missing accountId");
+  assert5(accountId, "Missing accountId");
   let migrations;
   if (config.migrations.length > 0) {
     let script;
@@ -12650,6 +12650,875 @@ function warnOrError(type, remote) {
   }
 }
 __name(warnOrError, "warnOrError");
+var ProvisionResourceHandler = class {
+  constructor(type, bindingName, binding, idField, complianceConfig, accountId) {
+    this.type = type;
+    this.bindingName = bindingName;
+    this.binding = binding;
+    this.idField = idField;
+    this.complianceConfig = complianceConfig;
+    this.accountId = accountId;
+  }
+  static {
+    __name(this, "ProvisionResourceHandler");
+  }
+  inherit() {
+    this.binding[this.idField] = INHERIT_SYMBOL;
+  }
+  connect(id) {
+    this.binding[this.idField] = id;
+  }
+  async provision(name) {
+    const id = await this.create(name);
+    this.connect(id);
+  }
+  // This binding is fully specified and can't/shouldn't be provisioned.
+  // This is usually when it has an id (e.g. D1 `database_id`).
+  isFullySpecified() {
+    return false;
+  }
+  // Does this binding need to be provisioned?
+  // Some bindings are not fully specified, but don't need provisioning
+  // (e.g. R2 binding, with a bucket_name that already exists).
+  async isConnectedToExistingResource() {
+    return false;
+  }
+  // Should this resource be provisioned?
+  async shouldProvision(settings) {
+    if (!this.isFullySpecified()) {
+      if (await this.canInherit(settings)) {
+        this.inherit();
+      } else {
+        const connected = await this.isConnectedToExistingResource();
+        if (connected) {
+          if (typeof connected === "string") {
+            this.connect(connected);
+          }
+          return false;
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+};
+var R2Handler = class extends ProvisionResourceHandler {
+  static {
+    __name(this, "R2Handler");
+  }
+  get name() {
+    return this.binding.bucket_name;
+  }
+  async create(name) {
+    await createR2Bucket(
+      this.complianceConfig,
+      this.accountId,
+      name,
+      void 0,
+      this.binding.jurisdiction
+    );
+    return name;
+  }
+  constructor(bindingName, binding, complianceConfig, accountId) {
+    super(
+      "r2_bucket",
+      bindingName,
+      binding,
+      "bucket_name",
+      complianceConfig,
+      accountId
+    );
+  }
+  /**
+   * Inheriting an R2 binding replaces the id property (bucket_name for R2) with the inheritance symbol.
+   * This works when deploying (and is appropriate for all other binding types), but it means that the
+   * bucket_name for an R2 bucket is not displayed when deploying. As such, only use the inheritance symbol
+   * if the R2 binding has no `bucket_name`.
+   */
+  inherit() {
+    this.binding.bucket_name ??= INHERIT_SYMBOL;
+  }
+  /**
+   * R2 bindings can be inherited if the binding name and jurisdiction match.
+   * Additionally, if the user has specified a bucket_name in config, make sure that matches.
+   */
+  canInherit(settings) {
+    return !!settings?.bindings.find(
+      (existing) => existing.type === this.type && existing.name === this.bindingName && existing.jurisdiction === this.binding.jurisdiction && (this.binding.bucket_name ? this.binding.bucket_name === existing.bucket_name : true)
+    );
+  }
+  async isConnectedToExistingResource() {
+    assert5(typeof this.binding.bucket_name !== "symbol");
+    if (!this.binding.bucket_name) {
+      return false;
+    }
+    try {
+      await getR2Bucket(
+        this.complianceConfig,
+        this.accountId,
+        this.binding.bucket_name,
+        this.binding.jurisdiction
+      );
+      return true;
+    } catch (e) {
+      if (!(e instanceof APIError && e.code === 10006)) {
+        throw e;
+      }
+      return false;
+    }
+  }
+};
+var AISearchNamespaceHandler = class extends ProvisionResourceHandler {
+  static {
+    __name(this, "AISearchNamespaceHandler");
+  }
+  get name() {
+    return this.binding.namespace;
+  }
+  async create(name) {
+    await createAISearchNamespace(this.complianceConfig, this.accountId, name);
+    return name;
+  }
+  constructor(bindingName, binding, complianceConfig, accountId) {
+    super(
+      "ai_search_namespace",
+      bindingName,
+      binding,
+      "namespace",
+      complianceConfig,
+      accountId
+    );
+  }
+  canInherit(settings) {
+    return !!settings?.bindings.find(
+      (existing) => existing.type === this.type && existing.name === this.bindingName && (this.binding.namespace ? this.binding.namespace === existing.namespace : true)
+    );
+  }
+  async isConnectedToExistingResource() {
+    assert5(typeof this.binding.namespace !== "symbol");
+    if (!this.binding.namespace) {
+      return false;
+    }
+    const namespace = await getAISearchNamespace(
+      this.complianceConfig,
+      this.accountId,
+      this.binding.namespace
+    );
+    return namespace !== null;
+  }
+};
+var AgentMemoryNamespaceHandler = class extends ProvisionResourceHandler {
+  static {
+    __name(this, "AgentMemoryNamespaceHandler");
+  }
+  get name() {
+    return this.binding.namespace;
+  }
+  async create(name) {
+    await createAgentMemoryNamespace(
+      this.complianceConfig,
+      this.accountId,
+      name
+    );
+    return name;
+  }
+  constructor(bindingName, binding, complianceConfig, accountId) {
+    super(
+      "agent_memory",
+      bindingName,
+      binding,
+      "namespace",
+      complianceConfig,
+      accountId
+    );
+  }
+  canInherit(settings) {
+    return !!settings?.bindings.find(
+      (existing) => existing.type === this.type && existing.name === this.bindingName && (this.binding.namespace ? this.binding.namespace === existing.namespace : true)
+    );
+  }
+  async isConnectedToExistingResource() {
+    assert5(typeof this.binding.namespace !== "symbol");
+    if (!this.binding.namespace) {
+      return false;
+    }
+    const namespace = await getAgentMemoryNamespace(
+      this.complianceConfig,
+      this.accountId,
+      this.binding.namespace
+    );
+    return namespace !== null;
+  }
+};
+var KVHandler = class extends ProvisionResourceHandler {
+  static {
+    __name(this, "KVHandler");
+  }
+  get name() {
+    return void 0;
+  }
+  async create(name) {
+    return await createKVNamespace(this.complianceConfig, this.accountId, name);
+  }
+  constructor(bindingName, binding, complianceConfig, accountId) {
+    super(
+      "kv_namespace",
+      bindingName,
+      binding,
+      "id",
+      complianceConfig,
+      accountId
+    );
+  }
+  canInherit(settings) {
+    return !!settings?.bindings.find(
+      (existing) => existing.type === this.type && existing.name === this.bindingName
+    );
+  }
+  isFullySpecified() {
+    return !!this.binding.id;
+  }
+};
+var D1Handler = class extends ProvisionResourceHandler {
+  static {
+    __name(this, "D1Handler");
+  }
+  get name() {
+    return this.binding.database_name;
+  }
+  async create(name) {
+    const db = await createD1Database(
+      this.complianceConfig,
+      this.accountId,
+      name
+    );
+    return db.uuid;
+  }
+  constructor(bindingName, binding, complianceConfig, accountId) {
+    super(
+      "d1",
+      bindingName,
+      binding,
+      "database_id",
+      complianceConfig,
+      accountId
+    );
+  }
+  async canInherit(settings) {
+    const maybeInherited = settings?.bindings.find(
+      (existing) => existing.type === this.type && existing.name === this.bindingName
+    );
+    if (maybeInherited) {
+      if (!this.binding.database_name) {
+        return true;
+      }
+      const dbFromId = await getDatabaseInfoFromIdOrName(
+        this.complianceConfig,
+        this.accountId,
+        maybeInherited.id
+      );
+      if (this.binding.database_name === dbFromId.name) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async isConnectedToExistingResource() {
+    assert5(typeof this.binding.database_name !== "symbol");
+    if (!this.binding.database_name) {
+      return false;
+    }
+    try {
+      const db = await getDatabaseInfoFromIdOrName(
+        this.complianceConfig,
+        this.accountId,
+        this.binding.database_name
+      );
+      return db.uuid;
+    } catch (e) {
+      if (!(e instanceof APIError && e.code === 7404)) {
+        throw e;
+      }
+      return false;
+    }
+  }
+  isFullySpecified() {
+    return !!this.binding.database_id;
+  }
+};
+var HANDLERS = {
+  kv_namespace: {
+    Handler: KVHandler,
+    sort: 0,
+    name: "KV Namespace",
+    keyDescription: "title or id",
+    configField: "kv_namespaces",
+    load: /* @__PURE__ */ __name(async (complianceConfig, accountId) => {
+      const preExistingKV = await listKVNamespaces(
+        complianceConfig,
+        accountId,
+        true
+      );
+      return preExistingKV.map((ns) => ({ title: ns.title, value: ns.id }));
+    }, "load"),
+    toConfig: /* @__PURE__ */ __name((bindingName, binding) => {
+      const { type: _, ...rest } = binding;
+      return {
+        ...rest,
+        binding: bindingName
+      };
+    }, "toConfig")
+  },
+  d1: {
+    Handler: D1Handler,
+    sort: 1,
+    name: "D1 Database",
+    keyDescription: "name or id",
+    configField: "d1_databases",
+    load: /* @__PURE__ */ __name(async (complianceConfig, accountId) => {
+      const preExisting = await listDatabases(
+        complianceConfig,
+        accountId,
+        true,
+        1e3
+      );
+      return preExisting.map((db) => ({ title: db.name, value: db.uuid }));
+    }, "load"),
+    toConfig: /* @__PURE__ */ __name((bindingName, binding) => {
+      const { type: _, ...rest } = binding;
+      return {
+        ...rest,
+        binding: bindingName
+      };
+    }, "toConfig")
+  },
+  r2_bucket: {
+    Handler: R2Handler,
+    sort: 2,
+    name: "R2 Bucket",
+    keyDescription: "name",
+    configField: "r2_buckets",
+    load: /* @__PURE__ */ __name(async (complianceConfig, accountId) => {
+      const preExisting = await listR2Buckets(complianceConfig, accountId);
+      return preExisting.map((bucket) => ({
+        title: bucket.name,
+        value: bucket.name
+      }));
+    }, "load"),
+    toConfig: /* @__PURE__ */ __name((bindingName, binding) => {
+      const { type: _, ...rest } = binding;
+      return {
+        ...rest,
+        binding: bindingName
+      };
+    }, "toConfig")
+  },
+  ai_search_namespace: {
+    Handler: AISearchNamespaceHandler,
+    sort: 3,
+    name: "AI Search Namespace",
+    keyDescription: "namespace name",
+    configField: "ai_search_namespaces",
+    load: /* @__PURE__ */ __name(async (_complianceConfig, _accountId) => {
+      return [];
+    }, "load"),
+    toConfig: /* @__PURE__ */ __name((bindingName, binding) => {
+      const { type: _, ...rest } = binding;
+      return {
+        ...rest,
+        binding: bindingName
+      };
+    }, "toConfig")
+  },
+  agent_memory: {
+    Handler: AgentMemoryNamespaceHandler,
+    sort: 4,
+    name: "Agent Memory",
+    keyDescription: "namespace name",
+    configField: "agent_memory",
+    load: /* @__PURE__ */ __name(async (_complianceConfig, _accountId) => {
+      return [];
+    }, "load"),
+    toConfig: /* @__PURE__ */ __name((bindingName, binding) => {
+      const { type: _, ...rest } = binding;
+      return {
+        ...rest,
+        binding: bindingName
+      };
+    }, "toConfig")
+  }
+};
+function isProvisionableBinding(binding) {
+  return binding.type in HANDLERS;
+}
+__name(isProvisionableBinding, "isProvisionableBinding");
+function createHandler(bindingName, binding, complianceConfig, accountId) {
+  switch (binding.type) {
+    case "kv_namespace":
+      return new KVHandler(bindingName, binding, complianceConfig, accountId);
+    case "d1":
+      return new D1Handler(bindingName, binding, complianceConfig, accountId);
+    case "r2_bucket":
+      return new R2Handler(bindingName, binding, complianceConfig, accountId);
+    case "ai_search_namespace":
+      return new AISearchNamespaceHandler(
+        bindingName,
+        binding,
+        complianceConfig,
+        accountId
+      );
+    case "agent_memory":
+      return new AgentMemoryNamespaceHandler(
+        bindingName,
+        binding,
+        complianceConfig,
+        accountId
+      );
+  }
+}
+__name(createHandler, "createHandler");
+function toConfigBinding(bindingName, binding) {
+  switch (binding.type) {
+    case "kv_namespace":
+      return HANDLERS.kv_namespace.toConfig(bindingName, binding);
+    case "d1":
+      return HANDLERS.d1.toConfig(bindingName, binding);
+    case "r2_bucket":
+      return HANDLERS.r2_bucket.toConfig(bindingName, binding);
+    case "ai_search_namespace":
+      return HANDLERS.ai_search_namespace.toConfig(bindingName, binding);
+    case "agent_memory":
+      return HANDLERS.agent_memory.toConfig(bindingName, binding);
+  }
+}
+__name(toConfigBinding, "toConfigBinding");
+async function collectPendingResources(complianceConfig, accountId, scriptName, bindings) {
+  let settings;
+  try {
+    settings = await getSettings(complianceConfig, accountId, scriptName);
+  } catch {
+    logger.debug("No settings found");
+  }
+  const pendingResources = [];
+  for (const [bindingName, binding] of Object.entries(bindings ?? {})) {
+    if (!isProvisionableBinding(binding)) {
+      continue;
+    }
+    const handler = createHandler(
+      bindingName,
+      binding,
+      complianceConfig,
+      accountId
+    );
+    if (await handler.shouldProvision(settings)) {
+      pendingResources.push({
+        binding: bindingName,
+        resourceType: binding.type,
+        handler
+      });
+    }
+  }
+  return pendingResources.sort(
+    (a, b) => HANDLERS[a.resourceType].sort - HANDLERS[b.resourceType].sort
+  );
+}
+__name(collectPendingResources, "collectPendingResources");
+async function provisionBindings(bindings, accountId, scriptName, autoCreate, config, options) {
+  const configPath = config.userConfigPath ?? config.configPath;
+  const pendingResources = await collectPendingResources(
+    config,
+    accountId,
+    scriptName,
+    bindings
+  );
+  if (pendingResources.length > 0) {
+    assert5(
+      configPath,
+      "Provisioning resources is not possible without a config file"
+    );
+    if (useServiceEnvironments(config)) {
+      throw new UserError$1(
+        "Provisioning resources is not supported with a service environment",
+        { telemetryMessage: "provision resources with service environment" }
+      );
+    }
+    logger.log();
+    printBindings(
+      Object.fromEntries(
+        pendingResources.map((resource) => [
+          resource.binding,
+          { type: resource.resourceType }
+        ])
+      ),
+      config.tail_consumers,
+      config.streaming_tail_consumers,
+      config.containers,
+      { provisioning: true }
+    );
+    logger.log();
+    const existingResources = {};
+    for (const resource of pendingResources) {
+      existingResources[resource.resourceType] ??= await HANDLERS[resource.resourceType].load(config, accountId);
+      await runProvisioningFlow(
+        resource,
+        existingResources[resource.resourceType],
+        HANDLERS[resource.resourceType].name,
+        scriptName,
+        autoCreate
+      );
+    }
+    const patch = {};
+    const existingBindingNames = /* @__PURE__ */ new Set();
+    const isUsingRedirectedConfig = config.userConfigPath && config.userConfigPath !== config.configPath;
+    if (isUsingRedirectedConfig) {
+      const { rawConfig: unredirectedConfig } = await experimental_readRawConfig(
+        { config: config.userConfigPath },
+        { useRedirectIfAvailable: false }
+      );
+      for (const resourceType of Object.keys(
+        HANDLERS
+      )) {
+        const configField = HANDLERS[resourceType].configField;
+        for (const binding of unredirectedConfig[configField] ?? []) {
+          existingBindingNames.add(binding.binding);
+        }
+      }
+    }
+    for (const [bindingName, binding] of Object.entries(bindings ?? {})) {
+      if (!isProvisionableBinding(binding)) {
+        continue;
+      }
+      if (isUsingRedirectedConfig && !existingBindingNames.has(bindingName)) {
+        continue;
+      }
+      const resourceType = HANDLERS[binding.type].configField;
+      patch[resourceType] ??= [];
+      const bindingToWrite = toConfigBinding(bindingName, binding);
+      patch[resourceType].push(
+        Object.fromEntries(
+          Object.entries(bindingToWrite).filter(
+            // Make sure all the values are JSON serialisable.
+            // Otherwise we end up with "undefined" in the config.
+            ([_, value]) => typeof value === "string"
+          )
+        )
+      );
+    }
+    if (options.skipConfigWriteback) {
+      logger.log(
+        "Your Worker was deployed with provisioned resources. You may add the resource IDs to your config file if you wish, but future deploys will continue to work even without IDs."
+      );
+    } else if (!isNonInteractiveOrCI()) {
+      try {
+        await experimental_patchConfig(configPath, patch, false);
+        logger.log(
+          "Your Worker was deployed with provisioned resources. We've written the IDs of these resources to your config file, which you can choose to save or discard. Either way future deploys will continue to work."
+        );
+      } catch (e) {
+        if (!(e instanceof PatchConfigError)) {
+          throw e;
+        }
+      }
+    }
+    logger.log(`\u{1F389} All resources provisioned, continuing with deployment...
+`);
+  }
+}
+__name(provisionBindings, "provisionBindings");
+function getSettings(complianceConfig, accountId, scriptName) {
+  return fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/workers/scripts/${scriptName}/settings`
+  );
+}
+__name(getSettings, "getSettings");
+function printDivider() {
+  logger.log();
+}
+__name(printDivider, "printDivider");
+async function runProvisioningFlow(item, preExisting, friendlyBindingName, scriptName, autoCreate) {
+  const NEW_OPTION_VALUE = "__WRANGLER_INTERNAL_NEW";
+  const SEARCH_OPTION_VALUE = "__WRANGLER_INTERNAL_SEARCH";
+  const MAX_OPTIONS = 4;
+  const options = preExisting.slice(0, MAX_OPTIONS - 1);
+  if (options.length < preExisting.length) {
+    options.push({
+      title: "Other (too many to list)",
+      value: SEARCH_OPTION_VALUE
+    });
+  }
+  const defaultName = autoProvisionedResourceName(scriptName, item.binding);
+  logger.log("Provisioning", item.binding, `(${friendlyBindingName})...`);
+  if (item.handler.name) {
+    logger.log("Resource name found in config:", item.handler.name);
+    logger.log(
+      `\u{1F300} Creating new ${friendlyBindingName} "${item.handler.name}"...`
+    );
+    await item.handler.provision(item.handler.name);
+  } else if (autoCreate) {
+    logger.log(`\u{1F300} Creating new ${friendlyBindingName} "${defaultName}"...`);
+    await item.handler.provision(defaultName);
+  } else {
+    let action = NEW_OPTION_VALUE;
+    if (options.length > 0) {
+      action = await select(
+        `Would you like to connect an existing ${friendlyBindingName} or create a new one?`,
+        {
+          choices: options.concat([
+            { title: "Create new", value: NEW_OPTION_VALUE }
+          ]),
+          defaultOption: options.length,
+          fallbackOption: options.length
+        }
+      );
+    }
+    if (action === NEW_OPTION_VALUE) {
+      const name = await prompt(
+        `Enter a name for your new ${friendlyBindingName}`,
+        {
+          defaultValue: defaultName
+        }
+      );
+      logger.log(`\u{1F300} Creating new ${friendlyBindingName} "${name}"...`);
+      await item.handler.provision(name);
+    } else if (action === SEARCH_OPTION_VALUE) {
+      let foundResource;
+      while (foundResource === void 0) {
+        const input = await prompt(
+          `Enter the ${HANDLERS[item.resourceType].keyDescription} for an existing ${friendlyBindingName}`
+        );
+        foundResource = preExisting.find(
+          (resource) => resource.title === input || resource.value === input
+        );
+        if (foundResource) {
+          item.handler.connect(foundResource.value);
+        } else {
+          logger.log(
+            `No ${friendlyBindingName} with that ${HANDLERS[item.resourceType].keyDescription} "${input}" found. Please try again.`
+          );
+        }
+      }
+    } else {
+      item.handler.connect(action);
+    }
+  }
+  logger.log(`\u2728 ${item.binding} provisioned \u{1F389}`);
+  printDivider();
+}
+__name(runProvisioningFlow, "runProvisioningFlow");
+function autoProvisionedResourceName(scriptName, bindingName) {
+  return `${scriptName}-${bindingName.toLowerCase().replaceAll("_", "-")}`;
+}
+__name(autoProvisionedResourceName, "autoProvisionedResourceName");
+async function createKVNamespace(complianceConfig, accountId, title) {
+  const response = await fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/storage/kv/namespaces`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        title
+      })
+    }
+  );
+  return response.id;
+}
+__name(createKVNamespace, "createKVNamespace");
+async function listKVNamespaces(complianceConfig, accountId, limitCalls = false) {
+  const pageSize = 100;
+  let page = 1;
+  const results = [];
+  while (results.length % pageSize === 0) {
+    const json2 = await fetchResult(
+      complianceConfig,
+      `/accounts/${accountId}/storage/kv/namespaces`,
+      {},
+      new URLSearchParams({
+        per_page: pageSize.toString(),
+        order: "title",
+        direction: "asc",
+        page: page.toString()
+      })
+    );
+    page++;
+    results.push(...json2);
+    if (limitCalls) {
+      break;
+    }
+    if (json2.length < pageSize) {
+      break;
+    }
+  }
+  return results;
+}
+__name(listKVNamespaces, "listKVNamespaces");
+async function createD1Database(complianceConfig, accountId, name) {
+  try {
+    return await fetchResult(
+      complianceConfig,
+      `/accounts/${accountId}/d1/database`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ name })
+      }
+    );
+  } catch (e) {
+    const errorCode = e.code;
+    if (errorCode === 7502) {
+      throw new UserError$1("A database with that name already exists", {
+        telemetryMessage: "d1 create database already exists"
+      });
+    }
+    if (errorCode === 7406) {
+      throw new UserError$1(
+        "You have reached the maximum number of D1 databases for your account. Please consider deleting unused databases, or visit the D1 documentation to learn more: https://developers.cloudflare.com/d1/",
+        { telemetryMessage: "d1 create database limit reached" }
+      );
+    }
+    throw e;
+  }
+}
+__name(createD1Database, "createD1Database");
+async function listDatabases(complianceConfig, accountId, limitCalls = false, pageSize = 10) {
+  let page = 1;
+  const results = [];
+  while (results.length % pageSize === 0) {
+    const json2 = await fetchResult(
+      complianceConfig,
+      `/accounts/${accountId}/d1/database`,
+      {},
+      new URLSearchParams({
+        per_page: pageSize.toString(),
+        page: page.toString()
+      })
+    );
+    page++;
+    results.push(...json2);
+    if (limitCalls && page > 3) {
+      break;
+    }
+    if (json2.length < pageSize) {
+      break;
+    }
+  }
+  return results;
+}
+__name(listDatabases, "listDatabases");
+async function getDatabaseInfoFromIdOrName(complianceConfig, accountId, databaseIdOrName) {
+  return await fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/d1/database/${databaseIdOrName}`,
+    {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    }
+  );
+}
+__name(getDatabaseInfoFromIdOrName, "getDatabaseInfoFromIdOrName");
+async function listR2Buckets(complianceConfig, accountId, jurisdiction) {
+  const headers = {};
+  if (jurisdiction !== void 0) {
+    headers["cf-r2-jurisdiction"] = jurisdiction;
+  }
+  const results = await fetchResult(complianceConfig, `/accounts/${accountId}/r2/buckets`, { headers });
+  return results.buckets;
+}
+__name(listR2Buckets, "listR2Buckets");
+async function getR2Bucket(complianceConfig, accountId, bucketName, jurisdiction) {
+  const headers = {};
+  if (jurisdiction !== void 0) {
+    headers["cf-r2-jurisdiction"] = jurisdiction;
+  }
+  return await fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/r2/buckets/${bucketName}`,
+    {
+      method: "GET",
+      headers
+    }
+  );
+}
+__name(getR2Bucket, "getR2Bucket");
+async function createR2Bucket(complianceConfig, accountId, bucketName, location, jurisdiction, storageClass) {
+  const headers = {};
+  if (jurisdiction !== void 0) {
+    headers["cf-r2-jurisdiction"] = jurisdiction;
+  }
+  return await fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/r2/buckets`,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        name: bucketName,
+        ...storageClass !== void 0 && { storageClass },
+        ...location !== void 0 && { locationHint: location }
+      }),
+      headers
+    }
+  );
+}
+__name(createR2Bucket, "createR2Bucket");
+async function getAISearchNamespace(complianceConfig, accountId, namespaceName) {
+  try {
+    return await fetchResult(
+      complianceConfig,
+      `/accounts/${accountId}/ai-search/namespaces/${namespaceName}`,
+      { method: "GET" }
+    );
+  } catch (e) {
+    if (e instanceof APIError && e.status === 404) {
+      return null;
+    }
+    throw e;
+  }
+}
+__name(getAISearchNamespace, "getAISearchNamespace");
+async function createAISearchNamespace(complianceConfig, accountId, namespaceName) {
+  await fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/ai-search/namespaces`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: namespaceName })
+    }
+  );
+}
+__name(createAISearchNamespace, "createAISearchNamespace");
+async function getAgentMemoryNamespace(complianceConfig, accountId, namespaceName) {
+  try {
+    return await fetchResult(
+      complianceConfig,
+      `/accounts/${accountId}/agent-memory/namespaces/${namespaceName}`
+    );
+  } catch (e) {
+    if (e instanceof APIError && e.status === 404) {
+      return null;
+    }
+    throw e;
+  }
+}
+__name(getAgentMemoryNamespace, "getAgentMemoryNamespace");
+async function createAgentMemoryNamespace(complianceConfig, accountId, namespaceName) {
+  await fetchResult(
+    complianceConfig,
+    `/accounts/${accountId}/agent-memory/namespaces`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: namespaceName })
+    }
+  );
+}
+__name(createAgentMemoryNamespace, "createAgentMemoryNamespace");
 
 // src/deploy/helpers/error-codes.ts
 var INVALID_INHERIT_BINDING_CODE = 10057;
@@ -12808,7 +13677,7 @@ function getSourceMappingPrepareStackTrace(retrieveSourceMap) {
     }
   });
   sourceMappingPrepareStackTrace = Error.prepareStackTrace;
-  assert6(sourceMappingPrepareStackTrace !== void 0);
+  assert5(sourceMappingPrepareStackTrace !== void 0);
   Error.prepareStackTrace = originalPrepareStackTrace;
   return sourceMappingPrepareStackTrace;
 }
@@ -12839,23 +13708,38 @@ function callFrameToCallSite(frame) {
   });
 }
 __name(callFrameToCallSite, "callFrameToCallSite");
+function tryPrepareStack(prepareStack, error, callSites) {
+  try {
+    return prepareStack(error, callSites);
+  } catch (err) {
+    logger?.debug(
+      `Source map application failed, falling back to original stack trace: ${err}`
+    );
+    return null;
+  }
+}
+__name(tryPrepareStack, "tryPrepareStack");
 var placeholderError = new Error();
 function getSourceMappedString(value, retrieveSourceMap) {
   const callSiteLines = Array.from(value.matchAll(CALL_SITE_REGEXP));
   const callSites = callSiteLines.map(lineMatchToCallSite);
   const prepareStack = getSourceMappingPrepareStackTrace(retrieveSourceMap);
-  const sourceMappedStackTrace = prepareStack(
+  const sourceMappedStackTrace = tryPrepareStack(
+    prepareStack,
     placeholderError,
     callSites
   );
+  if (sourceMappedStackTrace === null) {
+    return value;
+  }
   const sourceMappedCallSiteLines = sourceMappedStackTrace.split("\n").slice(1);
   for (let i = 0; i < callSiteLines.length; i++) {
-    if (callSites[i].getFileName() === void 0) {
+    if (callSites[i].getFileName() === null) {
       continue;
     }
     const callSiteLine = callSiteLines[i][0];
     const callSiteAtIndex = callSiteLine.indexOf("at");
-    assert6(callSiteAtIndex !== -1);
+    assert5(callSiteAtIndex !== -1);
     const callSiteLineLeftPad = callSiteLine.substring(0, callSiteAtIndex);
     value = value.replace(
       callSiteLine,
@@ -13080,7 +13964,7 @@ async function deploy(props, config, buildResult, callbacks) {
   } = props;
   const assetsOptions = resolveAssetOptions(props, config);
   if (!props.dryRun) {
-    assert6(accountId, "Missing account ID");
+    assert5(accountId, "Missing account ID");
     await verifyWorkerMatchesCITag(config, accountId, name, config.configPath);
   }
   const deployConfirm = getDeployConfirmFunction({
@@ -13194,7 +14078,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
   }
   validateRoutes(allDeploymentRoutes, assetsOptions);
   const scriptName = name;
-  assert6(
+  assert5(
     !config.site || config.site.bucket,
     "A [site] definition requires a `bucket` field with a path to the site's assets directory."
   );
@@ -13410,16 +14294,19 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
       { warnIfNoBindings: true, unsafeMetadata: config.unsafe?.metadata }
     );
   } else {
-    assert6(accountId, "Missing accountId");
+    assert5(accountId, "Missing accountId");
     if (assetsOptions?.routerConfig.has_user_worker === false) {
       logger.debug("skipping provisioning on assets-only project");
-    } else if (props.resourcesProvision && callbacks.provisionBindings) {
-      await callbacks.provisionBindings(
+    } else if (props.resourcesProvision) {
+      await provisionBindings(
         bindings ?? {},
         accountId,
         scriptName,
         props.experimentalAutoCreate,
-        config
+        config,
+        {
+          skipConfigWriteback: props.skipProvisioningConfigWriteback
+        }
       );
     }
     workerBundle = createWorkerUploadForm(
@@ -13616,7 +14503,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
   const uploadMs = Date.now() - start;
   logger.log("Uploaded", workerName, formatTime(uploadMs));
   if (normalisedContainerConfig.length && props.containersRollout !== "none" && callbacks.deployContainers) {
-    assert6(versionId && accountId);
+    assert5(versionId && accountId);
     await callbacks.deployContainers(config, normalisedContainerConfig, {
       versionId,
       accountId,
@@ -13627,7 +14514,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     deployWfpUserWorker(props.dispatchNamespace, versionId);
     return { versionId, workerTag };
   }
-  assert6(accountId);
+  assert5(accountId);
   const targets = await triggersDeploy({
     config,
     accountId,
@@ -13664,7 +14551,7 @@ async function versionsUpload(props, config, buildResult, callbacks) {
   } = props;
   const assetsOptions = resolveAssetOptions(props, config);
   if (!props.dryRun) {
-    assert6(accountId, "Missing account ID");
+    assert5(accountId, "Missing account ID");
     await verifyWorkerMatchesCITag(config, accountId, name, config.configPath);
   }
   let versionId = null;
@@ -13864,16 +14751,19 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
       { unsafeMetadata: config.unsafe?.metadata }
     );
   } else {
-    assert6(accountId, "Missing accountId");
+    assert5(accountId, "Missing accountId");
     if (assetsOptions?.routerConfig.has_user_worker === false) {
       logger.debug("skipping provisioning on assets-only project");
-    } else if (props.resourcesProvision && callbacks.provisionBindings) {
-      await callbacks.provisionBindings(
+    } else if (props.resourcesProvision) {
+      await provisionBindings(
         bindings,
         accountId,
         scriptName,
         props.experimentalAutoCreate,
-        config
+        config,
+        {
+          skipConfigWriteback: props.skipProvisioningConfigWriteback
+        }
       );
     }
     workerBundle = createWorkerUploadForm(worker, bindings, {
@@ -14117,4 +15007,4 @@ __name(validateNodeCompatMode, "validateNodeCompatMode");
  *  THE SOFTWARE.
  */
 
-export { INVALID_INHERIT_BINDING_CODE, InputWorkerSchema, NoInputError, OutputWorkerSchema, WORKER_LEGACY_ENVIRONMENT_NOT_FOUND_ERR_CODE, WORKER_NOT_FOUND_ERR_CODE, WORKFLOW_NOT_FOUND_CODE, addRequiredSecretsInheritBindings, addWorkersSitesBindings, applyServiceAndEnvironmentTags, buildAssetManifest, checkRemoteSecretsOverride, checkWorkflowConflicts, confirmLatestDeploymentOverwrite, convertConfigToBindings, convertToWranglerConfig, createDeployment, createTruncatedAlias, createWorkerUploadForm, deletePullConsumer, deleteWorkerConsumer, deploy, deployWfpUserWorker, diagnoseScriptSizeError, diagnoseStartupError, diffJsonObjects, downloadWorkerConfig, ensureQueuesExistByConfig, extractBindingsOfType, fetchDeployableVersions, fetchDeploymentVersions, fetchLatestDeployment, fetchLatestDeployments, fetchSecrets, fetchVersion, fetchVersions, fetchWorkerConfig, fromMimeType, generatePreviewAlias, getBindings, getBranchName, getConfigPatch, getDeployConfirmFunction, getMigrationsToUpload, getQueue, getRemoteConfigDiff, getSourceMappedStack, getSourceMappedString, getSubdomainValues, getSubdomainValuesAPIMock, getWorkersDevSubdomain, getZoneForRoute, getZoneIdFromHost, handleMissingSecretsError, handleUnsafeCapnp, hasDefinedEnvironments, hashFile, helpIfErrorIsSizeOrScriptStartup, isJwtExpired, isModifiedDiffValue, isNonDestructive, isUnsafeBindingType, isWorkerNotFoundError, listConsumers, listQueues, maybeRetrieveFileSourceMap, moduleTypeMimeType, parseBulkInputToObject, parseConfigPlacement, patchNonVersionedScriptSettings, postConsumer, printBindings, printBundleSize, printVersions, publishCustomDomains, publishRoutes, putConsumer, putConsumerById, renderRoute, resolveAssetOptions, sanitizeBranchName, syncAssets, tagsAreEqual, triggersDeploy, updateQueueConsumers, useServiceEnvironments, validateFileSecrets, validateNodeCompatMode, validateRoutes, verifyWorkerMatchesCITag, versionsUpload, warnOnErrorUpdatingServiceAndEnvironmentTags, warnOrError, workerNotFoundErrorMessage };
+export { INVALID_INHERIT_BINDING_CODE, InputWorkerSchema, NoInputError, OutputWorkerSchema, WORKER_LEGACY_ENVIRONMENT_NOT_FOUND_ERR_CODE, WORKER_NOT_FOUND_ERR_CODE, WORKFLOW_NOT_FOUND_CODE, addRequiredSecretsInheritBindings, addWorkersSitesBindings, applyServiceAndEnvironmentTags, buildAssetManifest, checkRemoteSecretsOverride, checkWorkflowConflicts, confirmLatestDeploymentOverwrite, convertConfigToBindings, convertToWranglerConfig, createDeployment, createTruncatedAlias, createWorkerUploadForm, deletePullConsumer, deleteWorkerConsumer, deploy, deployWfpUserWorker, diagnoseScriptSizeError, diagnoseStartupError, diffJsonObjects, downloadWorkerConfig, ensureQueuesExistByConfig, extractBindingsOfType, fetchDeployableVersions, fetchDeploymentVersions, fetchLatestDeployment, fetchLatestDeployments, fetchSecrets, fetchVersion, fetchVersions, fetchWorkerConfig, fromMimeType, generatePreviewAlias, getBindings, getBranchName, getConfigPatch, getDeployConfirmFunction, getMigrationsToUpload, getQueue, getRemoteConfigDiff, getSettings, getSourceMappedStack, getSourceMappedString, getSubdomainValues, getSubdomainValuesAPIMock, getWorkersDevSubdomain, getZoneForRoute, getZoneIdFromHost, handleMissingSecretsError, handleUnsafeCapnp, hasDefinedEnvironments, hashFile, helpIfErrorIsSizeOrScriptStartup, isJwtExpired, isModifiedDiffValue, isNonDestructive, isUnsafeBindingType, isWorkerNotFoundError, listConsumers, listQueues, maybeRetrieveFileSourceMap, moduleTypeMimeType, parseBulkInputToObject, parseConfigPlacement, patchNonVersionedScriptSettings, postConsumer, printBindings, printBundleSize, printVersions, provisionBindings, publishCustomDomains, publishRoutes, putConsumer, putConsumerById, renderRoute, resolveAssetOptions, sanitizeBranchName, syncAssets, tagsAreEqual, triggersDeploy, updateQueueConsumers, useServiceEnvironments, validateFileSecrets, validateNodeCompatMode, validateRoutes, verifyWorkerMatchesCITag, versionsUpload, warnOnErrorUpdatingServiceAndEnvironmentTags, warnOrError, workerNotFoundErrorMessage };