@dragonmastery/tamer 0.30.0 → 0.31.0

package/dist/{fetchStackImports-ClUYZy_U.mjs → registry-EWWdkLf7.mjs}

@@ -1,857 +1,7 @@
-import { f as getDispatchNamespaces, n as materializeTamerResolvable, r as materializeVars } from "./normalize-DVSTRZhO.mjs";
-import { t as getWorkers } from "./loader-DnT9iqz9.mjs";
-import { f as stackNameForConfig, o as effectiveDispatchNamespaceName, s as isEphemeralEnv, t as StateManager } from "./StateManager-JLBtz9V-.mjs";
-import { n as r2S3CredentialsFromEnv, t as emptyR2BucketViaS3 } from "./r2S3EmptyBucket-DD81ZWQ7.mjs";
-import { n as logApplyChange } from "./planFormat-CJw8Kq2s.mjs";
-import { resolve } from "path";
-
-//#region src/core/naming/NamingEngine.ts
-function reLiteral(s) {
-	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-var NamingEngine = class {
-	constructor(tenant, conventions) {
-		this.tenant = tenant;
-		this.conventions = conventions;
-	}
-	/** Tenant id for per-resource {@link CloudflareNameFn} overrides. */
-	get tenantId() {
-		return this.tenant.id;
-	}
-	d1SingleName(logicalName, env) {
-		if (this.conventions?.d1Single) return this.conventions.d1Single(logicalName, this.tenant.id, env);
-		return `db_${logicalName}_t_${this.tenant.id}_${env}`;
-	}
-	d1ShardName(logicalName, shardDate, env) {
-		if (this.conventions?.d1Shard) return this.conventions.d1Shard(logicalName, shardDate, this.tenant.id, env);
-		const dateNoDashes = shardDate.replace(/-/g, "");
-		if (logicalName === "default" || logicalName === "") return `db_${dateNoDashes}_t_${this.tenant.id}_${env}`;
-		return `db_${logicalName}_${dateNoDashes}_t_${this.tenant.id}_${env}`;
-	}
-	d1SingleBindingKey(logicalName) {
-		return `DB_${logicalName.toUpperCase().replace(/-/g, "_")}_T_${this.tenant.id.toUpperCase()}`;
-	}
-	d1ShardBindingKey(logicalName, shardDate) {
-		const dateNoDashes = shardDate.replace(/-/g, "");
-		return `DB_${logicalName.toUpperCase().replace(/-/g, "_")}_${dateNoDashes}_T_${this.tenant.id.toUpperCase()}`;
-	}
-	r2BucketName(logicalName, env) {
-		if (this.conventions?.r2Bucket) {
-			const dateNoDashes = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "");
-			return this.conventions.r2Bucket(logicalName, dateNoDashes, this.tenant.id, env);
-		}
-		return `r2-${logicalName}-t-${this.tenant.id}-${env}`;
-	}
-	/**
-	* Wrangler `r2_buckets[].binding`: logical + tenant only (same idea as {@link kvBindingKey}).
-	* Stable across envs; default {@link r2BucketName} is `r2-{logical}-t-{tenant}-{env}`.
-	*/
-	r2BindingKey(logicalName) {
-		return `R2_${logicalName.toUpperCase().replace(/-/g, "_")}_T_${this.tenant.id.toUpperCase()}`;
-	}
-	kvNamespaceName(logicalName, env) {
-		return `kv_${logicalName}_t_${this.tenant.id}_${env}`;
-	}
-	kvBindingKey(logicalName) {
-		return `KV_${logicalName.toUpperCase().replace(/-/g, "_")}_T_${this.tenant.id.toUpperCase()}`;
-	}
-	queueName(logicalName, env) {
-		return `q-${logicalName}-t-${this.tenant.id}-${env}`;
-	}
-	queueBindingKey(logicalName) {
-		return `Q_${logicalName.toUpperCase().replace(/-/g, "_")}_T_${this.tenant.id.toUpperCase()}`;
-	}
-	hyperdriveName(logicalName, env) {
-		return `hd-${logicalName}-t-${this.tenant.id}-${env}`;
-	}
-	hyperdriveBindingKey(logicalName) {
-		return `HD_${logicalName.toUpperCase().replace(/-/g, "_")}_T_${this.tenant.id.toUpperCase()}`;
-	}
-	vectorizeName(logicalName, env) {
-		return `vec-${logicalName}-t-${this.tenant.id}-${env}`;
-	}
-	vectorizeBindingKey(logicalName) {
-		return `VEC_${logicalName.toUpperCase().replace(/-/g, "_")}_T_${this.tenant.id.toUpperCase()}`;
-	}
-	/**
-	* AI Gateway slug (== Cloudflare gateway id). Per the Cloudflare API,
-	* gateway ids are case-sensitive lowercase ascii with `-`/`_`. Format:
-	* `aigw-{logical}-t-{tenantId}-{env}`.
-	*/
-	aiGatewayId(logicalName, env) {
-		return `aigw-${logicalName}-t-${this.tenant.id}-${env}`.toLowerCase();
-	}
-	/**
-	* Stable cross-reference binding key for AI Gateway. AI Gateway has no
-	* Wrangler binding kind today, so this is only consumed by
-	* `${tamer:ai_gateway:<logical>.binding}` interpolations.
-	*/
-	aiGatewayBindingKey(logicalName) {
-		return `AI_GW_${logicalName.toUpperCase().replace(/-/g, "_")}_T_${this.tenant.id.toUpperCase()}`;
-	}
-	/**
-	* Cloudflare-side pipeline name. Pipelines V1 names must be lowercase
-	* alphanumerics + hyphens (no underscores), so we mirror the R2 scheme.
-	* Pattern: `pipe-{logical}-t-{tenantId}-{env}`.
-	*/
-	pipelineName(logicalName, env) {
-		return `pipe-${logicalName}-t-${this.tenant.id}-${env}`.toLowerCase();
-	}
-	/**
-	* Wrangler binding key emitted in `pipelines[]`. Uppercased logical with
-	* the tenant id appended so two tenants can share a worker namespace
-	* without colliding bindings.
-	*/
-	pipelineBindingKey(logicalName) {
-		return `PIPE_${logicalName.toUpperCase().replace(/-/g, "_")}_T_${this.tenant.id.toUpperCase()}`;
-	}
-	pipelineMatchPattern(logicalName, env) {
-		const exact = this.pipelineName(logicalName, env);
-		return (name) => name === exact;
-	}
-	/**
-	* Cloudflare-side workflow name. Workflow names accept lowercase
-	* alphanumerics + hyphens; we mirror the pipelines/AI-Gateway hyphen
-	* scheme. Pattern: `wf-{logical}-t-{tenantId}-{env}`.
-	*/
-	workflowName(logicalName, env) {
-		if (this.conventions?.workflow) return this.conventions.workflow(logicalName, this.tenant.id, env);
-		return `wf-${logicalName}-t-${this.tenant.id}-${env}`.toLowerCase();
-	}
-	/**
-	* Wrangler binding key emitted in `workflows[]`. Uppercased logical with
-	* the tenant id appended so two tenants sharing a script can't collide.
-	*/
-	workflowBindingKey(logicalName) {
-		return `WF_${logicalName.toUpperCase().replace(/-/g, "_")}_T_${this.tenant.id.toUpperCase()}`;
-	}
-	workflowMatchPattern(logicalName, env) {
-		const exact = this.workflowName(logicalName, env);
-		return (name) => name === exact;
-	}
-	/**
-	* Cloudflare Secrets Store name. Account-scoped — the API allows free-form
-	* names (the dashboard examples use both `service_x_keys` and dashed
-	* variants), so we mirror our hyphen convention for consistency with
-	* pipelines / workflows / AI Gateway. Pattern:
-	* `sec-{logical}-t-{tenantId}-{env}`.
-	*/
-	secretsStoreName(logicalName, env) {
-		return `sec-${logicalName}-t-${this.tenant.id}-${env}`.toLowerCase();
-	}
-	/**
-	* Stable cross-reference key for the store. Secrets Store has no Wrangler
-	* binding kind directly — `secrets_store_secrets[]` references the
-	* resolved `store_id`, not the store name — so this only powers
-	* `${tamer:secret_store:<n>.binding}` interpolations.
-	*/
-	secretsStoreBindingKey(logicalName) {
-		return `SEC_${logicalName.toUpperCase().replace(/-/g, "_")}_T_${this.tenant.id.toUpperCase()}`;
-	}
-	secretsStoreMatchPattern(logicalName, env) {
-		const exact = this.secretsStoreName(logicalName, env);
-		return (name) => name === exact;
-	}
-	workerName(workerKey, env) {
-		if (this.conventions?.workerName) return this.conventions.workerName(this.tenant.slug, workerKey, env, this.tenant.id);
-		if (env === "local") return `${this.tenant.slug}-${workerKey}-${this.tenant.id}`;
-		return `${this.tenant.slug}-${workerKey}-${env}-${this.tenant.id}`;
-	}
-	/** Whether stack {@link NamingConventions.d1Shard} is configured. */
-	hasD1ShardConvention() {
-		return Boolean(this.conventions?.d1Shard);
-	}
-	d1MatchPattern(logicalName, env) {
-		if (this.conventions?.d1Shard) return (name) => {
-			const shardDate = this.extractD1ShardDate(name);
-			if (!shardDate) return false;
-			return this.d1ShardName(logicalName, shardDate, env) === name;
-		};
-		const suffix = `_t_${this.tenant.id}_${env}`;
-		if (logicalName === "default" || logicalName === "") return (name) => /^db_\d{8}_t_/.test(name) && name.endsWith(suffix);
-		const prefix = `db_${logicalName}_`;
-		return (name) => name.startsWith(prefix) && name.endsWith(suffix);
-	}
-	/**
-	* Default: exact {@link r2BucketName}, or legacy dated buckets
-	* `r2-{logical}-{YYYYMMDD}-t-{tenant}-{env}` from older Tamer versions.
-	* Custom {@link NamingConventions.r2Bucket}: exact name only (uses today's date
-	* when calling the hook, same as apply).
-	*/
-	r2MatchPattern(logicalName, env) {
-		if (this.conventions?.r2Bucket) {
-			const expected = this.r2BucketName(logicalName, env);
-			return (name) => name === expected;
-		}
-		const exactNew = `r2-${logicalName}-t-${this.tenant.id}-${env}`;
-		const legacyDated = /* @__PURE__ */ new RegExp(`^r2-${reLiteral(logicalName)}-\\d{8}-t-${reLiteral(this.tenant.id)}-${reLiteral(env)}$`);
-		return (name) => name === exactNew || legacyDated.test(name);
-	}
-	extractD1ShardDate(name) {
-		const compact = name.match(/_(\d{8})_t_/);
-		if (compact) {
-			const d = compact[1];
-			return `${d.slice(0, 4)}-${d.slice(4, 6)}-${d.slice(6, 8)}`;
-		}
-		const underscored = name.match(/_(\d{4})_(\d{2})_(\d{2})_t_/);
-		if (underscored) return `${underscored[1]}-${underscored[2]}-${underscored[3]}`;
-		return null;
-	}
-	extractR2Date(name) {
-		const match = name.match(/r2-\w+-(\d{8})-t-/);
-		if (match) {
-			const d = match[1];
-			return `${d.slice(0, 4)}-${d.slice(4, 6)}-${d.slice(6, 8)}`;
-		}
-		return null;
-	}
-};
-
-//#endregion
-//#region src/core/config/namingFromConfig.ts
-function namingFromConfig(config) {
-	const conventions = "naming" in config && config.naming ? config.naming : void 0;
-	return new NamingEngine(config.tenant, conventions);
-}
-
-//#endregion
-//#region src/core/routes/routes.resolve.ts
-const DEFAULT_PROD_ENVS = ["prod", "production"];
-const DEFAULT_SKIP_ENVS = ["local"];
-/**
-* Per `docs/handoff.md` §6:
-*   - prod / production → bare apex (`todo.com`)
-*   - any other env (including ephemeral `pr-*`) → `{env}.{apex}`
-*   - `local` (or anything in `skipEnvs`) → no route
-*
-* The resource-name `-{env}` suffix on workers/D1/R2/KV is decoupled from
-* URLs; this function only computes the URL.
-*/
-function effectiveHostForEnv(route, env) {
-	if ((route.skipEnvs ?? DEFAULT_SKIP_ENVS).includes(env)) return void 0;
-	if ((route.prodEnvs ?? DEFAULT_PROD_ENVS).includes(env)) return route.host;
-	return `${env}.${route.host}`;
-}
-/**
-* Expand one Tamer route into a wrangler `Route` (or `undefined` if the env
-* should not receive the route at all).
-*/
-function expandRouteForEnv(route, env) {
-	const host = effectiveHostForEnv(route, env);
-	if (!host) return void 0;
-	const zone = route.zone ?? route.host;
-	if (route.customDomain) return {
-		pattern: host,
-		custom_domain: true
-	};
-	return {
-		pattern: `${host}${route.path ?? "/*"}`,
-		zone_name: zone
-	};
-}
-/**
-* Expand `tamerRoutes` for the given env, dropping any that resolve to
-* `undefined` (`local`, `skipEnvs`).
-*
-* Note: ephemeral envs (matching `tenant.ephemeralEnvPattern`) follow the
-* same `{env}.{apex}` prefix rule as any non-prod env — e.g. an env named
-* `pr-1234` resolves to `pr-1234.todo.com`. Callers that want a different
-* URL scheme for ephemeral envs should special-case before calling.
-*/
-function effectiveRoutesForEnv(tamerRoutes, env) {
-	if (!tamerRoutes || tamerRoutes.length === 0) return [];
-	const out = [];
-	for (const r of tamerRoutes) {
-		const expanded = expandRouteForEnv(r, env);
-		if (expanded) out.push(expanded);
-	}
-	return out;
-}
-/**
-* Zone-name routes are attached via the Cloudflare Workers Routes HTTP API
-* (`/zones/{id}/workers/routes`), not via `wrangler.json`, so deploys stay
-* consistent with `tamer drift` / destroy.
-*/
-function isApiManagedZoneRoute(r) {
-	return typeof r === "object" && r !== null && "zone_name" in r && typeof r.zone_name === "string" && "pattern" in r && typeof r.pattern === "string" && !("custom_domain" in r && r.custom_domain === true);
-}
-/** Custom-domain `tamerRoutes` stay in wrangler until a dedicated API path exists. */
-function isWranglerOnlyTamerRoute(r) {
-	return typeof r === "object" && r !== null && "custom_domain" in r && r.custom_domain === true;
-}
-
-//#endregion
-//#region src/core/wrangler/wranglerOutFile.ts
-/** Reject path segments in generated Wrangler config filename. */
-function assertSafeWranglerOutFile(name) {
-	const trimmed = name.trim();
-	if (!trimmed) throw new Error("wranglerOutFile cannot be empty");
-	if (trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("..")) throw new Error(`Invalid wranglerOutFile "${name}": use a basename only (e.g. wrangler.json)`);
-	return trimmed;
-}
-/** Extra CLI args so Wrangler uses a non-default config file. */
-function wranglerConfigCliArgs(outFile) {
-	if (outFile === "wrangler.json") return [];
-	return ["--config", outFile];
-}
-
-//#endregion
-//#region src/core/references/references.ts
-var TamerReferenceError = class extends Error {
-	constructor(message, fieldPath) {
-		super(`${message} (at ${fieldPath})`);
-		this.fieldPath = fieldPath;
-		this.name = "TamerReferenceError";
-	}
-};
-const REF_RE = /\$\{tamer:([a-z0-9_]+):([a-zA-Z0-9_-]+)\.([a-zA-Z0-9_-]+)\}/g;
-/**
-* Scan a string for any `${tamer:...}` references. Returns true when at
-* least one reference is present (used for cheap pre-checks).
-*/
-function stringHasReference(s) {
-	REF_RE.lastIndex = 0;
-	return REF_RE.test(s);
-}
-/**
-* Resolve every `${tamer:...}` reference in `value`. Replacement preserves
-* surrounding text for partial-string interpolation. `fieldPath` is included
-* in any thrown {@link TamerReferenceError} for actionable diagnostics.
-*/
-function resolveReferencesInString(value, ctx, fieldPath) {
-	if (!stringHasReference(value)) return value;
-	return value.replace(REF_RE, (match, kind, logicalName, field) => {
-		try {
-			return lookupReference(kind, logicalName, field, ctx, fieldPath);
-		} catch (err) {
-			if (ctx.tolerant && err instanceof TamerReferenceError) return match;
-			throw err;
-		}
-	});
-}
-/**
-* Walk a `vars` record (or any flat string→string map) replacing references
-* in every value. Returns a new object; the input is not mutated.
-*/
-function resolveReferencesInVars(vars, ctx, fieldPathPrefix) {
-	if (!vars) return vars;
-	const out = {};
-	for (const [key, value] of Object.entries(vars)) {
-		if (typeof value !== "string") {
-			out[key] = value;
-			continue;
-		}
-		out[key] = resolveReferencesInString(value, ctx, `${fieldPathPrefix}.${key}`);
-	}
-	return out;
-}
-function lookupReference(kind, logicalName, field, ctx, fieldPath) {
-	switch (kind) {
-		case "d1": return lookupResource(ctx, kind, logicalName, field, fieldPath, (entry) => entry.type === "d1_database" && entry.logicalName === logicalName);
-		case "r2": return lookupResource(ctx, kind, logicalName, field, fieldPath, (entry) => entry.type === "r2_bucket" && entry.logicalName === logicalName);
-		case "kv": return lookupResource(ctx, kind, logicalName, field, fieldPath, (entry) => entry.type === "kv_namespace" && entry.logicalName === logicalName);
-		case "queue": return lookupResource(ctx, kind, logicalName, field, fieldPath, (entry) => entry.type === "queue" && entry.logicalName === logicalName);
-		case "hyperdrive": return lookupResource(ctx, kind, logicalName, field, fieldPath, (entry) => entry.type === "hyperdrive" && entry.logicalName === logicalName);
-		case "vectorize": return lookupResource(ctx, kind, logicalName, field, fieldPath, (entry) => entry.type === "vectorize" && entry.logicalName === logicalName);
-		case "ai_gateway": return lookupResource(ctx, kind, logicalName, field, fieldPath, (entry) => entry.type === "ai_gateway" && entry.logicalName === logicalName);
-		case "pipeline": return lookupResource(ctx, kind, logicalName, field, fieldPath, (entry) => entry.type === "pipeline" && entry.logicalName === logicalName);
-		case "workflow": return lookupResource(ctx, kind, logicalName, field, fieldPath, (entry) => entry.type === "workflow" && entry.logicalName === logicalName);
-		case "secret_store": return lookupResource(ctx, kind, logicalName, field, fieldPath, (entry) => entry.type === "secrets_store" && entry.logicalName === logicalName);
-		case "dispatch_namespace": return lookupDispatchNamespace(ctx, logicalName, field, fieldPath);
-		case "worker": return lookupWorker(ctx, logicalName, field, fieldPath);
-		case "import": return lookupImport(ctx, logicalName, field, fieldPath);
-		case "logpush_pipelines": return lookupLogpushPipelines(ctx, logicalName, field, fieldPath);
-		case "config": return lookupConfigField(ctx, logicalName, field, fieldPath);
-		default: throw new TamerReferenceError(`Unknown reference kind "${kind}" — expected one of d1 | r2 | kv | queue | hyperdrive | vectorize | ai_gateway | pipeline | workflow | secret_store | dispatch_namespace | worker | import | logpush_pipelines | config`, fieldPath);
-	}
-}
-function lookupConfigField(ctx, _logicalName, field, fieldPath) {
-	if (field === "account_id") {
-		const id = (ctx.accountId ?? ctx.config.account_id ?? "").trim();
-		if (!id) throw new TamerReferenceError(`Reference \${tamer:config:stack.account_id} needs the stack Cloudflare account id — set top-level account_id in tamer/project.config.ts or pass CLOUDFLARE_ACCOUNT_ID when running tamer.`, fieldPath);
-		return id;
-	}
-	throw new TamerReferenceError(`Unknown field "${field}" on config reference — expected account_id`, fieldPath);
-}
-function getLogpushPipelinesEntry(ctx, logicalName, fieldPath) {
-	const all = ctx.state.getAll();
-	const entry = Object.values(all).find((e) => e.type === "logpush_pipelines" && e.logicalName === logicalName);
-	if (!entry) throw new TamerReferenceError(`Reference \${tamer:logpush_pipelines:${logicalName}.…} cannot be resolved — no pipelines graph in state for logpush job "${logicalName}". Run a full \`tamer apply\` (including the Logpush / pipelinesAuto step) for env "${ctx.env}" first.`, fieldPath);
-	return entry;
-}
-/**
-* Exposes fields from the `logpush_pipelines:*` D1 state row (after
-* `ensurePipelinesLogpushProvision` has run) for `outputs` and `vars`, e.g.
-* `${tamer:logpush_pipelines:workers-trace.r2_data_catalog_table_name}`.
-*/
-function lookupLogpushPipelines(ctx, logicalName, field, fieldPath) {
-	const entry = getLogpushPipelinesEntry(ctx, logicalName, fieldPath);
-	switch (field) {
-		case "r2_data_catalog_table_name":
-		case "iceberg_table": {
-			const v = entry.r2DataCatalogTableName?.trim();
-			if (!v) throw new TamerReferenceError(`logpush_pipelines state for "${logicalName}" has no r2DataCatalogTableName (sink not yet created, or pre-upgrade state). Re-run a full \`tamer apply\` for env "${ctx.env}" after pipelinesAuto provisions the sink, or set table manually in consuming stack.`, fieldPath);
-			return v;
-		}
-		case "r2_data_catalog_table_name_pipelines":
-		case "iceberg_table_pipelines": {
-			const v = entry.r2DataCatalogTableNamePipelines?.trim();
-			if (v) return v;
-			const fallback = entry.r2DataCatalogTableName?.trim();
-			if (!fallback) throw new TamerReferenceError(`logpush_pipelines state for "${logicalName}" has no table name (sink not yet created). Re-run \`tamer apply\` for env "${ctx.env}".`, fieldPath);
-			return fallback;
-		}
-		case "r2_data_catalog_namespace":
-		case "iceberg_namespace": return (entry.r2DataCatalogNamespace ?? "default").trim() || "default";
-		case "name": return entry.pipelineName;
-		case "id": return entry.pipelineId;
-		default: throw new TamerReferenceError(`Unknown field "${field}" on logpush_pipelines reference — expected r2_data_catalog_table_name | r2_data_catalog_table_name_pipelines | r2_data_catalog_namespace | name | id | iceberg_table | iceberg_table_pipelines | iceberg_namespace`, fieldPath);
-	}
-}
-/**
-* Resolve a `${tamer:import:<stack>.<output>}` against pre-fetched sibling
-* stack outputs. The pre-fetch (`fetchStackImports`) loads every imported
-* stack's `cfi_state:{stack}` row before resolution begins; this lookup is
-* pure map access. Throws if the stack isn't in `ctx.imports` (config
-* never declared it / pre-fetch wasn't wired in for this command) or if
-* the named output hasn't been published yet (sibling stack hasn't run
-* `apply` since the output was declared, or has been destroyed).
-*/
-function lookupImport(ctx, stackName, outputName, fieldPath) {
-	const imports = ctx.imports;
-	if (!imports || !(stackName in imports)) throw new TamerReferenceError(`Reference \${tamer:import:${stackName}.${outputName}} cannot be resolved — no imported stack "${stackName}" available. Ensure stack "${stackName}" exists in env "${ctx.env}" (run 'tamer apply' there first) and that the current command pre-fetches sibling stacks.`, fieldPath);
-	const stackOutputs = imports[stackName];
-	if (!(outputName in stackOutputs)) {
-		const available = Object.keys(stackOutputs).sort();
-		throw new TamerReferenceError(`Reference \${tamer:import:${stackName}.${outputName}} cannot be resolved — output "${outputName}" not found on imported stack "${stackName}".${available.length > 0 ? ` Available outputs on stack "${stackName}": ${available.join(", ")}.` : ` Stack "${stackName}" has no published outputs — run 'tamer apply' there with an \`outputs:\` block.`}`, fieldPath);
-	}
-	return stackOutputs[outputName];
-}
-function lookupResource(ctx, kind, logicalName, field, fieldPath, predicate) {
-	const all = ctx.state.getAll();
-	const entry = Object.values(all).find(predicate);
-	if (!entry) throw new TamerReferenceError(`Reference \${tamer:${kind}:${logicalName}.${field}} cannot be resolved — no ${kind} resource named "${logicalName}" in state. Run 'tamer apply --env ${ctx.env}' first.`, fieldPath);
-	switch (field) {
-		case "name": return resourceName(entry);
-		case "id": return resourceId(entry, kind, logicalName, fieldPath);
-		case "binding": return resourceBinding(entry);
-		default: throw new TamerReferenceError(`Unknown field "${field}" on ${kind} reference — expected name | id | binding`, fieldPath);
-	}
-}
-function resourceName(entry) {
-	switch (entry.type) {
-		case "d1_database":
-		case "kv_namespace":
-		case "queue":
-		case "hyperdrive":
-		case "vectorize":
-		case "ai_gateway":
-		case "pipeline":
-		case "workflow":
-		case "secrets_store":
-		case "dispatch_namespace":
-		case "r2_bucket": return entry.derivedName;
-		case "dns_record": return entry.name;
-		case "logpush_job": return entry.derivedName;
-		case "logpush_pipelines": return entry.pipelineName;
-		case "worker_route": return entry.pattern;
-	}
-}
-function resourceId(entry, kind, logicalName, fieldPath) {
-	switch (entry.type) {
-		case "d1_database":
-		case "kv_namespace":
-		case "queue":
-		case "hyperdrive":
-		case "vectorize":
-		case "ai_gateway":
-		case "pipeline":
-		case "workflow":
-		case "secrets_store": return entry.cfId;
-		case "r2_bucket": throw new TamerReferenceError(`R2 bucket "${logicalName}" has no .id (R2 buckets are addressed by name); use \${tamer:${kind}:${logicalName}.name}`, fieldPath);
-		case "dispatch_namespace": return entry.derivedName;
-		case "dns_record": return entry.recordId;
-		case "logpush_job": return String(entry.cfJobId);
-		case "logpush_pipelines": return entry.pipelineId;
-		case "worker_route": return entry.routeId;
-	}
-}
-function resourceBinding(entry) {
-	switch (entry.type) {
-		case "d1_database":
-		case "r2_bucket":
-		case "kv_namespace":
-		case "queue":
-		case "hyperdrive":
-		case "vectorize":
-		case "ai_gateway":
-		case "pipeline":
-		case "workflow":
-		case "secrets_store": return entry.bindingKey;
-		case "dispatch_namespace": return entry.derivedName;
-		case "dns_record": throw new Error("internal: dns_record has no .binding — use .name or .id in config references");
-		case "logpush_job": throw new Error("internal: logpush_job has no .binding — use .name or .id in config references");
-		case "logpush_pipelines": throw new Error("internal: logpush_pipelines has no .binding — use .name or .id in config references");
-		case "worker_route": return entry.routeId;
-	}
-}
-function lookupDispatchNamespace(ctx, logicalName, field, fieldPath) {
-	if (!getDispatchNamespaces(ctx.config).find((d) => d.logicalName === logicalName)) throw new TamerReferenceError(`Reference \${tamer:dispatch_namespace:${logicalName}.${field}} cannot be resolved — no dispatchNamespaces entry named "${logicalName}" in the Tamer project config`, fieldPath);
-	if (field !== "name" && field !== "id") throw new TamerReferenceError(`Unknown field "${field}" on dispatch_namespace reference — expected name | id`, fieldPath);
-	const all = ctx.state.getAll();
-	const stateEntry = Object.values(all).find((e) => e.type === "dispatch_namespace" && e.logicalName === logicalName);
-	if (!stateEntry || stateEntry.type !== "dispatch_namespace") throw new TamerReferenceError(`Reference \${tamer:dispatch_namespace:${logicalName}.${field}} unresolved — no state entry. Run 'tamer apply --env ${ctx.env}' first.`, fieldPath);
-	return stateEntry.derivedName;
-}
-function lookupWorker(ctx, workerKey, field, fieldPath) {
-	let target;
-	if (ctx.config.workers && ctx.config.workers[workerKey]) target = ctx.config.workers[workerKey];
-	else if (ctx.config.worker && workerKey === "default") target = ctx.config.worker;
-	if (!target) throw new TamerReferenceError(`Reference \${tamer:worker:${workerKey}.${field}} cannot be resolved — no worker key "${workerKey}" in the Tamer project config`, fieldPath);
-	if (field !== "name") throw new TamerReferenceError(`Unknown field "${field}" on worker reference — only "name" is supported (the env-suffixed deployed script name)`, fieldPath);
-	return resolveDeployedWorkerName(ctx.config, workerKey, target, ctx.env, ctx.naming);
-}
-
-//#endregion
-//#region src/core/config/resolver.ts
-/** Wrangler script name after env suffix rules (matches `tamer deploy`). */
-function resolveDeployedWorkerName(_config, workerKey, workerConfig, env, naming) {
-	const sn = workerConfig.scriptName?.trim();
-	if (sn) {
-		if (env === "local") return sn;
-		return `${sn}-${env}`;
-	}
-	return naming.workerName(workerKey, env);
-}
-/**
-* Map from base service-binding target name (`scriptName` for envs other than
-* `local`, or the local-deployed name) → env-suffixed deployed name for every
-* worker in `config`. Used to auto-rewrite intra-stack `services[].service`
-* fields so fixtures don't have to repeat env overrides for every env.
-*/
-function buildIntraStackScriptNameMap(config, env, naming) {
-	const map = /* @__PURE__ */ new Map();
-	if (config.workers) for (const [key, wc] of Object.entries(config.workers)) {
-		const baseName = wc.scriptName?.trim() ?? naming.workerName(key, "local");
-		const deployed = resolveDeployedWorkerName(config, key, wc, env, naming);
-		map.set(baseName, deployed);
-	}
-	if (config.worker) {
-		const w = config.worker;
-		const baseName = w.scriptName?.trim() ?? naming.workerName("default", "local");
-		const deployed = resolveDeployedWorkerName(config, "default", w, env, naming);
-		map.set(baseName, deployed);
-	}
-	return map;
-}
-/** Returns a worker config copy whose `services[].service` is rewritten to env-suffixed deployed names. */
-function rewriteIntraStackServiceTargets(workerConfig, baseToDeployed) {
-	const services = workerConfig.services;
-	if (!services || services.length === 0) return workerConfig;
-	let rewroteAny = false;
-	const rewritten = services.map((s) => {
-		const target = baseToDeployed.get(s.service);
-		if (!target || target === s.service) return s;
-		rewroteAny = true;
-		return {
-			...s,
-			service: target
-		};
-	});
-	if (!rewroteAny) return workerConfig;
-	return {
-		...workerConfig,
-		services: rewritten
-	};
-}
-function mergeVars(base = {}, override = {}) {
-	return {
-		...base,
-		...override
-	};
-}
-/** Same env merge as `resolveWorkerConfig` (for deploy topo-sort service edges). */
-function mergedWorkerConfigForEnv(workerConfig, env, tenant) {
-	let merged = { ...workerConfig };
-	if (env === "local" && workerConfig.local) merged = {
-		...merged,
-		...workerConfig.local,
-		vars: mergeVars(workerConfig.vars, workerConfig.local.vars)
-	};
-	else if (workerConfig.env?.[env]) {
-		const envOverride = workerConfig.env[env];
-		merged = {
-			...merged,
-			...envOverride,
-			vars: mergeVars(workerConfig.vars, envOverride.vars)
-		};
-	}
-	const mv = merged.vars;
-	if (mv && Object.prototype.hasOwnProperty.call(mv, "BRANCH_SUFFIX")) merged = {
-		...merged,
-		vars: {
-			...mv,
-			BRANCH_SUFFIX: isEphemeralEnv(env, tenant) ? env : ""
-		}
-	};
-	return merged;
-}
-/**
-* Align `dispatch_namespaces[].namespace` and `vars.WFP_NAMESPACE` with
-* {@link effectiveDispatchNamespaceName} for envs that have no explicit
-* `worker.env[env]` block (e.g. `pr-*` shared namespace).
-*/
-function applyDispatchNamespaceEnvOverrides(config, merged, env) {
-	const dns = getDispatchNamespaces(config);
-	if (dns.length === 0) return merged;
-	const resolved = effectiveDispatchNamespaceName(dns[0], env, config.tenant);
-	const m = merged;
-	let next = merged;
-	if (m.dispatch_namespaces?.length) next = {
-		...next,
-		dispatch_namespaces: m.dispatch_namespaces.map((d) => ({
-			...d,
-			namespace: resolved
-		}))
-	};
-	if (m.vars && typeof m.vars.WFP_NAMESPACE === "string" && m.vars.WFP_NAMESPACE === dns[0].namespace) {
-		const v = next.vars;
-		next = {
-			...next,
-			vars: {
-				...v,
-				WFP_NAMESPACE: resolved
-			}
-		};
-	}
-	return next;
-}
-/**
-* Walk the merged worker config and replace `${tamer:<kind>:<logical>.<field>}`
-* references in `vars` and `tamerRoutes[].host` / `.zone` against the current
-* state snapshot. Also resolves `r2_buckets[].bucket_name`,
-* **`services[].service`**, **`dispatch_namespaces[].namespace`**, and
-* `resources.d1[].databaseName` when `ownership` is `external`. Throws
-* `TamerReferenceError` (with field path) if any
-* reference is unresolved — bubbles up to the caller as a fatal.
-*/
-function resolveCrossResourceReferences(merged, ctx) {
-	const refCtx = {
-		config: ctx.config,
-		env: ctx.env,
-		state: ctx.state,
-		naming: ctx.naming,
-		tolerant: ctx.tolerant,
-		imports: ctx.imports,
-		accountId: ctx.accountId
-	};
-	const m = merged;
-	let next = merged;
-	if (m.vars) {
-		const resolvedVars = resolveReferencesInVars(materializeVars(m.vars), refCtx, `worker[${ctx.workerKey}].vars`);
-		if (resolvedVars && resolvedVars !== m.vars) next = {
-			...next,
-			vars: resolvedVars
-		};
-	}
-	const tamerRoutes = next.tamerRoutes;
-	if (tamerRoutes && tamerRoutes.length > 0) {
-		let mutated = false;
-		const resolvedRoutes = tamerRoutes.map((r, idx) => {
-			const fieldBase = `worker[${ctx.workerKey}].tamerRoutes[${idx}]`;
-			const host = resolveReferencesInString(r.host, refCtx, `${fieldBase}.host`);
-			const zone = r.zone ? resolveReferencesInString(r.zone, refCtx, `${fieldBase}.zone`) : r.zone;
-			if (host !== r.host || zone !== r.zone) mutated = true;
-			return {
-				...r,
-				host,
-				...zone !== void 0 ? { zone } : {}
-			};
-		});
-		if (mutated) next = {
-			...next,
-			tamerRoutes: resolvedRoutes
-		};
-	}
-	const r2Buckets = next.r2_buckets;
-	if (r2Buckets && r2Buckets.length > 0) {
-		let mutated = false;
-		const resolvedBuckets = r2Buckets.map((b, idx) => {
-			const raw = b.bucket_name;
-			if (raw === void 0) return b;
-			const fieldBase = `worker[${ctx.workerKey}].r2_buckets[${idx}].bucket_name`;
-			const bucket_name = resolveReferencesInString(materializeTamerResolvable(raw), refCtx, fieldBase);
-			if (bucket_name !== raw) mutated = true;
-			return {
-				...b,
-				bucket_name
-			};
-		});
-		if (mutated) next = {
-			...next,
-			r2_buckets: resolvedBuckets
-		};
-	}
-	const svc = next.services;
-	if (svc && svc.length > 0) {
-		let mutated = false;
-		const resolvedSvc = svc.map((s, idx) => {
-			const raw = s.service;
-			const fieldBase = `worker[${ctx.workerKey}].services[${idx}].service`;
-			const service = resolveReferencesInString(materializeTamerResolvable(raw), refCtx, fieldBase);
-			if (service !== raw) mutated = true;
-			return {
-				...s,
-				service
-			};
-		});
-		if (mutated) next = {
-			...next,
-			services: resolvedSvc
-		};
-	}
-	const dispatchNsMerged = next.dispatch_namespaces;
-	if (dispatchNsMerged && dispatchNsMerged.length > 0) {
-		let mutated = false;
-		const resolvedDn = dispatchNsMerged.map((d, idx) => {
-			const raw = d.namespace;
-			const fieldBase = `worker[${ctx.workerKey}].dispatch_namespaces[${idx}].namespace`;
-			const namespace = resolveReferencesInString(materializeTamerResolvable(raw), refCtx, fieldBase);
-			if (namespace !== raw) mutated = true;
-			return {
-				...d,
-				namespace
-			};
-		});
-		if (mutated) next = {
-			...next,
-			dispatch_namespaces: resolvedDn
-		};
-	}
-	const resBlock = next.resources;
-	if (resBlock?.d1 && resBlock.d1.length > 0) {
-		let mutated = false;
-		const d1Resolved = resBlock.d1.map((d1c, idx) => {
-			if (d1c.ownership !== "external" || !d1c.databaseName) return d1c;
-			const fieldBase = `worker[${ctx.workerKey}].resources.d1[${idx}].databaseName`;
-			const databaseName = resolveReferencesInString(materializeTamerResolvable(d1c.databaseName), refCtx, fieldBase);
-			if (databaseName !== d1c.databaseName) mutated = true;
-			return {
-				...d1c,
-				databaseName
-			};
-		});
-		if (mutated) next = {
-			...next,
-			resources: {
-				...resBlock,
-				d1: d1Resolved
-			}
-		};
-	}
-	return next;
-}
-function stripTamerFields(config) {
-	const { path, config: configPath, resources, local, env, scriptName: _scriptName, wranglerOutFile: _out, dispatchNamespace: _dispatchNs, tamerRoutes: _tamerRoutes, tamerStaleRouteSweepZones: _tamerStaleRouteSweepZones, ...rest } = config;
-	return rest;
-}
-/**
-* Env merge + intra-stack `services` rewrite + sibling-stack resolution for
-* **`resources.d1[].databaseName` only** when `ownership: "external"`.
-*
-* Use before {@link ResourceModule.pickResources} during `apply` / `sync` /
-* `drift` so imported D1 names are known **without** resolving worker `vars`
-* (those references often need resources created earlier in the same `apply`).
-*/
-function mergeWorkerConfigForResourcePick(config, workerKey, workerConfig, env, accountId, naming, state, opts = {}) {
-	let merged = mergedWorkerConfigForEnv(workerConfig, env, config.tenant);
-	merged = applyDispatchNamespaceEnvOverrides(config, merged, env);
-	const intraMap = buildIntraStackScriptNameMap(config, env, naming);
-	merged = rewriteIntraStackServiceTargets(merged, intraMap);
-	const refCtx = {
-		config,
-		env,
-		state,
-		naming,
-		tolerant: opts.referencesMode === "tolerant",
-		imports: opts.imports,
-		accountId
-	};
-	const resBlock = merged.resources;
-	if (!resBlock?.d1?.length) return merged;
-	const d1Resolved = resBlock.d1.map((d1c, idx) => {
-		if (d1c.ownership !== "external" || !d1c.databaseName) return d1c;
-		const fieldBase = `worker[${workerKey}].resources.d1[${idx}].databaseName`;
-		const databaseName = resolveReferencesInString(materializeTamerResolvable(d1c.databaseName), refCtx, fieldBase);
-		return {
-			...d1c,
-			databaseName
-		};
-	});
-	return {
-		...merged,
-		resources: {
-			...resBlock,
-			d1: d1Resolved
-		}
-	};
-}
-/**
-* Env-merged worker config with every `${tamer:…}` site resolved for wrangler
-* (`vars`, `tamerRoutes`, `r2_buckets[].bucket_name`, external D1 names).
-* Used by {@link resolveWorkerConfig} after resource state is up to date.
-*/
-function mergeWorkerConfigWithResolvedRefs(config, workerKey, workerConfig, env, accountId, naming, state, opts = {}) {
-	let merged = mergedWorkerConfigForEnv(workerConfig, env, config.tenant);
-	merged = applyDispatchNamespaceEnvOverrides(config, merged, env);
-	const intraMap = buildIntraStackScriptNameMap(config, env, naming);
-	merged = rewriteIntraStackServiceTargets(merged, intraMap);
-	return resolveCrossResourceReferences(merged, {
-		config,
-		env,
-		state,
-		naming,
-		workerKey,
-		tolerant: opts.referencesMode === "tolerant",
-		imports: opts.imports,
-		accountId
-	});
-}
-async function resolveWorkerConfig(config, workerKey, workerConfig, env, baseDir, accountId, naming, state, opts = {}) {
-	const merged = mergeWorkerConfigWithResolvedRefs(config, workerKey, workerConfig, env, accountId, naming, state, opts);
-	const workerDir = workerConfig.path ? resolve(baseDir, workerConfig.path) : baseDir;
-	const m = merged;
-	const workerName = resolveDeployedWorkerName(config, workerKey, merged, env, naming);
-	const wranglerOutFile = assertSafeWranglerOutFile(m.wranglerOutFile?.trim() || "wrangler.json");
-	const dispatchNamespace = m.dispatchNamespace?.trim() || void 0;
-	const stripped = stripTamerFields(merged);
-	const tamerRoutes = merged.tamerRoutes;
-	const expandedRoutes = effectiveRoutesForEnv(tamerRoutes, env);
-	const apiManagedRoutes = expandedRoutes.filter(isApiManagedZoneRoute);
-	const wranglerTamerRoutes = expandedRoutes.filter(isWranglerOnlyTamerRoute);
-	const mergedRoutes = [...stripped.routes ?? [], ...wranglerTamerRoutes];
-	/** Non-local deploys emit `routes: []` when there are none — omitting `routes` can leave stale Wrangler-published custom domains attached from a prior config. */
-	const wranglerRoutes = mergedRoutes.length > 0 ? mergedRoutes : env === "local" ? void 0 : [];
-	return {
-		workerKey,
-		workerName,
-		workerDir,
-		env,
-		wranglerOutFile,
-		dispatchNamespace,
-		wranglerConfig: {
-			...stripped,
-			...wranglerRoutes !== void 0 ? { routes: wranglerRoutes } : {},
-			name: workerName,
-			account_id: accountId,
-			compatibility_date: stripped.compatibility_date ?? config.compatibility_date
-		},
-		resources: merged.resources ?? workerConfig.resources ?? {},
-		apiManagedRoutes
-	};
-}
+import { B as getWorkers } from "./tamer.mjs";
+import { n as r2S3CredentialsFromEnv, t as emptyR2BucketViaS3 } from "./r2S3EmptyBucket-B9_pHfvB.mjs";
+import { n as logApplyChange } from "./planFormat-5XMJK879.mjs";
 
-//#endregion
 //#region src/core/naming/resolveCloudflareName.ts
 function resolveOverride(fn, tenantId, env, ctx) {
 	if (!fn) return void 0;
@@ -3879,132 +3029,5 @@ function getResourceModule(kind) {
 }
 
 //#endregion
-//#region src/core/imports/fetchStackImports.ts
-const IMPORT_RE = /\$\{tamer:import:([a-zA-Z0-9_-]+)\.([a-zA-Z0-9_-]+)\}/g;
-/**
-* Walk the merged `CfiConfig` and collect every `${tamer:import:…}` ref
-* site along with where it was found. Used both to drive the pre-fetch
-* (which sibling stacks to load) and by `tamer status` to render an
-* "inbound imports" panel even before any `apply` has run.
-*
-* Self-imports (current stack importing from its own name) are filtered
-* out — they are almost always a config typo and would otherwise
-* silently resolve via the same row this command is about to write.
-*/
-function scanConfigForImports(config) {
-	const selfStack = stackNameForConfig(config);
-	const refs = [];
-	const seen = /* @__PURE__ */ new Set();
-	const push = (raw, fieldPath) => {
-		if (!raw) return;
-		IMPORT_RE.lastIndex = 0;
-		let m;
-		while ((m = IMPORT_RE.exec(raw)) !== null) {
-			const stack = m[1];
-			const output = m[2];
-			if (stack === selfStack) continue;
-			const key = `${fieldPath}::${stack}.${output}`;
-			if (seen.has(key)) continue;
-			seen.add(key);
-			refs.push({
-				stack,
-				output,
-				fieldPath
-			});
-		}
-	};
-	const walkVars = (vars, pathPrefix) => {
-		if (!vars) return;
-		for (const [k, v] of Object.entries(vars)) push(materializeTamerResolvable(v), `${pathPrefix}.${k}`);
-	};
-	const walkR2BucketNames = (w, pathPrefix) => {
-		if (!w.r2_buckets) return;
-		w.r2_buckets.forEach((b, i) => {
-			if (b.bucket_name === void 0) return;
-			push(materializeTamerResolvable(b.bucket_name), `${pathPrefix}.r2_buckets[${i}].bucket_name`);
-		});
-	};
-	const walkD1DatabaseNames = (w, pathPrefix) => {
-		const d1 = w.resources?.d1;
-		if (!d1) return;
-		d1.forEach((d, i) => {
-			if (d.databaseName === void 0) return;
-			push(materializeTamerResolvable(d.databaseName), `${pathPrefix}.resources.d1[${i}].databaseName`);
-		});
-	};
-	/** Service bindings / WfP namespace strings may carry `${tamer:import:…}`. */
-	const walkBindingsWithRefs = (w, pathPrefix) => {
-		w.services?.forEach((s, i) => {
-			if (s.service === void 0) return;
-			push(materializeTamerResolvable(s.service), `${pathPrefix}.services[${i}].service`);
-		});
-		w.dispatch_namespaces?.forEach((d, i) => {
-			if (d.namespace === void 0) return;
-			push(materializeTamerResolvable(d.namespace), `${pathPrefix}.dispatch_namespaces[${i}].namespace`);
-		});
-	};
-	if (config.worker) {
-		walkVars(config.worker.vars, "worker.vars");
-		walkR2BucketNames(config.worker, "worker");
-		walkD1DatabaseNames(config.worker, "worker");
-		walkBindingsWithRefs(config.worker, "worker");
-		if (config.worker.tamerRoutes) config.worker.tamerRoutes.forEach((r, i) => {
-			push(r.host, `worker.tamerRoutes[${i}].host`);
-			push(r.zone, `worker.tamerRoutes[${i}].zone`);
-		});
-	}
-	if (config.workers) for (const [key, w] of Object.entries(config.workers)) {
-		walkVars(w.vars, `worker[${key}].vars`);
-		walkR2BucketNames(w, `worker[${key}]`);
-		walkD1DatabaseNames(w, `worker[${key}]`);
-		walkBindingsWithRefs(w, `worker[${key}]`);
-		if (w.tamerRoutes) w.tamerRoutes.forEach((r, i) => {
-			push(r.host, `worker[${key}].tamerRoutes[${i}].host`);
-			push(r.zone, `worker[${key}].tamerRoutes[${i}].zone`);
-		});
-	}
-	if (config.outputs) for (const [name, source] of Object.entries(config.outputs)) push(materializeTamerResolvable(source), `outputs.${name}`);
-	return refs;
-}
-/** Distinct sibling stack names referenced anywhere in `config`. */
-function importedStackNames(config) {
-	const refs = scanConfigForImports(config);
-	return [...new Set(refs.map((r) => r.stack))].sort();
-}
-/**
-* Hydrate every imported sibling stack's persisted outputs and return
-* them shaped for {@link ReferenceContext.imports}.
-*
-* - `local` env: returns `{}` immediately. Local mode never persists
-*   state, so cross-stack imports are inherently unresolvable. Callers
-*   running in tolerant mode (`plan`, `status`) will see the placeholder
-*   verbatim; strict callers (`apply`, `deploy`) will fail at resolution
-*   with a clear "no imported stack" message.
-* - Missing sibling state row: recorded as an empty outputs map, so
-*   `lookupImport` can produce a "no published outputs" diagnostic
-*   (vs. the generic "stack not pre-fetched" error).
-*
-* The {@link CFApiClient} is shared with the caller for socket reuse.
-*/
-async function fetchStackImports(api, config, env) {
-	const stacks = importedStackNames(config);
-	if (stacks.length === 0 || env === "local") return {};
-	const out = {};
-	for (const stack of stacks) {
-		const sibling = new StateManager(config.tenant.id, env, stack);
-		try {
-			await sibling.hydrate(api);
-		} catch (err) {
-			throw new Error(`Failed to hydrate imported stack "${stack}" from env "${env}": ${err instanceof Error ? err.message : String(err)}`);
-		}
-		const persisted = sibling.getStackOutputs();
-		const flat = {};
-		for (const [name, v] of Object.entries(persisted)) flat[name] = v.value;
-		out[stack] = flat;
-	}
-	return out;
-}
-
-//#endregion
-export { wranglerConfigCliArgs as _, resourceModules as a, d1CloudflareDatabaseName as c, mergeWorkerConfigForResourcePick as d, mergedWorkerConfigForEnv as f, resolveReferencesInString as g, rewriteIntraStackServiceTargets as h, getResourceModule as i, d1SkipsProvisionAndMigrate as l, resolveWorkerConfig as m, importedStackNames as n, secretsStoreDeriveName as o, resolveDeployedWorkerName as p, scanConfigForImports as r, logicalNamesForResourceKind as s, fetchStackImports as t, buildIntraStackScriptNameMap as u, namingFromConfig as v };
-//# sourceMappingURL=fetchStackImports-ClUYZy_U.mjs.map
+export { d1CloudflareDatabaseName as a, logicalNamesForResourceKind as i, resourceModules as n, d1SkipsProvisionAndMigrate as o, secretsStoreDeriveName as r, getResourceModule as t };
+//# sourceMappingURL=registry-EWWdkLf7.mjs.map