void 0.26.1 → 0.28.0

package/dist/{wrangler-D9KTuqnv.mjs → wrangler-BYs07Rxy.mjs}

@@ -1,11 +1,11 @@
-import { a as join, n as dirname, o as normalize, t as basename } from "./dist-BVqXeR_h.mjs";
-import "./project-paths-GgcMozYz.mjs";
-import { m as readConfig } from "./config-DiowPT80.mjs";
-import { a as hasSandboxSqliteMigration, c as resolveSandboxConfig, i as assertSandboxNamespaceConfig, l as sandboxContainerConfig, r as SANDBOX_MIGRATION_TAG } from "./config-B_ggY-IO.mjs";
-import { i as persistCloudflareConfig, r as materializeCloudflareConfig } from "./cloudflare-config-BmhBv3HV.mjs";
+import { a as join, n as dirname, o as normalize, t as basename } from "./dist-ipQi0Q8y.mjs";
+import "./project-paths-DMvEeSau.mjs";
+import { d as readConfig } from "./config-Bx_1SpnO.mjs";
+import { i as persistCloudflareConfig, r as materializeCloudflareConfig } from "./cloudflare-config-DV60XFFK.mjs";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { appendSqliteClassMigration, isRecord } from "@void/deploy-core";
 import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 import { SyntaxKind, applyEdits, createScanner, findNodeAtLocation, modify, parse, parseTree } from "jsonc-parser";
 //#region src/cli/wrangler.ts
 const COMPAT_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
@@ -163,27 +163,14 @@ function resolveGeneratedName(base, used, kind) {
 	}
 }
 /**
-* Read compatibility settings from `wrangler.jsonc`/`wrangler.json`,
-* `void.json`, and build output, with priority:
-* void.json > wrangler.jsonc > build output > latest known-good date.
-*
-* This function is read-only: when no explicit `compatibility_date` exists, it
-* returns the latest known-good date without writing it anywhere. Use
-* `ensureWranglerCompat()` when the caller is in a real dev/build/deploy
-* lifecycle and wants to persist the default in `void.json`.
-*
-* @param buildOutputDir - Optional path to the build output directory (e.g.
-*   `dist/ssr`) which may contain a plugin-generated `wrangler.json` with the
-*   correct compat settings for the built worker.
+* Read compatibility settings with priority: Void config > project Wrangler config >
+* `<buildOutputDir>/wrangler.json` > latest known-good date. Read-only; use
+* `ensureWranglerCompat()` to pin the default date.
 */
 function readWranglerCompat(root, config, buildOutputDir) {
 	return resolveWranglerCompat(readWranglerCompatFields(root, config, buildOutputDir));
 }
-/**
-* Read compatibility settings and ensure the default date is pinned in
-* `void.json` when no explicit date exists in void.json, wrangler config, or
-* build output.
-*/
+/** Like `readWranglerCompat()`, but pins the default date when no source sets one. */
 function ensureWranglerCompat(root, config, buildOutputDir) {
 	const fields = readWranglerCompatFields(root, config, buildOutputDir);
 	const defaultDate = fields.voidDate ?? fields.wranglerDate ?? fields.buildDate ? void 0 : ensureVoidCompatibilityDate(root, fields.voidConfig);
@@ -217,13 +204,10 @@ function readWranglerCompatFields(root, config, buildOutputDir) {
 		}
 		if (Array.isArray(buildParsed.compatibility_flags) && buildParsed.compatibility_flags.every((f) => typeof f === "string")) buildFlags = buildParsed.compatibility_flags;
 	} catch {}
-	const voidDate = voidConfig?.worker?.compatibility_date;
-	const voidFlags = voidConfig?.worker?.compatibility_flags;
-	if (voidDate !== void 0) validateCompatDate(voidDate, "void.json worker config");
 	return {
 		voidConfig,
-		voidDate,
-		voidFlags,
+		voidDate: voidConfig?.worker?.compatibility_date,
+		voidFlags: voidConfig?.worker?.compatibility_flags,
 		wranglerDate,
 		wranglerFlags,
 		buildDate,
@@ -266,9 +250,8 @@ function ensureVoidCompatibilityDate(root, config) {
 	return LATEST_KNOWN_COMPAT_DATE;
 }
 /**
-* Sync inferred/configured bindings into the project's wrangler.jsonc for local dev.
-* Only adds bindings that are missing — existing bindings are preserved.
-* Returns true if the file was modified.
+* Add missing inferred bindings to the project Wrangler config for local dev; existing
+* bindings are kept. Returns true if the file was written.
 */
 function syncWranglerBindings(root, bindings, options) {
 	const { configPath, parsed, created } = readOrCreateProjectWranglerConfig(root);
@@ -357,67 +340,12 @@ function syncWranglerBindings(root, bindings, options) {
 			modified = true;
 		}
 	}
-	if (options?.durableObjects && options.durableObjects.length > 0) {
-		const existingBindings = durableObjectBindingsOf(parsed);
-		for (const module of options.durableObjects) {
-			const conflict = existingBindings.find((binding) => binding.name === module.bindingName && binding.class_name !== module.className);
-			if (conflict) throw new Error(`durable: binding '${module.bindingName}' is already configured for class '${conflict.class_name}', but durable-objects/ requires '${module.className}'.`);
-		}
-		const additions = options.durableObjects.filter((module) => !existingBindings.some((binding) => binding.name === module.bindingName)).map((module) => ({
-			name: module.bindingName,
-			class_name: module.className
-		}));
-		if (additions.length > 0) {
-			parsed.durable_objects = { bindings: [...existingBindings, ...additions] };
-			modified = true;
-		}
-		const migrations = Array.isArray(parsed.migrations) ? parsed.migrations : [];
-		for (const module of options.durableObjects) {
-			if (migrations.find((migration) => migration.tag === module.migrationTag && !migration.new_sqlite_classes?.includes(module.className))) throw new Error(`durable: migration tag '${module.migrationTag}' is already used by another Durable Object migration.`);
-			if (!hasDurableObjectSqliteMigration(migrations, module.className)) {
-				migrations.push({
-					tag: module.migrationTag,
-					new_sqlite_classes: [module.className]
-				});
-				modified = true;
-			}
-		}
-		if (modified) parsed.migrations = migrations;
-	}
-	if (bindings.needsSandbox) {
-		const sandbox = options?.sandbox ?? resolveSandboxConfig({ sandbox: true }, root);
-		const bindingName = options?.bindingNames?.sandbox ?? sandbox?.binding ?? "SANDBOX";
-		const className = sandbox.className;
-		assertSandboxNamespaceConfig(parsed, sandbox);
-		const existingDurableObjectBindings = durableObjectBindingsOf(parsed);
-		if (!existingDurableObjectBindings.some((binding) => binding.name === bindingName)) {
-			parsed.durable_objects = { bindings: [...existingDurableObjectBindings, {
-				name: bindingName,
-				class_name: className
-			}] };
-			modified = true;
-		}
-		const existingContainers = parsed.containers ?? [];
-		const containers = [...existingContainers.filter((container) => container.class_name !== className), sandboxContainerConfig(sandbox)];
-		if (JSON.stringify(containers) !== JSON.stringify(existingContainers)) {
-			parsed.containers = containers;
-			modified = true;
-		}
-		const migrations = Array.isArray(parsed.migrations) ? parsed.migrations : [];
-		if (!hasSandboxSqliteMigration(migrations, className)) {
-			parsed.migrations = [...migrations, {
-				tag: SANDBOX_MIGRATION_TAG,
-				new_sqlite_classes: [className]
-			}];
-			modified = true;
-		}
-	}
 	if (bindings.needsLive || options?.live) {
 		const existingDurableObjectBindings = durableObjectBindingsOf(parsed);
 		const liveConfig = typeof options?.live === "object" ? options.live : resolveLiveBindingConfig(root, {
 			existingBindings: existingDurableObjectBindings,
 			reservedBindings: options?.websockets?.map((route) => route.bindingName),
-			reservedClasses: [...options?.websockets?.map((route) => route.className) ?? [], options?.sandbox?.className]
+			reservedClasses: options?.websockets?.map((route) => route.className)
 		});
 		if (!existingDurableObjectBindings.some((binding) => binding.name === liveConfig.bindingName)) {
 			parsed.durable_objects = { bindings: [...existingDurableObjectBindings, {
@@ -438,20 +366,38 @@ function syncWranglerBindings(root, bindings, options) {
 	if (created || modified) writeProjectWranglerFile(configPath, JSON.stringify(parsed, null, 2) + "\n");
 	return created || modified;
 }
-const NO_INFERRED_BINDINGS = {
-	needsD1: false,
-	needsKV: false,
-	needsR2: false,
-	needsAuth: false,
-	needsQueues: false,
-	needsAI: false,
-	needsSandbox: false,
-	needsLive: false
-};
 /** Persist convention-derived Durable Object bindings and append-only migration history. */
 function syncWranglerDurableObjects(root, durableObjects) {
 	if (durableObjects.length === 0) return false;
-	return syncWranglerBindings(root, NO_INFERRED_BINDINGS, { durableObjects });
+	const { configPath, parsed, created } = readOrCreateProjectWranglerConfig(root);
+	let modified = false;
+	const existingBindings = durableObjectBindingsOf(parsed);
+	for (const module of durableObjects) {
+		const conflict = existingBindings.find((binding) => binding.name === module.bindingName && binding.class_name !== module.className);
+		if (conflict) throw new Error(`durable: binding '${module.bindingName}' is already configured for class '${conflict.class_name}', but durable-objects/ requires '${module.className}'.`);
+	}
+	const additions = durableObjects.filter((module) => !existingBindings.some((binding) => binding.name === module.bindingName)).map((module) => ({
+		name: module.bindingName,
+		class_name: module.className
+	}));
+	if (additions.length > 0) {
+		parsed.durable_objects = { bindings: [...existingBindings, ...additions] };
+		modified = true;
+	}
+	const migrations = Array.isArray(parsed.migrations) ? parsed.migrations : [];
+	for (const module of durableObjects) {
+		if (migrations.find((migration) => migration.tag === module.migrationTag && !migration.new_sqlite_classes?.includes(module.className))) throw new Error(`durable: migration tag '${module.migrationTag}' is already used by another Durable Object migration.`);
+		if (!hasDurableObjectSqliteMigration(migrations, module.className)) {
+			migrations.push({
+				tag: module.migrationTag,
+				new_sqlite_classes: [module.className]
+			});
+			modified = true;
+		}
+	}
+	if (modified) parsed.migrations = migrations;
+	if (created || modified) writeProjectWranglerFile(configPath, JSON.stringify(parsed, null, 2) + "\n");
+	return created || modified;
 }
 /** Persist WebSocket Durable Object bindings and SQLite migration history. */
 function syncWranglerWebSockets(root, websockets) {
@@ -459,10 +405,8 @@ function syncWranglerWebSockets(root, websockets) {
 	return writeProvisionedWranglerConfig(root, { webSockets: websockets }).modified;
 }
 /**
-* Return registered WebSocket classes that no longer have a source route.
-* These classes must remain exported while their data-bearing bindings remain
-* in Wrangler configuration. Arbitrary user Durable Objects are excluded by
-* requiring provenance from Void's WebSocket migration tag.
+* Registered WebSocket classes without a source route. They stay exported while their
+* bindings remain; only classes created by Void's WebSocket migration tag count.
 */
 function readWranglerWebSocketTombstones(root, websockets) {
 	const configPath = projectWranglerPaths(root).find((path) => existsSync(path));
@@ -474,23 +418,15 @@ function readWranglerWebSocketTombstones(root, websockets) {
 	const bindings = parsed.durable_objects?.bindings;
 	return [...new Set((Array.isArray(bindings) ? bindings : []).flatMap((binding) => typeof binding.class_name === "string" && historicalClasses.has(binding.class_name) && !currentClasses.has(binding.class_name) ? [binding.class_name] : []))].sort();
 }
-/**
-* Ensure a wrangler config has an explicit compatibility date.
-* Used when `worker.compatibility_date` is configured in void.json but the
-* active framework reads Cloudflare settings from wrangler.jsonc/json.
-*/
+/** Write the resolved compatibility date for frameworks that read the Wrangler config. */
 function ensureWranglerCompatibilityDate(root, compatibilityDate) {
-	validateCompatDate(compatibilityDate, "void.json worker config");
 	const { configPath, parsed } = readOrCreateProjectWranglerConfig(root);
 	if (parsed.compatibility_date === compatibilityDate) return false;
 	parsed.compatibility_date = compatibilityDate;
 	writeProjectWranglerFile(configPath, JSON.stringify(parsed, null, 2) + "\n");
 	return true;
 }
-/**
-* Ensure the `nodejs_als` compatibility flag exists in wrangler config.
-* Returns true if the config file was modified.
-*/
+/** Add the `nodejs_als` compatibility flag. Returns true if the file was written. */
 function ensureWranglerNodejsAlsFlag(root) {
 	const { configPath, parsed } = readOrCreateProjectWranglerConfig(root);
 	const compatibilityFlags = Array.isArray(parsed.compatibility_flags) ? parsed.compatibility_flags : [];
@@ -539,11 +475,8 @@ function writeManagedQueueProvenance(text, provenance) {
 	return `${marker}${text.includes("\r\n") ? "\r\n" : "\n"}${text}`;
 }
 /**
-* Return explicitly Void-owned consumer names that may need remote cleanup.
-*
-* Current managed consumers are included for schema-1 upgrades; the activation layer subtracts
-* consumers still present in the desired config. Pending removals survive failed deploys so a
-* later retry can finish cleanup without inferring ownership from queue naming conventions.
+* Void-owned consumer queues that may need remote cleanup: current managed consumers (the
+* caller subtracts desired ones) and pending removals, which survive failed deploys.
 */
 function readWranglerManagedQueueCleanupCandidates(configPath) {
 	if (!existsSync(configPath)) return [];
@@ -567,14 +500,8 @@ function acknowledgeWranglerManagedQueueRemovals(configPath, removedQueues) {
 	if (finalText !== raw) writeProjectWranglerFile(configPath, finalText);
 }
 /**
-* Fill root Wrangler config fields required by generated/provisioned resources, including
-* append-only WebSocket Durable Object bindings and migrations, and Mode B email fields
-* (`send_email`, `addresses`, `vars`) that have no Wrangler command.
-*
-* Comment-preserving: uses `jsonc-parser` `modify()` + `applyEdits()` so
-* comments and unrelated content survive (unlike `syncWranglerBindings`, which
-* round-trips through `JSON.stringify` and strips comments). Every edit is an
-* idempotent upsert — running twice produces byte-identical output.
+* Apply a {@link ProvisionedWranglerPatch} to the root Wrangler config. Edits keep comments
+* and unrelated content, and a second run produces the same bytes.
 */
 function writeProvisionedWranglerConfig(root, patch, options) {
 	const configPath = options?.configPath ?? discoverWranglerConfigPath(root);
@@ -676,7 +603,7 @@ function writeProvisionedWranglerConfig(root, patch, options) {
 		if (owner !== void 0) throw new Error(`deploy: cannot update "${configPath}" — cannot adopt ${JSON.stringify(binding)} into "${field}" because that binding name is already used by a ${owner} binding. Wrangler requires every binding name to be unique across the whole worker, so this would make the config undeployable. Rename the conflicting binding and retry.`);
 		if (matches.length === 1) {
 			const { index, entry: existing } = matches[0];
-			for (const [key, value] of Object.entries(properties)) if (!jsonEqual(existing[key], value)) set([
+			for (const [key, value] of Object.entries(properties)) if (!isDeepStrictEqual(existing[key], value)) set([
 				field,
 				index,
 				key
@@ -753,7 +680,7 @@ function writeProvisionedWranglerConfig(root, patch, options) {
 				const existing = currentList[index];
 				for (const [key, value] of Object.entries(entry)) {
 					if (value === void 0) continue;
-					if (!jsonEqual(existing[key], value)) set([
+					if (!isDeepStrictEqual(existing[key], value)) set([
 						"queues",
 						section,
 						index,
@@ -829,13 +756,13 @@ function writeProvisionedWranglerConfig(root, patch, options) {
 		for (const [key, value] of Object.entries(patch.vars)) {
 			const owner = owners.get(key);
 			if (owner !== void 0) throw new Error(`deploy: cannot update "${configPath}" — cannot write var ${JSON.stringify(key)} because that binding name is already used by a ${owner} binding. Wrangler requires every binding name to be unique across the whole worker, so this would make the config undeployable. Rename the conflicting binding and retry.`);
-			if (!jsonEqual(currentVars[key], value)) set(["vars", key], value);
+			if (!isDeepStrictEqual(currentVars[key], value)) set(["vars", key], value);
 		}
 	}
 	if (patch.addresses !== void 0) {
 		const currentAddresses = parseJsonc(text).addresses;
 		if (patch.addresses === null) text = removeMember(text, ["addresses"], { formattingOptions });
-		else if (!jsonEqual(currentAddresses, patch.addresses)) text = applyMemberEdit(text, ["addresses"], patch.addresses, { formattingOptions });
+		else if (!isDeepStrictEqual(currentAddresses, patch.addresses)) text = applyMemberEdit(text, ["addresses"], patch.addresses, { formattingOptions });
 	}
 	const droppedComment = findDroppedComment(extractCommentTokens(original), extractCommentTokens(text));
 	if (droppedComment !== void 0) {
@@ -957,12 +884,7 @@ function parseCustomDomains(value, configPath) {
 	}
 	return domains;
 }
-/**
-* Extract the multiset of comment TOKENS (line + block) from JSONC source using
-* jsonc-parser's scanner — exact by construction, no regex. Each token is its
-* verbatim source slice, so a relocated comment keeps identical text (its
-* multiset entry is unchanged) while a dropped comment removes one.
-*/
+/** Every line and block comment in JSONC source, verbatim, in order. */
 function extractCommentTokens(text) {
 	const scanner = createScanner(text, false);
 	const tokens = [];
@@ -976,12 +898,7 @@ function extractCommentTokens(text) {
 	}
 	return tokens;
 }
-/**
-* Multiset-subset check: return the first comment token present in `before` but
-* missing (accounting for repeats) from `after`, or `undefined` when `after` is
-* a superset of `before`. The final gate uses this to prove no comment TEXT was
-* dropped by the edits.
-*/
+/** The first comment in `before` missing from `after`, counting repeats, if any. */
 function findDroppedComment(before, after) {
 	const counts = /* @__PURE__ */ new Map();
 	for (const token of after) counts.set(token, (counts.get(token) ?? 0) + 1);
@@ -991,10 +908,7 @@ function findDroppedComment(before, after) {
 		counts.set(token, remaining - 1);
 	}
 }
-/**
-* Detect indentation from an existing config so `jsonc-parser` formats inserted
-* content to match. Falls back to two-space indentation (the repo default).
-*/
+/** Match inserted content to the file's indentation; two spaces by default. */
 function detectFormattingOptions(text) {
 	const match = text.match(/^([ \t]+)\S/m);
 	if (match) {
@@ -1015,27 +929,15 @@ function detectFormattingOptions(text) {
 }
 function parseJsonc(text) {
 	const errors = [];
-	const result = parse(text, errors, { allowTrailingComma: true });
+	const source = text.startsWith(UTF8_BOM) ? text.slice(1) : text;
+	const result = parse(source, errors, { allowTrailingComma: true });
 	if (errors.length > 0) throw new SyntaxError("Failed to parse JSONC");
 	return result;
 }
 /**
-* `modify()` + `applyEdits()`, but when the edit APPENDS a new member after a
-* sibling that carries a trailing inline comment, keep that comment attached to
-* the sibling it documented.
-*
-* jsonc-parser's formatting `modify()` reflows the whole enclosing member/entry
-* region and re-emits a trailing inline comment at the END of that region — so
-* inserting `migrations_dir` after `"database_id": "id" // production db` (or
-* appending a queue entry after `{ … } // jobs producer`) silently reassociates
-* the comment onto the NEWLY inserted member. That violates the writer's
-* comment-preservation contract. Here we detect that exact case, run the
-* (comment-free) formatting edit on a stripped copy, then splice the comment
-* back right after the sibling's separating comma so it stays put.
-*
-* Every other edit (value replacement, append after a comment-free sibling,
-* first insertion into a missing container) falls through to the plain path, so
-* behavior is byte-identical to before outside the trailing-comment case.
+* `modify()` + `applyEdits()` that keeps a trailing inline comment on the sibling it
+* documented. When a member is appended, `modify()` moves that comment after the new
+* member, so edit a copy without it and splice it back after the sibling's comma.
 */
 function applyMemberEdit(text, path, value, options) {
 	const plain = () => applyEdits(text, modify(text, path, value, options));
@@ -1070,26 +972,15 @@ function applyMemberEdit(text, path, value, options) {
 	} catch {
 		return plainResult;
 	}
-	if (!jsonEqual(relocatedParsed, parseJsonc(plainResult))) return plainResult;
+	if (!isDeepStrictEqual(relocatedParsed, parseJsonc(plainResult))) return plainResult;
 	return relocated;
 }
 /**
-* Remove one object member (the property at `path`), keeping every comment.
-*
-* jsonc-parser's `modify(text, path, undefined)` deletes from the END of the
-* previous member to the end of the removed one — so the previous sibling's
-* trailing comment, a full-line comment above the member, and the member's own
-* trailing comment all vanish (measured on 4.x). The final comment gate would
-* then refuse the write for the common `"name": "app", // worker` shape. Here
-* the property node's exact source range is spliced out instead, plus ONE
-* separating comma (the following one when present, else the preceding one so
-* a strict `.json` file never gains a trailing comma) and the now-blank line it
-* sat on. Comments are never inside those ranges, so they all stay put; a
-* comment that was attached to the removed member is left orphaned on its line.
-*
-* Validate-before-return backstop: the spliced text must parse and equal the
-* plain `modify()` result's data; otherwise the plain edit is returned and the
-* final gate decides. An absent member is a no-op.
+* Remove the object member at `path`, keeping every comment. `modify(…, undefined)` also
+* deletes the comments between the previous member and this one, so splice out the
+* property, one separating comma (the following one, else the preceding one, so strict
+* JSON gains no trailing comma) and its blank line. Falls back to `modify()` when the
+* result's data differs.
 */
 function removeMember(text, path, options) {
 	const root = parseTree(text, void 0, { allowTrailingComma: true });
@@ -1136,20 +1027,12 @@ function removeMember(text, path, options) {
 	} catch {
 		return plainResult;
 	}
-	if (!jsonEqual(splicedParsed, parseJsonc(plainResult))) return plainResult;
+	if (!isDeepStrictEqual(splicedParsed, parseJsonc(plainResult))) return plainResult;
 	return spliced;
 }
 /**
-* If a trailing inline comment sits on the same line right after `offset`,
-* return its text and end offset. Only whitespace and an OPTIONAL single
-* separator comma may sit between the sibling's value and the comment — so both
-* `"id": "x" // c` and `"id": "x", // c` (a JSONC trailing comma, or the
-* separator once a sibling follows) are recognized. A `//` line comment or a
-* single-line `/* *\/` block comment counts; a newline or closing bracket first
-* means there is no trailing comment (returns undefined). `offset` points just
-* past the sibling's value, and the sibling is always its container's LAST
-* member, so any comma here is a trailing/separator comma — never a boundary to
-* an existing following member.
+* The `//` or single-line block comment on the same line after `offset` (just past the
+* last member's value), allowing one comma before it.
 */
 function readTrailingComment(text, offset) {
 	let i = offset;
@@ -1178,12 +1061,7 @@ function readTrailingComment(text, offset) {
 		};
 	}
 }
-/**
-* Throw (without writing) if any object in the config declares the same member
-* name twice. See the call site for why a duplicate makes property-level upserts
-* silently ineffective. Walks the jsonc AST so nested objects (queue consumers,
-* D1 entries, …) are covered, not just the top level.
-*/
+/** Throw if any object in the config, at any depth, declares the same key twice. */
 function assertNoDuplicateMembers(text, configPath) {
 	const root = parseTree(text, void 0, { allowTrailingComma: true });
 	if (!root) return;
@@ -1205,7 +1083,7 @@ function assertNoDuplicateMembers(text, configPath) {
 	};
 	walk(root);
 }
-/** 1-based line/column for a byte offset — used in duplicate-key error messages. */
+/** 1-based line and column of an offset. */
 function offsetToLineColumn(text, offset) {
 	let line = 1;
 	let column = 1;
@@ -1243,19 +1121,9 @@ function validateDurableObjectMigrations(value, configPath) {
 	return value;
 }
 /**
-* wrangler's friendly label for each binding namespace. Mirrors
-* `friendlyBindingNames` in `wrangler-dist/cli.js` — the map
-* `validateBindingsHaveUniqueNames` iterates to gather every worker-wide binding
-* name. Drives the owner name in the worker-wide producer-collision error.
-*
-* This is a 1:1 copy of wrangler's `friendlyBindingNames` EXCEPT `queues`, which
-* is intentionally ABSENT: wrangler folds in `queues.producers`, but here producer
-* identity is handled by the upsert's own binding-match logic (and consumers carry
-* no binding), so including it would flag the very producer we are about to append
-* as a self-collision. Every OTHER field wrangler enumerates is present (including
-* `unsafe_hello_world`). `secrets.required` — which wrangler folds in separately
-* under the label "Secret", not via this map — is handled in
-* `collectWorkerBindingNames`.
+* Wrangler's `friendlyBindingNames`: the fields `validateBindingsHaveUniqueNames` reads, with
+* their labels. `queues` is left out because the producer upsert matches its own entries;
+* including it would make a producer collide with itself.
 */
 const FRIENDLY_BINDING_NAMES = {
 	data_blobs: "Data Blob",
@@ -1297,15 +1165,7 @@ const FRIENDLY_BINDING_NAMES = {
 	vpc_services: "VPC Service",
 	vpc_networks: "VPC Network"
 };
-/**
-* Collect every binding NAME already used across the worker config, mapped to
-* wrangler's friendly owner label (first writer wins on ties). Mirrors the exact
-* name set `validateBindingsHaveUniqueNames` builds in `wrangler-dist/cli.js`:
-* `getBindingNames(config[field])` for every `friendlyBindingNames` field, PLUS
-* `config.secrets.required` under the label "Secret" — minus `queues` (see
-* FRIENDLY_BINDING_NAMES for why). Used to fail closed before appending a queue
-* producer whose binding collides with any other worker-wide binding.
-*/
+/** Every binding name in the config, mapped to its owner's label (first one wins). */
 function collectWorkerBindingNames(config) {
 	const owners = /* @__PURE__ */ new Map();
 	const claim = (name, friendly) => {
@@ -1316,26 +1176,18 @@ function collectWorkerBindingNames(config) {
 	if (secrets && secrets.required !== void 0) {
 		if (!Array.isArray(secrets.required)) throw new Error("deploy: cannot verify binding-name uniqueness — \"secrets.required\" must be an array of secret names. Fix the wrangler config and retry.");
 		secrets.required.forEach((name, index) => {
-			if (typeof name !== "string" || name.length === 0) throw new Error(`deploy: cannot verify binding-name uniqueness — "secrets.required" contains a malformed entry at index ${index} (expected a non-empty string). Refusing to proceed on a partially-readable binding set (a dropped entry could hide a real collision). Fix the wrangler config and retry.`);
+			if (typeof name !== "string" || name.length === 0) throw bindingSetError(`"secrets.required" contains a malformed entry at index ${index} (expected a non-empty string)`, "dropped entry");
 			claim(name, "Secret");
 		});
 	}
 	return owners;
 }
-/** A shallow copy of `config` with one field omitted (never mutates the input). */
+/** A shallow copy of `config` without `field`. */
 function configWithoutField(config, field) {
 	const { [field]: _omit, ...rest } = config;
 	return rest;
 }
-/**
-* Add every `queues.producers[].binding` to an existing worker-binding owner map,
-* under the friendly label "Queue" (first-writer-wins). The base
-* `collectWorkerBindingNames` deliberately OMITS queues so the producer-append
-* path does not flag the producer it is adding as a self-collision — but for the
-* ADOPT path a producer binding sharing the adopted binding IS a real cross-type
-* collision wrangler rejects at deploy, so the adopt guard layers producers on
-* top of the reused collector.
-*/
+/** Add queue producer bindings (label "Queue"), which the base collector leaves out. */
 function addQueueProducerOwners(owners, config) {
 	const queues = assertObjectContainer(config.queues, "queues");
 	if (!queues || queues.producers === void 0) return;
@@ -1345,47 +1197,26 @@ function addQueueProducerOwners(owners, config) {
 	}
 }
 /**
-* The ONE strict `queues.producers` validator, shared by BOTH the adopt-guard's
-* owner collection ({@link addQueueProducerOwners}) and the producer-upsert path (which
-* otherwise clones the list and silently skips non-record members, committing a new
-* producer beside a corrupt list). A non-array, or any member that is not a record with
-* a non-empty string `binding`, THROWS (fail closed) rather than being dropped — a
-* dropped/hidden producer could mask a real binding collision. Returns the validated
-* producer records (each guaranteed to carry a non-empty string `binding`).
+* Validate `queues.producers`: every member needs a non-empty string `binding`. A skipped
+* member could hide a binding collision, so a malformed one throws.
 */
 function assertValidQueueProducers(producers) {
 	if (producers === void 0) return [];
 	if (!Array.isArray(producers)) throw new Error("deploy: cannot verify binding-name uniqueness — \"queues.producers\" must be an array. Fix the wrangler config and retry.");
 	return producers.map((producer, index) => {
-		if (!isRecord(producer) || typeof producer.binding !== "string" || producer.binding.length === 0) throw new Error(`deploy: cannot verify binding-name uniqueness — "queues.producers" contains a malformed entry at index ${index} (missing a non-empty string "binding"). Refusing to proceed on a partially-readable binding set (a dropped producer could hide a real collision). Fix the wrangler config and retry.`);
+		if (!isRecord(producer) || typeof producer.binding !== "string" || producer.binding.length === 0) throw bindingSetError(`"queues.producers" contains a malformed entry at index ${index} (missing a non-empty string "binding")`, "dropped producer");
 		return producer;
 	});
 }
-/**
-* Validate the OUTER shape of a wrangler container field that wrangler 4.131
-* requires to be an OBJECT (`queues`, `secrets`). A PRESENT-but-non-object container
-* (array/string/number/null) is malformed for wrangler AND would bypass the binding
-* collectors, HIDING a real cross-type binding collision — so it THROWS (fail closed).
-* An ABSENT container (undefined) returns undefined (a no-op, NOT an error).
-* Returns the container as a record when present-and-object.
-*
-* NOTE: `null` is `typeof 'object'` but `isRecord(null)` is false, so `secrets: null` /
-* `queues: null` (present but null) THROWS — correct (wrangler requires an object).
-* Absent (`undefined`) is the only no-op.
-*/
+/** An object-valued container field (`queues`, `secrets`); any other present value throws. */
 function assertObjectContainer(value, field) {
 	if (value === void 0) return;
-	if (!isRecord(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an object. Refusing to proceed on a partially-readable binding set (a wrong-shaped container could hide a real collision). Fix the wrangler config and retry.`);
+	if (!isRecord(value)) throw bindingSetError(`"${field}" must be an object`, "wrong-shaped container");
 	return value;
 }
 /**
-* The worker-wide OWNER of a binding name as the writer's adopt / `vars` guards see it:
-* validates `field`'s own outer shape (throws on a malformed target, fail closed), then
-* looks `name` up among every OTHER binding type — `queues.producers` included — and
-* returns wrangler's friendly label for the owner, or `undefined` when the name is free
-* (or held only by `field` itself). Lets a caller refuse a doomed write BEFORE side
-* effects the write would otherwise follow (the Mode B email step). Reuses the ONE
-* collector — never fork it.
+* The label of another binding type that already uses `name`, or undefined when only
+* `field` (or nothing) does. Lets a caller refuse a write before its side effects.
 */
 function findBindingNameOwner(config, field, name) {
 	bindingNamesForField(field, config[field]);
@@ -1394,20 +1225,9 @@ function findBindingNameOwner(config, field, name) {
 	return owners.get(name);
 }
 /**
-* The STRICT canonical reader for a single provisioned binding entry in a wrangler
-* config field (`d1_databases` / `kv_namespaces` / `r2_buckets` / `hyperdrive`). Replaces
-* the provisioner's loose first-match `.find()` — which validated no outer shape,
-* silently picked among duplicates, and bypassed the worker-wide collision check, so a
-* duplicate/cross-type-collision config could be reported `reused` or pass a create
-* postcondition though it is undeployable. Fails closed on:
-*   1. a malformed TARGET field (reuses {@link bindingNamesForField}: a non-array outer
-*      shape, or any member without a non-empty string `binding`, throws);
-*   2. MORE THAN ONE entry in the target field sharing `binding` (ambiguous identity —
-*      wrangler also rejects duplicate binding names);
-*   3. a worker-wide CROSS-TYPE collision — `binding` is ALSO owned by any OTHER binding
-*      type (reuses the {@link collectWorkerBindingNames} collector, EXCLUDING the
-*      target field so the entry never self-collides, and INCLUDING `queues.producers`).
-* Returns the single matching entry, or `undefined` when the binding is absent.
+* The one entry in `field` (`d1_databases`, `kv_namespaces`, …) with this binding, or
+* undefined. Throws on a malformed field, a duplicate entry, or a name another binding
+* type also uses.
 */
 function readProvisionedBindingEntry(config, field, binding, configPath) {
 	bindingNamesForField(field, config[field]);
@@ -1420,12 +1240,7 @@ function readProvisionedBindingEntry(config, field, binding, configPath) {
 	if (owner !== void 0) throw new Error(`provision: cannot read "${configPath}" — binding ${JSON.stringify(binding)} in "${field}" is also used by a ${owner} binding. Wrangler requires every binding name to be unique across the whole worker, so this config is undeployable. Rename the conflicting binding and retry.`);
 	return matches[0];
 }
-/**
-* Explicit per-field shape metadata (see {@link BindingFieldShape}), transcribed
-* from wrangler 4.131's config schema. Any `FRIENDLY_BINDING_NAMES` field absent here is
-* a `namespace-array` (`[{ binding }]`) — the shape wrangler's `getBindingNames` reads
-* via its `isNamespaceList` branch.
-*/
+/** Fields that are not a `namespace-array`. */
 const BINDING_FIELD_SHAPES = {
 	vars: { kind: "key-map" },
 	wasm_modules: { kind: "key-map" },
@@ -1480,32 +1295,16 @@ const BINDING_FIELD_SHAPES = {
 	}
 };
 /**
-* The ONE field-aware strict binding-name reader for a single config field. Routes
-* each field to its KNOWN shape (see {@link BINDING_FIELD_SHAPES}) and FAILS CLOSED on
-* any malformed/missing REQUIRED identity or wrong outer shape — never content-guessing.
-* wrangler is lenient and would silently drop such a member, letting the worker-wide
-* uniqueness guard miss (or invent) a collision.
-*
-* Exported so the deploy orchestrator's pass-through assert-set check reads a resource field's
-* per-entry identity keys through the SAME wrangler-schema shapes (handling `send_email` /
-* `ratelimits` name-keying and `logfwdr`'s nested `.bindings`, among others).
+* Binding names in one config field, read by the field's known shape. Throws on a wrong
+* shape or a missing required name, which Wrangler would drop silently.
 */
 function bindingNamesForField(field, value) {
 	if (BINDING_FIELD_SHAPES[field]?.kind === "key-map") return keyMapBindingNames(field, value);
 	return bindingEntriesForField(field, value).map((entry) => entry.name);
 }
 /**
-* The entry-shaped sibling of {@link bindingNamesForField}: routes each field to its KNOWN
-* shape and returns every binding's NAME **paired with its full config ENTRY object**, so a
-* caller can compare not just WHICH bindings a field declares but the TARGET each one points
-* at (a `services` binding's `service`, an `unsafe` binding's `type`, …). Same fail-closed
-* philosophy as {@link bindingNamesForField} — a malformed/missing REQUIRED identity or wrong
-* outer shape THROWS. {@link bindingNamesForField} is this reader's `.name` projection for every
-* non-key-map field.
-*
-* Exported so the deploy orchestrator's pass-through assert-set check can pin a legitimately
-* hand-declared binding's ENTRY pre-build and reject a build that KEEPS the name but REWRITES
-* the target.
+* Like {@link bindingNamesForField}, but pairs each name with its config entry so a caller
+* can also compare what the binding points at.
 */
 function bindingEntriesForField(field, value) {
 	const shape = BINDING_FIELD_SHAPES[field] ?? { kind: "namespace-array" };
@@ -1518,136 +1317,78 @@ function bindingEntriesForField(field, value) {
 		case "whole-object": return [];
 	}
 }
-/**
-* Entry-shaped reader for a KEY-MAP field. Key-map fields (vars/wasm_modules/text_blobs/
-* data_blobs) carry no per-binding config ENTRY object — the binding name is the KEY and the
-* VALUE is arbitrary content — and all four are excluded from the pass-through assert-set, so
-* this branch is never reached in the normal flow. It THROWS the same wrong-shape message the
-* name reader raises, so a FUTURE misclassification that routed a key-map field here fails
-* CLOSED rather than silently reading no entries.
-*/
+/** Key-map fields have no entry objects; callers never route them here. */
 function keyMapBindingEntries(field) {
-	throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an object mapping names to values. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	throw bindingSetError(`"${field}" must be an object mapping names to values`, "wrong-shaped field");
 }
-/**
-* Entry-shaped reader for a NAMESPACE-array field (`[{ binding }]`: kv_namespaces, d1_databases,
-* r2_buckets, hyperdrive, services, vectorize, …). A PRESENT value that is not an array THROWS
-* rather than being re-read as a key-map (which could under-collect and hide a real collision);
-* every member is strictly validated for a non-empty string `.binding`.
-*/
 function namespaceArrayBindingEntries(field, value) {
 	if (value === void 0) return [];
-	if (!Array.isArray(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an array of binding entries. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	if (!Array.isArray(value)) throw bindingSetError(`"${field}" must be an array of binding entries`, "wrong-shaped field");
 	return strictBindingEntries(value, "binding", field);
 }
 /**
-* Entry-shaped reader for a NAME-keyed array field (`send_email` / `ratelimits`: an array of
-* `{ name }`). A PRESENT non-array THROWS; every member is strictly validated.
-*
-* Identity is the `.name` ONLY. Verified against wrangler 4.131's bundle +
-* `config-schema.json`: NEITHER `send_email` NOR `ratelimits` has a `.binding` property in
-* the schema, and on UPLOAD wrangler keys them by `.name`. An optional `.binding` that happens
-* to sit on such an entry is NOT a binding identity wrangler recognizes, so unioning it would
-* invent a PHANTOM collision (e.g. `send_email:[{name:"EMAIL_A",binding:"QUEUE_JOBS"}]` would
-* falsely block a legitimate `QUEUE_JOBS` queue producer).
+* `send_email` and `ratelimits` are keyed by `.name` only. A `.binding` on such an entry is
+* not an identity Wrangler uses, so reading it would invent a collision.
 */
 function nameKeyedBindingEntries(field, value) {
 	if (value === void 0) return [];
-	if (!Array.isArray(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an array of binding entries. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	if (!Array.isArray(value)) throw bindingSetError(`"${field}" must be an array of binding entries`, "wrong-shaped field");
 	return strictBindingEntries(value, "name", field);
 }
-/**
-* Entry-shaped reader for a binding-LIST field (`{ bindings: [{ name }] }`: durable_objects /
-* logfwdr / unsafe): the entry of each member is the member itself, keyed on `.name`. A wrong
-* outer shape, or a missing `bindings` when required (durable_objects / logfwdr per schema),
-* THROWS; a `bindings`-less `unsafe` (optional) contributes nothing.
-*/
 function bindingListEntries(field, value, bindingsRequired) {
 	if (value === void 0) return [];
-	if (!isRecord(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an object with a "bindings" array. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	if (!isRecord(value)) throw bindingSetError(`"${field}" must be an object with a "bindings" array`, "wrong-shaped field");
 	if (value.bindings === void 0) {
-		if (bindingsRequired) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" requires a "bindings" array. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+		if (bindingsRequired) throw bindingSetError(`"${field}" requires a "bindings" array`, "wrong-shaped field");
 		return [];
 	}
-	if (!Array.isArray(value.bindings)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}.bindings" must be an array. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	if (!Array.isArray(value.bindings)) throw bindingSetError(`"${field}.bindings" must be an array`, "wrong-shaped field");
 	return strictBindingEntries(value.bindings, "name", `${field}.bindings`);
 }
-/**
-* Entry-shaped reader for a SINGLETON field (`{ binding }`: ai / browser / images / stream /
-* media / websearch / version_metadata / assets): the entry is the singleton value itself. A
-* PRESENT non-object THROWS; a present-but-malformed `binding` THROWS; a required-but-absent
-* `binding` THROWS (never a fall-through that would mis-collect the object's OTHER keys); a
-* binding-optional `assets` with no binding contributes nothing.
-*/
 function singletonBindingEntry(field, value, bindingRequired) {
 	if (value === void 0) return [];
-	if (!isRecord(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an object with a "binding". Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	if (!isRecord(value)) throw bindingSetError(`"${field}" must be an object with a "binding"`, "wrong-shaped field");
 	if (typeof value.binding === "string" && value.binding.length > 0) return [{
 		name: value.binding,
 		entry: value
 	}];
-	if (value.binding !== void 0) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" has a malformed "binding" (expected a non-empty string). Refusing to proceed on a partially-readable binding set (a dropped binding could hide a real collision). Fix the wrangler config and retry.`);
-	if (bindingRequired) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" requires a "binding" (a non-empty string). Refusing to proceed on a partially-readable binding set (a dropped binding could hide a real collision). Fix the wrangler config and retry.`);
+	if (value.binding !== void 0) throw bindingSetError(`"${field}" has a malformed "binding" (expected a non-empty string)`, "dropped binding");
+	if (bindingRequired) throw bindingSetError(`"${field}" requires a "binding" (a non-empty string)`, "dropped binding");
 	return [];
 }
-/**
-* Read binding names from a KEY-MAP field (`vars`/`wasm_modules`/`text_blobs`/
-* `data_blobs`): the object's KEYS are the binding names. Reads ONLY the keys — never
-* the values — so a value that happens to look like a binding list (`{bindings:[…]}`)
-* or a singleton (`{binding:'x'}`) is NOT misread. A PRESENT value that is not a
-* plain object is the wrong outer shape and THROWS (fail closed). An explicitly
-* `undefined`-valued key is not a real binding and is skipped.
-*/
+/** The keys of a key-map field are its binding names; the values are never read. */
 function keyMapBindingNames(field, value) {
 	if (value === void 0) return [];
-	if (!isRecord(value)) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" must be an object mapping names to values. Refusing to proceed on a partially-readable binding set (a wrong-shaped field could hide a real collision). Fix the wrangler config and retry.`);
+	if (!isRecord(value)) throw bindingSetError(`"${field}" must be an object mapping names to values`, "wrong-shaped field");
 	return Object.keys(value).filter((key) => value[key] !== void 0);
 }
 /**
-* Strictly read `keyField` (a non-empty string) from EVERY member of a binding-bearing array and
-* return it PAIRED with the member's full entry object. THROWS (fail closed) on ANY malformed
-* member — never silently drops one. Dropping a malformed member could convert a mixed-validity
-* array (e.g. `[null, { binding: 'DB', id: '…' }]`) into an empty/partial binding set, so the
-* worker-wide uniqueness guard would MISS the existing `DB` and commit a conflicting binding.
+* Read `keyField` from every member, paired with the member. A malformed member throws:
+* dropping it could hide an existing binding from the uniqueness check.
 */
 function strictBindingEntries(members, keyField, field) {
 	return members.map((member, index) => {
-		if (!isRecord(member) || typeof member[keyField] !== "string" || member[keyField].length === 0) throw new Error(`deploy: cannot verify binding-name uniqueness — "${field}" contains a malformed entry at index ${index} (missing a non-empty string "${keyField}"). Refusing to proceed on a partially-readable binding set (a dropped entry could hide a real collision). Fix the wrangler config and retry.`);
+		if (!isRecord(member) || typeof member[keyField] !== "string" || member[keyField].length === 0) throw bindingSetError(`"${field}" contains a malformed entry at index ${index} (missing a non-empty string "${keyField}")`, "dropped entry");
 		return {
 			name: member[keyField],
 			entry: member
 		};
 	});
 }
-/**
-* True when a D1 `migrations_pattern` is valid under `dir` per wrangler's rule:
-* the normalized pattern must start with `${normalized dir}/` (or the dir
-* normalizes to "."). Mirrors wrangler's `resolveMigrationsConfig` /
-* `stripDirPrefix`.
-*/
+/** A binding field that cannot be read completely; a missed name could hide a collision. */
+function bindingSetError(problem, hidden) {
+	return /* @__PURE__ */ new Error(`deploy: cannot verify binding-name uniqueness — ${problem}. Refusing to proceed on a partially-readable binding set (a ${hidden} could hide a real collision). Fix the wrangler config and retry.`);
+}
+/** Wrangler's rule: the normalized pattern starts with `<dir>/`, unless the dir is ".". */
 function migrationsPatternMatchesDir(pattern, dir) {
 	const normalizedDir = normalizeMigrationsPath(dir);
 	if (normalizedDir === ".") return true;
 	return normalizeMigrationsPath(pattern).startsWith(`${normalizedDir}/`);
 }
-/**
-* Mirror wrangler's `normalizeRelativePath`: forward-slash, posix-normalize, then
-* drop a trailing slash. Keeps the migrations validity check byte-identical with
-* wrangler's own.
-*/
+/** Wrangler's `normalizeRelativePath`: forward slashes, normalized, no trailing slash. */
 function normalizeMigrationsPath(p) {
 	const normalized = normalize(p.replace(/\\/g, "/"));
 	return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
 }
-/** Order-insensitive structural equality — avoids rewriting an entry that only
-* differs in key order (preserves the file's bytes/comments on that entry). */
-function jsonEqual(a, b) {
-	return JSON.stringify(canonicalize(a)) === JSON.stringify(canonicalize(b));
-}
-function canonicalize(value) {
-	if (Array.isArray(value)) return value.map(canonicalize);
-	if (isRecord(value)) return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
-	return value;
-}
 //#endregion
 export { updateWranglerCustomDomain as A, readWranglerManagedQueueCleanupCandidates as C, syncWranglerBindings as D, resolveLiveBindingConfig as E, writeWranglerPublishedTrafficSnapshot as M, syncWranglerDurableObjects as O, readWranglerCustomDomains as S, readWranglerWebSocketTombstones as T, persistMaterializedWranglerConfig as _, LIVE_MIGRATION_TAG as a, readRootWranglerConfig as b, bindingEntriesForField as c, ensureWranglerCompatibilityDate as d, ensureWranglerNodejsAlsFlag as f, normalizeWranglerCompatibilityFlags as g, nextDurableObjectMigrationTag as h, LATEST_KNOWN_COMPAT_DATE as i, writeProvisionedWranglerConfig as j, syncWranglerWebSockets as k, bindingNamesForField as l, hasDurableObjectSqliteMigration as m, DEFAULT_LIVE_CLASS as n, acknowledgeWranglerManagedQueueRemovals as o, findBindingNameOwner as p, FRIENDLY_BINDING_NAMES as r, assertNoDuplicateMembers as s, DEFAULT_LIVE_BINDING as t, ensureWranglerCompat as u, readExistingLiveBindingConfig as v, readWranglerPublishedTrafficSnapshot as w, readWranglerCompat as x, readProvisionedBindingEntry as y };