@bedrock-rbx/core 0.1.0-beta.12 → 0.1.0-beta.14

package/dist/{migrate-mantle-state-Dkk5zGHw.mjs → migrate-mantle-state-qejWFAR0.mjs}

@@ -3,6 +3,7 @@ import { ArkErrors, type } from "arktype";
 import { cancel, intro, log, outro } from "@clack/prompts";
 import process from "node:process";
 import { defu } from "defu";
+import { createHash } from "node:crypto";
 import { DeveloperProductsClient } from "@bedrock-rbx/ocale/developer-products";
 import { GamePassesClient } from "@bedrock-rbx/ocale/game-passes";
 import { PlacesClient } from "@bedrock-rbx/ocale/places";
@@ -16,16 +17,22 @@ import { tmpdir } from "node:os";
 import { parseYAML, stringifyYAML } from "confbox";
 //#region src/cli/render.ts
 /**
-* Render a `DeployError` to the supplied `ClackPort` as a single error line.
-* Each variant produces a distinct, terse diagnostic; wrapped variants
-* (`applyFailed`, `buildDesiredFailed`, `configLoadFailed`, `stateReadFailed`,
-* `stateWriteFailed`) surface the inner cause's actionable detail (file path,
-* resource key, parser message, HTTP failure, validator issue) so the reader
-* does not have to inspect the full cause to act.
+* Render a `DeployError` to the supplied `ClackPort`. Most variants emit a
+* single error line; `applyFailed` emits one line per failing op in the
+* aggregate (in Phase 1 then Phase 2 input order). Wrapped variants
+* (`applyFailed`, `buildDesiredFailed`, `configLoadFailed`,
+* `stateReadFailed`, `stateWriteFailed`) surface the inner cause's
+* actionable detail (file path, resource key, parser message, HTTP failure,
+* validator issue) so the reader does not have to inspect the full cause to
+* act.
 * @param err - The deploy error to describe.
 * @param port - The output port the diagnostic is written to.
 */
 function renderDeployError(err, port) {
+	if (err.kind === "applyFailed") {
+		for (const failure of err.cause.failures) port.logError(`apply failed for '${failure.key}': ${applyCauseDetail(failure)}`);
+		return;
+	}
 	port.logError(deployErrorMessage(err));
 }
 /**
@@ -110,18 +117,31 @@ function permissionDetail(err) {
 	const scopeList = err.requiredScopes.map((scope) => `'${scope}'`).join(", ");
 	return `${err.message} on ${err.operationKey}: missing required ${label} ${scopeList}. Grant ${pronoun} on the API key at https://create.roblox.com/credentials`;
 }
+function safeStringify(value) {
+	if (value instanceof Error) return value.message;
+	try {
+		return String(value);
+	} catch {
+		return "<unprintable cause>";
+	}
+}
 function applyCauseDetail(cause) {
 	switch (cause.kind) {
 		case "driverFailure":
 			if (cause.cause instanceof PermissionError) return permissionDetail(cause.cause);
 			return cause.cause.message;
+		case "unexpectedThrow": return `unexpected error: ${safeStringify(cause.cause)}`;
 		case "updateUnsupported": return "update not supported";
 	}
 }
 function buildDesiredDetail(cause) {
 	switch (cause.kind) {
-		case "fileReadFailed": return `(${cause.filePath}): ${cause.reason}`;
-		case "iconRemovalRejected": return `: ${cause.message}`;
+		case "fileReadFailed": return `for '${cause.key}' (${cause.filePath}): ${cause.reason}`;
+		case "iconRemovalRejected": return `for '${cause.key}': ${cause.message}`;
+		case "redactedNameCollision": {
+			const [first, second] = cause.keys;
+			return `for '${first}' and '${second}': ${cause.message}`;
+		}
 	}
 }
 function configErrorDetail(err) {
@@ -141,9 +161,9 @@ function stateErrorDetail(cause) {
 }
 function deployErrorMessage(err) {
 	switch (err.kind) {
-		case "applyFailed": return `apply failed for '${err.cause.key}': ${applyCauseDetail(err.cause)}`;
-		case "buildDesiredFailed": return `build desired state failed for '${err.cause.key}' ${buildDesiredDetail(err.cause)}`;
+		case "buildDesiredFailed": return `build desired state failed ${buildDesiredDetail(err.cause)}`;
 		case "configLoadFailed": return `config load failed: ${configErrorDetail(err.cause)}`;
+		case "incompletePassEntry": return `pass '${err.key}' is missing '${err.missingField}' under environment '${err.environment}'`;
 		case "incompletePlaceEntry": return `place '${err.key}' is missing '${err.missingField}' under environment '${err.environment}'`;
 		case "incompleteUniverseEntry": return `universe is missing '${err.missingField}' under environment '${err.environment}'`;
 		case "missingCredential": return `missing credential: environment variable ${err.variable} is not set`;
@@ -183,77 +203,54 @@ function buildStatePortErrorMessage(err) {
 	}
 }
 //#endregion
-//#region src/adapters/clack-progress-adapter.ts
+//#region src/core/resolve-state-config.ts
 /**
-* Build a {@link ProgressPort} that renders events through a `ClackPort`.
-* Pattern-matches on the event `kind`: `deploySuccess` becomes a single
-* success line and `deployFailure` delegates to the package's deploy-error
-* rendering helper.
+* Pick the `StateConfig` that applies to `environment`. Per-environment
+* overrides win over the root block; if neither is present, returns
+* `Err(stateNotConfigured)` so the deploy boundary can surface a typed
+* error instead of silently falling back.
 *
+* @param config - Validated project config.
+* @param environment - Target environment name.
+* @returns The resolved `StateConfig`, or `Err(stateNotConfigured)` when
+* neither the environment override nor the root block is set.
 * @example
 *
 * ```ts
-* import { createClackProgressAdapter, type ClackPort } from "@bedrock-rbx/core";
-*
-* const lines: Array<string> = [];
-* const clack: ClackPort = {
-*     cancel: (message) => lines.push(`cancel: ${message}`),
-*     intro: (message) => lines.push(`intro: ${message}`),
-*     logError: (message) => lines.push(`error: ${message}`),
-*     logMessage: (message) => lines.push(`log: ${message}`),
-*     logSuccess: (message) => lines.push(`ok: ${message}`),
-*     outro: (message) => lines.push(`outro: ${message}`),
-* };
-*
-* const port = createClackProgressAdapter({ clack });
-*
-* port.emit({ environment: "production", kind: "deploySuccess", resourceCount: 3 });
-*
-* expect(lines).toEqual(["ok: production: 3 resources reconciled"]);
-* ```
-*
-* @param deps - The clack port the adapter renders through.
-* @returns A `ProgressPort` that renders via clack.
-*/
-function createClackProgressAdapter(deps) {
-	const { clack } = deps;
-	return { emit(event) {
-		switch (event.kind) {
-			case "deployFailure":
-				renderDeployError(event.error, clack);
-				return;
-			case "deploySuccess": clack.logSuccess(`${event.environment}: ${event.resourceCount} resources reconciled`);
-		}
-	} };
-}
-//#endregion
-//#region src/core/derive-price-fields.ts
-/**
-* Translate a Mantle-style optional price into the Open Cloud wire shape.
-*
-* `desired.price === undefined` (no price declared) becomes
-* `{ isForSale: false }` and the `price` key is omitted entirely. A defined
-* price (including `0`) becomes `{ isForSale: true, price }`. Both
-* `developerProduct` create and update paths share this helper so the
-* "absent ⇒ off-sale" semantics live in exactly one place.
-*
-* @param desired - Object carrying the user-declared `price`.
-* @returns The wire-shape `{ isForSale, price? }` fragment.
-*
-* @example
+* import { resolveStateConfig } from "@bedrock-rbx/core";
 *
-* ```ts
-* import { derivePriceFields } from "@bedrock-rbx/core";
+* const result = resolveStateConfig(
+*     {
+*         state: { backend: "gist", gistId: "root-gist" },
+*         environments: {
+*             production: { state: { backend: "gist", gistId: "prod-gist" } },
+*         },
+*     },
+*     "production",
+* );
 *
-* expect(derivePriceFields({ price: undefined })).toStrictEqual({ isForSale: false });
-* expect(derivePriceFields({ price: 250 })).toStrictEqual({ isForSale: true, price: 250 });
+* expect(result.success).toBeTrue();
+* if (result.success) {
+*     expect(result.data).toContainEntry(["gistId", "prod-gist"]);
+* }
 * ```
 */
-function derivePriceFields(desired) {
-	if (desired.price === void 0) return { isForSale: false };
+function resolveStateConfig(config, environment) {
+	const override = config.environments[environment]?.state;
+	if (override !== void 0) return {
+		data: override,
+		success: true
+	};
+	if (config.state !== void 0) return {
+		data: config.state,
+		success: true
+	};
 	return {
-		isForSale: true,
-		price: desired.price
+		err: {
+			environment,
+			kind: "stateNotConfigured"
+		},
+		success: false
 	};
 }
 //#endregion
@@ -441,6 +438,62 @@ function asSha256Hex(raw) {
 	return raw;
 }
 //#endregion
+//#region src/core/environment.ts
+/**
+* Source pattern for environment names, including `^` and `$` anchors.
+* Letters, digits, `-`, `_`, length 1-64.
+*
+* Exported so the config schema can validate `environments` keys against
+* the same alphabet and length cap that adapters enforce on storage
+* identifiers. Single source of truth: changing the alphabet here changes
+* both the runtime check and the schema-level key constraint.
+*
+* Anchors are embedded so callers do not have to re-add them, matching
+* the `RESOURCE_KEY_PATTERN_SOURCE` convention in `types/ids.ts`.
+*/
+const ENV_NAME_PATTERN_SOURCE = "^[A-Za-z0-9_-]{1,64}$";
+const ENVIRONMENT_NAME_PATTERN = new RegExp(ENV_NAME_PATTERN_SOURCE);
+/**
+* Validate an environment name at a state-adapter boundary.
+*
+* Adapters that map environment names onto filesystem-like identifiers
+* (gist filenames, S3 keys) must reject names that could collide or escape
+* their storage layout. This helper accepts letters, digits, `-`, and `_`
+* only, with length between 1 and 64, and returns a `StateError` for
+* anything outside that set so the adapter can fail loudly instead of
+* silently stripping characters.
+*
+* @example
+*
+* ```ts
+* import { validateEnvironmentName } from "@bedrock-rbx/core";
+*
+* const ok = validateEnvironmentName("production");
+* expect(ok.success).toBeTrue();
+*
+* const bad = validateEnvironmentName("prod/staging");
+* expect(bad.success).toBeFalse();
+* ```
+*
+* @param environment - Raw environment name supplied by a caller.
+* @returns `Ok(environment)` when the name is safe to use, or
+* `Err(StateError)` with a descriptive reason when it is not.
+*/
+function validateEnvironmentName(environment) {
+	if (!ENVIRONMENT_NAME_PATTERN.test(environment)) return {
+		err: {
+			file: environment,
+			kind: "stateError",
+			reason: `invalid environment name: must match ${String(ENVIRONMENT_NAME_PATTERN)}`
+		},
+		success: false
+	};
+	return {
+		data: environment,
+		success: true
+	};
+}
+//#endregion
 //#region src/core/kinds/hash.ts
 /**
 * Compute the SHA-256 hex digest of a byte sequence. Shared by kind modules
@@ -454,17 +507,255 @@ async function sha256Hex(bytes) {
 	return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 //#endregion
+//#region src/core/redacted-icon.ts
+const REDACTED_ICON_BYTES = new Uint8Array([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10,
+	0,
+	0,
+	0,
+	13,
+	73,
+	72,
+	68,
+	82,
+	0,
+	0,
+	0,
+	64,
+	0,
+	0,
+	0,
+	64,
+	8,
+	0,
+	0,
+	0,
+	0,
+	143,
+	2,
+	46,
+	2,
+	0,
+	0,
+	0,
+	137,
+	73,
+	68,
+	65,
+	84,
+	120,
+	156,
+	237,
+	86,
+	209,
+	14,
+	128,
+	32,
+	8,
+	244,
+	83,
+	252,
+	148,
+	254,
+	255,
+	167,
+	174,
+	37,
+	98,
+	130,
+	189,
+	20,
+	110,
+	57,
+	119,
+	108,
+	26,
+	194,
+	188,
+	64,
+	15,
+	42,
+	229,
+	160,
+	164,
+	13,
+	0,
+	142,
+	160,
+	44,
+	144,
+	2,
+	1,
+	200,
+	3,
+	242,
+	96,
+	82,
+	45,
+	176,
+	31,
+	176,
+	161,
+	244,
+	60,
+	0,
+	0,
+	153,
+	81,
+	245,
+	235,
+	161,
+	142,
+	219,
+	222,
+	188,
+	254,
+	187,
+	128,
+	50,
+	224,
+	116,
+	181,
+	168,
+	205,
+	106,
+	134,
+	202,
+	113,
+	0,
+	0,
+	109,
+	150,
+	173,
+	101,
+	97,
+	0,
+	58,
+	239,
+	67,
+	4,
+	254,
+	29,
+	239,
+	83,
+	168,
+	232,
+	177,
+	51,
+	144,
+	176,
+	251,
+	80,
+	101,
+	209,
+	82,
+	80,
+	239,
+	0,
+	240,
+	85,
+	216,
+	15,
+	216,
+	15,
+	200,
+	131,
+	89,
+	197,
+	180,
+	1,
+	0,
+	255,
+	15,
+	86,
+	184,
+	5,
+	2,
+	228,
+	255,
+	207,
+	224,
+	4,
+	233,
+	243,
+	166,
+	219,
+	234,
+	149,
+	21,
+	116,
+	0,
+	0,
+	0,
+	0,
+	73,
+	69,
+	78,
+	68,
+	174,
+	66,
+	96,
+	130
+]);
+/**
+* Sentinel path written into a resource's `icon["en-us"]` field when
+* redaction substitutes the bedrock-supplied placeholder image. Callers
+* route this path through {@link withRedactedIcon} or through the
+* `readBytes` short-circuit; neither touches the filesystem.
+*/
+const REDACTED_ICON_PATH = "<bedrock:redacted-icon.png>";
+/**
+* `true` when `path` is the redacted-icon sentinel. `readBytes` and
+* {@link withRedactedIcon} both use this predicate to decide whether to
+* bypass the injected file reader.
+*
+* @param path - Icon path supplied by a flattened or normalized resource entry.
+* @returns `true` for {@link REDACTED_ICON_PATH}; otherwise `false`.
+*/
+function isRedactedIconPath(path) {
+	return path === REDACTED_ICON_PATH;
+}
+/**
+* Wrap a `readFile` so the sentinel resolves to {@link REDACTED_ICON_BYTES}
+* without touching the inner reader. Applied once at the shell deploy /
+* preview boundary; the wrapped reader flows to every consumer (normalize,
+* registry drivers) unchanged.
+*
+* @param readFile - Inner reader that handles every non-sentinel path.
+* @returns Sentinel-aware reader with the same callable shape as `readFile`.
+*/
+function withRedactedIcon(readFile) {
+	return async (path) => {
+		if (isRedactedIconPath(path)) return new Uint8Array(REDACTED_ICON_BYTES);
+		return readFile(path);
+	};
+}
+//#endregion
 //#region src/core/kinds/read-bytes.ts
 /**
 * Read file bytes via the injected reader, translating rejections into a
 * `fileReadFailed` `BuildDesiredError`. Shared by kind modules whose
-* pre-I/O normalization hashes a file the user declared by path.
+* pre-I/O normalization hashes a file the user declared by path. The
+* redacted-icon sentinel short-circuits to the embedded placeholder
+* bytes without invoking the injected reader, so a redaction-substituted
+* icon path produces a deterministic hash on every deploy.
 *
 * @param target - Path to read plus the resource key blamed on failure.
 * @param io - I/O surface carrying the injected `readFile` function.
 * @returns `Ok` with the bytes, or `Err` with a `fileReadFailed` error.
 */
 async function readBytes(target, io) {
+	if (isRedactedIconPath(target.filePath)) return {
+		data: new Uint8Array(REDACTED_ICON_BYTES),
+		success: true
+	};
 	try {
 		return {
 			data: await io.readFile(target.filePath),
@@ -599,56 +890,499 @@ function shouldReuploadIcon(currentHashes, desiredHashes) {
 	return !iconHashesEqual(currentHashes, desiredHashes);
 }
 //#endregion
-//#region src/core/plan-follow-up-patch.ts
+//#region src/core/validate-universe-xor.ts
 /**
-* Plan the optional follow-up PATCH body needed after a developer-product
-* create POST. Returns `undefined` when no PATCH is required: either the
-* user did not declare `storePageEnabled`, or the create response already
-* matches the desired value.
+* Walk the loose authored-shape and surface every place the
+* universeId-XOR-between-root-and-env rule is violated. Pure: returns
+* the issue list; the caller hands it to arktype's `ctx.reject` so each
+* one lands at the offending config path. The schema's runtime narrow
+* uses this to enforce the rule at validation time before the validated
+* value is cast to the strict `Config` discriminated union.
 *
-* @param desired - Desired state for the developer product being created.
-* @param createResponse - The `storePageEnabled` value reported by the create POST response.
-* @returns The PATCH body to issue, or `undefined` when no follow-up is needed.
+* @param value - Parsed config the schema is validating.
+* @returns Zero or more issues. Empty when the config satisfies the rule.
 */
-function planFollowUpPatch(desired, createResponse) {
-	if (desired.storePageEnabled === void 0) return;
-	if (desired.storePageEnabled === createResponse.storePageEnabled) return;
-	return { storePageEnabled: desired.storePageEnabled };
+function collectUniverseIdIssues(value) {
+	const rootUniverseId = value.universe?.universeId;
+	const hasRootUniverseBlock = value.universe !== void 0;
+	const environmentEntries = Object.entries(value.environments);
+	const hasEnvironmentUniverseId = environmentEntries.some(([, environment]) => environment.universe?.universeId !== void 0);
+	const environmentIssues = collectEnvironmentIssues(rootUniverseId, environmentEntries);
+	const rootIssues = hasRootUniverseBlock && rootUniverseId === void 0 && !hasEnvironmentUniverseId ? [{
+		message: "universeId must be declared on the root universe block, or on every environment that declares its own universe overlay.",
+		path: ["universe", "universeId"]
+	}] : [];
+	return [...environmentIssues, ...rootIssues];
+}
+function collectEnvironmentIssues(rootUniverseId, environmentEntries) {
+	return environmentEntries.flatMap(([environmentName, environment]) => {
+		if (environment.universe === void 0) return [];
+		if (rootUniverseId !== void 0 && environment.universe.universeId !== void 0) return [{
+			message: "universeId is declared at the root universe block; remove it from this environment overlay (root is authoritative) or remove it from the root and declare it on every environment.",
+			path: [
+				"environments",
+				environmentName,
+				"universe",
+				"universeId"
+			]
+		}];
+		if (rootUniverseId === void 0 && environment.universe.universeId === void 0) return [{
+			message: "universeId must be declared on this environment overlay because the root universe block does not provide one.",
+			path: [
+				"environments",
+				environmentName,
+				"universe",
+				"universeId"
+			]
+		}];
+		return [];
+	});
 }
 //#endregion
-//#region src/adapters/developer-product-driver.ts
+//#region src/core/schema.ts
 /**
-* Wraps {@link DeveloperProductsClient} as a `ResourceDriver<"developerProduct">`
-* that maps a desired-state entry to an ocale create or update call and the
-* response back to a `ResourceCurrentState<"developerProduct">`. The
-* `update` path consumes the upstream `204 No Content` response and
-* synthesizes the post-update `ResourceCurrentState` from `desired` plus
-* the existing `current.outputs`, carrying `iconImageAssetId` forward when
-* present.
-*
-* Upstream `OpenCloudError` results pass through as `Result` failures.
-*
-* @param deps - Injected ocale client and owning universe.
-* @returns A driver indexable by `"developerProduct"` in a `DriverRegistry`.
+* Narrow a `StateConfig` to the `GistStateConfig` arm. The `(string & {})`
+* autocomplete idiom prevents TypeScript from narrowing on
+* `backend === "gist"` alone, so dispatch sites use this guard to
+* preserve the `gistId` field shape.
 *
 * @example
 *
 * ```ts
-* import type { HttpClient } from "@bedrock-rbx/ocale";
-* import { DeveloperProductsClient } from "@bedrock-rbx/ocale/developer-products";
-* import {
-*     asResourceKey,
-*     asRobloxAssetId,
-*     createDeveloperProductDriver,
-* } from "@bedrock-rbx/core";
+* import { isGistStateConfig } from "@bedrock-rbx/core";
+* import type { StateConfig } from "@bedrock-rbx/core/config";
 *
-* const httpClient: HttpClient = {
-*     async request() {
-*         return {
-*             data: {
-*                 body: {
-*                     createdTimestamp: "2024-01-15T10:30:00.000Z",
-*                     description: "Stocks the player up with 1,000 premium gems.",
+* const config: StateConfig = { backend: "gist", gistId: "abc" };
+*
+* expect(isGistStateConfig(config)).toBeTrue();
+* if (isGistStateConfig(config)) {
+*     expect(config.gistId).toBe("abc");
+* }
+* ```
+*
+* @param config - Resolved state config to inspect.
+* @returns `true` when `config.backend === "gist"`; otherwise `false`.
+*/
+function isGistStateConfig(config) {
+	return config.backend === "gist";
+}
+const OPTIONAL_BOOLEAN$2 = "boolean | undefined";
+const OPTIONAL_STRING = "string | undefined";
+const REDACTED_KEY = "redacted?";
+const NON_EMPTY_OVERRIDE_MESSAGE = "a non-empty override object; use `redacted: true` for default placeholders";
+/**
+* Shared arktype constraint for any optional positive-integer field.
+* Reused by per-kind entry schemas so positive-integer fields validate
+* identically.
+*/
+const OPTIONAL_POSITIVE_INTEGER = "(number.integer >= 1) | undefined";
+/**
+* Shared arktype constraint for any optional Robux-price field. The schema
+* rejects negatives, fractional values, `NaN`, and `Infinity` at config
+* validation time so a malformed price surfaces with a path attributing the
+* failure to the offending field, rather than slipping through to the
+* Roblox API and surfacing as an opaque error at apply time. Per-kind entry
+* schemas reuse this constant so all Robux-price fields validate
+* identically.
+*/
+const OPTIONAL_ROBUX_PRICE = "number.integer >= 0 | undefined";
+const gamePassRedacted = type({
+	"description?": "string",
+	"icon?": iconMap,
+	"name?": "string",
+	"price?": OPTIONAL_ROBUX_PRICE
+}).onUndeclaredKey("reject").narrow((value, ctx) => {
+	if (Object.keys(value).length === 0) return ctx.mustBe(NON_EMPTY_OVERRIDE_MESSAGE);
+	return true;
+}).or(OPTIONAL_BOOLEAN$2);
+const placeRedacted = type({
+	"description?": "string",
+	"displayName?": "string"
+}).onUndeclaredKey("reject").narrow((value, ctx) => {
+	if (Object.keys(value).length === 0) return ctx.mustBe(NON_EMPTY_OVERRIDE_MESSAGE);
+	return true;
+}).or(OPTIONAL_BOOLEAN$2);
+const productRedacted = type({
+	"description?": "string",
+	"icon?": iconMap,
+	"name?": "string",
+	"price?": OPTIONAL_ROBUX_PRICE
+}).onUndeclaredKey("reject").narrow((value, ctx) => {
+	if (Object.keys(value).length === 0) return ctx.mustBe(NON_EMPTY_OVERRIDE_MESSAGE);
+	return true;
+}).or(OPTIONAL_BOOLEAN$2);
+const environmentRedacted = type({
+	"description?": "string",
+	"displayName?": "string",
+	"icon?": iconMap,
+	"name?": "string",
+	"price?": OPTIONAL_ROBUX_PRICE
+}).onUndeclaredKey("reject").narrow((value, ctx) => {
+	if (Object.keys(value).length === 0) return ctx.mustBe(NON_EMPTY_OVERRIDE_MESSAGE);
+	return true;
+}).or(OPTIONAL_BOOLEAN$2);
+const gamePassEntry = type({
+	"name": "string",
+	"description": "string",
+	"icon": iconMap,
+	"price?": OPTIONAL_ROBUX_PRICE,
+	[REDACTED_KEY]: gamePassRedacted
+});
+const passesCollection = type({ [`[/${RESOURCE_KEY_PATTERN_SOURCE}/]`]: gamePassEntry }).onUndeclaredKey("reject");
+const developerProductEntry = type({
+	"name": "string",
+	"description": "string",
+	"icon?": iconMap,
+	"isRegionalPricingEnabled?": OPTIONAL_BOOLEAN$2,
+	"price?": OPTIONAL_ROBUX_PRICE,
+	[REDACTED_KEY]: productRedacted,
+	"storePageEnabled?": OPTIONAL_BOOLEAN$2
+}).onUndeclaredKey("reject");
+const productsCollection = type({ [`[/${RESOURCE_KEY_PATTERN_SOURCE}/]`]: developerProductEntry }).onUndeclaredKey("reject");
+const ROBLOX_ID_DIGITS = "string.digits";
+const placeEntry = type({
+	"description?": OPTIONAL_STRING,
+	"displayName?": OPTIONAL_STRING,
+	"filePath": "string",
+	[REDACTED_KEY]: placeRedacted,
+	"serverSize?": OPTIONAL_POSITIVE_INTEGER
+}).onUndeclaredKey("reject");
+const placesCollection = type({ [`[/${RESOURCE_KEY_PATTERN_SOURCE}/]`]: placeEntry }).onUndeclaredKey("reject");
+const socialLinkOrUndefined$1 = type({
+	title: "string",
+	uri: "string"
+}).onUndeclaredKey("reject").or("undefined");
+const universeEntry = type({
+	"consoleEnabled?": OPTIONAL_BOOLEAN$2,
+	"desktopEnabled?": OPTIONAL_BOOLEAN$2,
+	"discordSocialLink?": socialLinkOrUndefined$1,
+	"displayName?": OPTIONAL_STRING,
+	"facebookSocialLink?": socialLinkOrUndefined$1,
+	"guildedSocialLink?": socialLinkOrUndefined$1,
+	"mobileEnabled?": OPTIONAL_BOOLEAN$2,
+	"privateServerPriceRobux?": OPTIONAL_ROBUX_PRICE,
+	"robloxGroupSocialLink?": socialLinkOrUndefined$1,
+	"tabletEnabled?": OPTIONAL_BOOLEAN$2,
+	"twitchSocialLink?": socialLinkOrUndefined$1,
+	"twitterSocialLink?": socialLinkOrUndefined$1,
+	"universeId?": ROBLOX_ID_DIGITS,
+	"voiceChatEnabled?": OPTIONAL_BOOLEAN$2,
+	"vrEnabled?": OPTIONAL_BOOLEAN$2,
+	"youtubeSocialLink?": socialLinkOrUndefined$1
+}).onUndeclaredKey("reject");
+const stateConfig = type({
+	"backend": "string",
+	"gistId?": "string > 0"
+}).onUndeclaredKey("reject");
+const gamePassOverlay = type({
+	"description?": "string",
+	"icon?": iconMap,
+	"name?": "string",
+	"price?": OPTIONAL_ROBUX_PRICE,
+	[REDACTED_KEY]: gamePassRedacted
+}).onUndeclaredKey("reject");
+const passesOverlayCollection = type({ [`[/${RESOURCE_KEY_PATTERN_SOURCE}/]`]: gamePassOverlay }).onUndeclaredKey("reject");
+const developerProductOverlay = type({
+	"description?": "string",
+	"icon?": iconMap,
+	"isRegionalPricingEnabled?": OPTIONAL_BOOLEAN$2,
+	"name?": "string",
+	"price?": OPTIONAL_ROBUX_PRICE,
+	[REDACTED_KEY]: productRedacted,
+	"storePageEnabled?": OPTIONAL_BOOLEAN$2
+}).onUndeclaredKey("reject");
+const productsOverlayCollection = type({ [`[/${RESOURCE_KEY_PATTERN_SOURCE}/]`]: developerProductOverlay }).onUndeclaredKey("reject");
+const placeOverlay = type({
+	"description?": OPTIONAL_STRING,
+	"displayName?": OPTIONAL_STRING,
+	"filePath?": "string",
+	"placeId": ROBLOX_ID_DIGITS,
+	[REDACTED_KEY]: placeRedacted,
+	"serverSize?": OPTIONAL_POSITIVE_INTEGER
+}).onUndeclaredKey("reject");
+const placesOverlayCollection = type({ [`[/${RESOURCE_KEY_PATTERN_SOURCE}/]`]: placeOverlay }).onUndeclaredKey("reject");
+const universeOverlay = universeEntry;
+const environmentEntry = type({
+	"label?": OPTIONAL_STRING,
+	"passes?": passesOverlayCollection,
+	"places?": placesOverlayCollection,
+	"products?": productsOverlayCollection,
+	[REDACTED_KEY]: environmentRedacted,
+	"state?": stateConfig,
+	"universe?": universeOverlay
+}).onUndeclaredKey("reject");
+const rootSchema = type({
+	"displayNamePrefix?": type({
+		"enabled?": OPTIONAL_BOOLEAN$2,
+		"format?": OPTIONAL_STRING
+	}).onUndeclaredKey("reject"),
+	"environments": type({ [`[/${ENV_NAME_PATTERN_SOURCE}/]`]: environmentEntry }).onUndeclaredKey("reject").narrow((value, ctx) => {
+		if (Object.keys(value).length === 0) return ctx.mustBe("an environments record with at least one declared environment");
+		return true;
+	}),
+	"extends?": "unknown",
+	"passes?": passesCollection,
+	"places?": placesCollection,
+	"products?": productsCollection,
+	"state?": stateConfig,
+	"universe?": universeEntry
+}).onUndeclaredKey("reject").narrow((value, ctx) => {
+	return collectUniverseIdIssues(value).reduce((_accumulator, issue) => {
+		return ctx.reject({
+			message: issue.message,
+			path: [...issue.path]
+		});
+	}, true);
+});
+/**
+* Validate a parsed config value against the runtime schema. Returns the
+* validated `Config` on success or a `validationFailed` `ConfigError` with
+* one issue per problem, each attributed to a field path. `sourceFile`
+* appears in the error so callers can point a human at the offending file.
+*
+* @param input - Parsed value from a config source (object tree from a
+* config loader, or a hand-built literal). Shape is checked, not assumed.
+* @param sourceFile - Path or identifier of the source file, used in the
+* `validationFailed` error.
+* @returns `Ok` with the validated `Config`, or `Err` with a
+* `validationFailed` error carrying each issue's field path.
+* @example
+*
+* ```ts
+* import { validateConfig } from "@bedrock-rbx/core";
+*
+* const ok = validateConfig(
+*     {
+*         environments: { production: {} },
+*         passes: {
+*             "vip-pass": {
+*                 description: "VIP perks.",
+*                 icon: { "en-us": "assets/vip.png" },
+*                 name: "VIP Pass",
+*                 price: 500,
+*             },
+*         },
+*     },
+*     "bedrock.config.ts",
+* );
+* expect(ok.success).toBeTrue();
+*
+* const err = validateConfig(
+*     { environments: { production: {} }, passes: { "vip-pass": { name: "VIP" } } },
+*     "bedrock.config.ts",
+* );
+* expect(err.success).toBeFalse();
+* if (!err.success) {
+*     expect(err.err.kind).toBe("validationFailed");
+* }
+* ```
+*/
+function validateConfig(input, sourceFile) {
+	const validated = rootSchema(input);
+	if (validated instanceof ArkErrors) return {
+		err: {
+			issues: Array.from(validated, (issue) => {
+				return {
+					message: issue.message,
+					path: [...issue.path].map((segment) => String(segment))
+				};
+			}),
+			kind: "validationFailed",
+			sourceFile
+		},
+		success: false
+	};
+	return {
+		data: validated,
+		success: true
+	};
+}
+//#endregion
+//#region src/adapters/clack-progress-adapter.ts
+/**
+* Build a {@link ProgressPort} that renders events through a `ClackPort`.
+* Pattern-matches on the event `kind`: per-resource events render one line each,
+* the aggregate `applySummary` becomes the deploy footer, and `stateWritten`
+* names the persistence backend resolved from the loaded `Config`.
+*
+* @example
+*
+* ```ts
+* import { createClackProgressAdapter, type ClackPort } from "@bedrock-rbx/core";
+*
+* const lines: Array<string> = [];
+* const clack: ClackPort = {
+*     cancel: (message) => lines.push(`cancel: ${message}`),
+*     intro: (message) => lines.push(`intro: ${message}`),
+*     logError: (message) => lines.push(`error: ${message}`),
+*     logMessage: (message) => lines.push(`log: ${message}`),
+*     logSuccess: (message) => lines.push(`ok: ${message}`),
+*     outro: (message) => lines.push(`outro: ${message}`),
+* };
+*
+* const port = createClackProgressAdapter({ clack });
+*
+* port.emit({ environment: "production", kind: "stateWritten" });
+*
+* expect(lines).toEqual(["log: State written to state"]);
+* ```
+*
+* @param deps - The clack port and optional config the adapter renders through.
+* @returns A `ProgressPort` that renders via clack.
+*/
+function createClackProgressAdapter(deps) {
+	return { emit(event) {
+		renderEvent(event, deps);
+	} };
+}
+function applySummaryLine(event) {
+	return `Succeeded in ${(event.durationMs / 1e3).toFixed(1)}s: ${[
+		`${event.created} create`,
+		`${event.updated} update`,
+		`${event.noop} noop`,
+		`${event.failed} failed`
+	].join(", ")}`;
+}
+function stateConfigLabel(state) {
+	if (isGistStateConfig(state)) return `gist:${state.gistId}`;
+	return state.backend;
+}
+function formatStateLabel(config, environment) {
+	if (config === void 0) return "state";
+	const resolved = resolveStateConfig(config, environment);
+	if (!resolved.success) return "state";
+	return stateConfigLabel(resolved.data);
+}
+function extractResourceId(event) {
+	switch (event.resourceKind) {
+		case "developerProduct": return event.outputs.productId;
+		case "gamePass": return event.outputs.assetId;
+		case "place": return;
+		case "universe": return event.outputs.rootPlaceId;
+	}
+}
+function renderResourceOpSucceeded(event, clack) {
+	if (event.opType === "create") {
+		const id = extractResourceId(event);
+		const suffix = id === void 0 ? "" : ` (id ${id})`;
+		clack.logSuccess(`${event.resourceKind}.${event.key} created${suffix}`);
+		return;
+	}
+	clack.logSuccess(`${event.resourceKind}.${event.key} ${event.changedFields.join(", ")} updated`);
+}
+function describeApplyError(error) {
+	switch (error.kind) {
+		case "driverFailure": return `failed: ${error.cause.message}`;
+		case "unexpectedThrow": return "unexpected error";
+		case "updateUnsupported": return "update not supported";
+	}
+}
+function renderEvent(event, deps) {
+	const { clack, config } = deps;
+	switch (event.kind) {
+		case "applySummary":
+			clack.logMessage(applySummaryLine(event));
+			return;
+		case "deployFailure":
+			renderDeployError(event.error, clack);
+			return;
+		case "deploySuccess":
+			clack.logSuccess(`${event.environment}: ${event.resourceCount} resources reconciled`);
+			return;
+		case "resourceOpFailed":
+			clack.logError(`${event.resourceKind}.${event.key} ${describeApplyError(event.error)}`);
+			return;
+		case "resourceOpNoop":
+			clack.logMessage(`${event.resourceKind}.${event.key} unchanged`);
+			return;
+		case "resourceOpStarted": return;
+		case "resourceOpSucceeded":
+			renderResourceOpSucceeded(event, clack);
+			return;
+		case "stateWritten": clack.logMessage(`State written to ${formatStateLabel(config, event.environment)}`);
+	}
+}
+//#endregion
+//#region src/core/derive-price-fields.ts
+/**
+* Translate a Mantle-style optional price into the Open Cloud wire shape.
+*
+* `desired.price === undefined` (no price declared) becomes
+* `{ isForSale: false }` and the `price` key is omitted entirely. A defined
+* price (including `0`) becomes `{ isForSale: true, price }`. Both
+* `developerProduct` create and update paths share this helper so the
+* "absent ⇒ off-sale" semantics live in exactly one place.
+*
+* @param desired - Object carrying the user-declared `price`.
+* @returns The wire-shape `{ isForSale, price? }` fragment.
+*
+* @example
+*
+* ```ts
+* import { derivePriceFields } from "@bedrock-rbx/core";
+*
+* expect(derivePriceFields({ price: undefined })).toStrictEqual({ isForSale: false });
+* expect(derivePriceFields({ price: 250 })).toStrictEqual({ isForSale: true, price: 250 });
+* ```
+*/
+function derivePriceFields(desired) {
+	if (desired.price === void 0) return { isForSale: false };
+	return {
+		isForSale: true,
+		price: desired.price
+	};
+}
+//#endregion
+//#region src/core/plan-follow-up-patch.ts
+/**
+* Plan the optional follow-up PATCH body needed after a developer-product
+* create POST. Returns `undefined` when no PATCH is required: either the
+* user did not declare `storePageEnabled`, or the create response already
+* matches the desired value.
+*
+* @param desired - Desired state for the developer product being created.
+* @param createResponse - The `storePageEnabled` value reported by the create POST response.
+* @returns The PATCH body to issue, or `undefined` when no follow-up is needed.
+*/
+function planFollowUpPatch(desired, createResponse) {
+	if (desired.storePageEnabled === void 0) return;
+	if (desired.storePageEnabled === createResponse.storePageEnabled) return;
+	return { storePageEnabled: desired.storePageEnabled };
+}
+//#endregion
+//#region src/adapters/developer-product-driver.ts
+/**
+* Wraps {@link DeveloperProductsClient} as a `ResourceDriver<"developerProduct">`
+* that maps a desired-state entry to an ocale create or update call and the
+* response back to a `ResourceCurrentState<"developerProduct">`. The
+* `update` path consumes the upstream `204 No Content` response and
+* synthesizes the post-update `ResourceCurrentState` from `desired` plus
+* the existing `current.outputs`, carrying `iconImageAssetId` forward when
+* present.
+*
+* Upstream `OpenCloudError` results pass through as `Result` failures.
+*
+* @param deps - Injected ocale client and owning universe.
+* @returns A driver indexable by `"developerProduct"` in a `DriverRegistry`.
+*
+* @example
+*
+* ```ts
+* import type { HttpClient } from "@bedrock-rbx/ocale";
+* import { DeveloperProductsClient } from "@bedrock-rbx/ocale/developer-products";
+* import {
+*     asResourceKey,
+*     asRobloxAssetId,
+*     createDeveloperProductDriver,
+* } from "@bedrock-rbx/core";
+*
+* const httpClient: HttpClient = {
+*     async request() {
+*         return {
+*             data: {
+*                 body: {
+*                     createdTimestamp: "2024-01-15T10:30:00.000Z",
+*                     description: "Stocks the player up with 1,000 premium gems.",
 *                     iconImageAssetId: null,
 *                     isForSale: false,
 *                     isImmutable: false,
@@ -696,12 +1430,16 @@ function planFollowUpPatch(desired, createResponse) {
 * ```
 */
 function createDeveloperProductDriver(deps) {
+	const effective = {
+		...deps,
+		readFile: withRedactedIcon(deps.readFile)
+	};
 	return {
 		async create(desired) {
-			return createOne(deps, desired);
+			return createOne(effective, desired);
 		},
 		async update(current, desired) {
-			return updateOne(deps, {
+			return updateOne(effective, {
 				current,
 				desired
 			});
@@ -853,12 +1591,16 @@ async function updateOne(deps, { current, desired }) {
 * ```
 */
 function createGamePassDriver(deps) {
+	const effective = {
+		...deps,
+		readFile: withRedactedIcon(deps.readFile)
+	};
 	return {
 		async create(desired) {
-			return createGamePass(deps, desired);
+			return createGamePass(effective, desired);
 		},
 		async update(current, desired) {
-			return updateGamePass(deps, {
+			return updateGamePass(effective, {
 				current,
 				desired
 			});
@@ -930,62 +1672,6 @@ async function updateGamePass(deps, states) {
 	});
 }
 //#endregion
-//#region src/core/environment.ts
-/**
-* Source pattern for environment names, including `^` and `$` anchors.
-* Letters, digits, `-`, `_`, length 1-64.
-*
-* Exported so the config schema can validate `environments` keys against
-* the same alphabet and length cap that adapters enforce on storage
-* identifiers. Single source of truth: changing the alphabet here changes
-* both the runtime check and the schema-level key constraint.
-*
-* Anchors are embedded so callers do not have to re-add them, matching
-* the `RESOURCE_KEY_PATTERN_SOURCE` convention in `types/ids.ts`.
-*/
-const ENV_NAME_PATTERN_SOURCE = "^[A-Za-z0-9_-]{1,64}$";
-const ENVIRONMENT_NAME_PATTERN = new RegExp(ENV_NAME_PATTERN_SOURCE);
-/**
-* Validate an environment name at a state-adapter boundary.
-*
-* Adapters that map environment names onto filesystem-like identifiers
-* (gist filenames, S3 keys) must reject names that could collide or escape
-* their storage layout. This helper accepts letters, digits, `-`, and `_`
-* only, with length between 1 and 64, and returns a `StateError` for
-* anything outside that set so the adapter can fail loudly instead of
-* silently stripping characters.
-*
-* @example
-*
-* ```ts
-* import { validateEnvironmentName } from "@bedrock-rbx/core";
-*
-* const ok = validateEnvironmentName("production");
-* expect(ok.success).toBeTrue();
-*
-* const bad = validateEnvironmentName("prod/staging");
-* expect(bad.success).toBeFalse();
-* ```
-*
-* @param environment - Raw environment name supplied by a caller.
-* @returns `Ok(environment)` when the name is safe to use, or
-* `Err(StateError)` with a descriptive reason when it is not.
-*/
-function validateEnvironmentName(environment) {
-	if (!ENVIRONMENT_NAME_PATTERN.test(environment)) return {
-		err: {
-			file: environment,
-			kind: "stateError",
-			reason: `invalid environment name: must match ${String(ENVIRONMENT_NAME_PATTERN)}`
-		},
-		success: false
-	};
-	return {
-		data: environment,
-		success: true
-	};
-}
-//#endregion
 //#region src/core/state-file.ts
 const envelopeSchema = type({
 	$bedrock: { version: "1" },
@@ -1197,12 +1883,26 @@ function toGistFile(entry) {
 		size
 	};
 }
-function mapHttpError({ file, gistId, status }) {
+function isRateLimited(headers) {
+	return headers.get("retry-after") !== null || headers.get("x-ratelimit-remaining") === "0";
+}
+function rateLimitReason(status, headers) {
+	const retryAfter = headers.get("retry-after");
+	if (retryAfter !== null) return `rate limited (${status}): retry after ${retryAfter}s`;
+	return `rate limited (${status})`;
+}
+function mapHttpError({ file, gistId, response }) {
+	const { headers, status } = response;
 	if (status === 404) return {
 		file,
 		kind: "stateError",
 		reason: `gist ${gistId} not found: check gistId`
 	};
+	if (status === 403 && isRateLimited(headers)) return {
+		file,
+		kind: "stateError",
+		reason: rateLimitReason(status, headers)
+	};
 	if (status === 401 || status === 403) return {
 		file,
 		kind: "stateError",
@@ -1264,7 +1964,7 @@ async function fetchGistBody(ctx, file) {
 		err: mapHttpError({
 			file,
 			gistId: ctx.gistId,
-			status: response.status
+			response
 		}),
 		success: false
 	};
@@ -1386,7 +2086,7 @@ async function writePath(ctx, state) {
 		err: mapHttpError({
 			file,
 			gistId: ctx.gistId,
-			status: response.status
+			response
 		}),
 		success: false
 	};
@@ -1466,612 +2166,350 @@ const UNIVERSE_SINGLETON_KEY = asResourceKey("main");
 //#endregion
 //#region src/adapters/place-driver.ts
 /**
-* Wraps {@link PlacesClient} as a `ResourceDriver<"place">`. `create` and
-* `update` are both thin wrappers over a shared publish helper because the
-* upstream Open Cloud call is identical either way: there is no "create
-* place" endpoint (the place is user-supplied input), only "publish version".
-*
-* Format is detected from the file extension (`.rbxl` → binary,
-* `.rbxlx` → XML); any other extension returns an `ApiError`-backed failure
-* without hitting the network.
-*
-* @param deps - Injected ocale client, file reader, and owning universe.
-* @returns A driver indexable by `"place"` in a `DriverRegistry`.
-* @throws Whatever `deps.readFile` rejects with.
-*
-* @example
-*
-* ```ts
-* import type { HttpClient } from "@bedrock-rbx/ocale";
-* import { PlacesClient } from "@bedrock-rbx/ocale/places";
-* import {
-*     asResourceKey,
-*     asRobloxAssetId,
-*     asSha256Hex,
-*     createPlaceDriver,
-* } from "@bedrock-rbx/core";
-*
-* const httpClient: HttpClient = {
-*     async request() {
-*         return {
-*             data: { body: { versionNumber: 1 }, headers: {}, status: 200 },
-*             success: true,
-*         };
-*     },
-* };
-*
-* const driver = createPlaceDriver({
-*     client: new PlacesClient({
-*         apiKey: "rbx-your-key",
-*         httpClient,
-*         sleep: async () => {},
-*     }),
-*     readFile: async () =>
-*         new Uint8Array([
-*             0x3c, 0x72, 0x6f, 0x62, 0x6c, 0x6f, 0x78, 0x21, 0x89, 0xff, 0x0d, 0x0a, 0x1a,
-*             0x0a,
-*         ]),
-*     universeId: asRobloxAssetId("1234567890"),
-* });
-*
-* return driver
-*     .create({
-*         description: undefined,
-*         displayName: undefined,
-*         fileHash: asSha256Hex(
-*             "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-*         ),
-*         filePath: "places/start.rbxl",
-*         key: asResourceKey("start-place"),
-*         kind: "place",
-*         placeId: asRobloxAssetId("4711"),
-*         serverSize: undefined,
-*     })
-*     .then((result) => {
-*         expect(result.success).toBeTrue();
-*         if (result.success) {
-*             expect(result.data.outputs.versionNumber).toBe(1);
-*         }
-*     });
-* ```
-*/
-function createPlaceDriver(deps) {
-	return {
-		async create(desired) {
-			return publishPlace(deps, desired);
-		},
-		async update(_current, desired) {
-			return publishPlace(deps, desired);
-		}
-	};
-}
-function buildMetadataParameters(universeId, desired) {
-	const metadata = PLACE_MANAGED_METADATA_FIELDS.reduce((accumulator, field) => {
-		const value = desired[field];
-		return value === void 0 ? accumulator : {
-			...accumulator,
-			[field]: value
-		};
-	}, {});
-	if (Object.keys(metadata).length === 0) return;
-	return {
-		...metadata,
-		placeId: desired.placeId,
-		universeId
-	};
-}
-function detectFormat(filePath) {
-	if (filePath.endsWith(".rbxlx")) return "rbxlx";
-	if (filePath.endsWith(".rbxl")) return "rbxl";
-}
-async function publishVersion(deps, desired) {
-	const format = detectFormat(desired.filePath);
-	if (format === void 0) return {
-		err: new ApiError(`Unsupported place file extension for ${desired.filePath}; expected .rbxl or .rbxlx`, { statusCode: 0 }),
-		success: false
-	};
-	const body = await deps.readFile(desired.filePath);
-	return deps.client.publish({
-		body: Uint8Array.from(body),
-		format,
-		placeId: desired.placeId,
-		universeId: deps.universeId
-	});
-}
-async function publishPlace(deps, desired) {
-	const publishResult = await publishVersion(deps, desired);
-	if (!publishResult.success) return publishResult;
-	const metadataParameters = buildMetadataParameters(deps.universeId, desired);
-	if (metadataParameters !== void 0) {
-		const metadataResult = await deps.client.update(metadataParameters);
-		if (!metadataResult.success) return metadataResult;
-	}
-	return {
-		data: {
-			...desired,
-			outputs: publishResult.data
-		},
-		success: true
-	};
-}
-//#endregion
-//#region src/adapters/universe-driver.ts
-/**
-* Wraps {@link UniversesClient} as a `ResourceDriver<"universe">`. `create`
-* and `update` both delegate to a shared reconcile helper because Open
-* Cloud cannot mint universes; the user supplies an existing `universeId`
-* and bedrock adopts the universe on first apply.
-*
-* A `NotFound` error (HTTP 404) from `UniversesClient.update` is repackaged
-* as an adoption-error `ApiError` whose message names the config key and
-* the `universeId`, so operators can tell adoption failure apart from
-* transient upstream errors. A successful response whose `rootPlaceId` is
-* absent surfaces as an `ApiError` with status 200, mirroring the
-* malformed-response guard in `GamePassDriver`.
+* Wraps {@link PlacesClient} as a `ResourceDriver<"place">`. `create` and
+* `update` are both thin wrappers over a shared publish helper because the
+* upstream Open Cloud call is identical either way: there is no "create
+* place" endpoint (the place is user-supplied input), only "publish version".
 *
-* When `displayName` is declared, the driver routes that field through
-* `PlacesClient.update` on the root place after the universe PATCH
-* succeeds. A subsequent places failure surfaces to the caller as the
-* driver's error result without rolling back the prior universe patch,
-* so callers observing a partial failure should reconcile by
-* reapplying rather than assuming the universe-level fields are
-* unchanged.
+* Format is detected from the file extension (`.rbxl` → binary,
+* `.rbxlx` → XML); any other extension returns an `ApiError`-backed failure
+* without hitting the network.
 *
-* @param deps - Injected ocale clients (universes plus places for the
-*   read-only universe fields Roblox derives from the root place).
-* @returns A driver indexable by `"universe"` in a `DriverRegistry`.
+* @param deps - Injected ocale client, file reader, and owning universe.
+* @returns A driver indexable by `"place"` in a `DriverRegistry`.
+* @throws Whatever `deps.readFile` rejects with.
 *
 * @example
 *
 * ```ts
 * import type { HttpClient } from "@bedrock-rbx/ocale";
 * import { PlacesClient } from "@bedrock-rbx/ocale/places";
-* import { UniversesClient } from "@bedrock-rbx/ocale/universes";
-* import { validUniverseBody } from "@bedrock-rbx/ocale/testing";
 * import {
+*     asResourceKey,
 *     asRobloxAssetId,
-*     createUniverseDriver,
-*     UNIVERSE_SINGLETON_KEY,
+*     asSha256Hex,
+*     createPlaceDriver,
 * } from "@bedrock-rbx/core";
 *
-* const universeBodyHttpClient: HttpClient = {
+* const httpClient: HttpClient = {
 *     async request() {
 *         return {
-*             data: {
-*                 body: validUniverseBody({
-*                     path: "universes/1234567890",
-*                     rootPlace: "universes/1234567890/places/4711",
-*                 }),
-*                 headers: {},
-*                 status: 200,
-*             },
+*             data: { body: { versionNumber: 1 }, headers: {}, status: 200 },
 *             success: true,
 *         };
 *     },
 * };
 *
-* const driver = createUniverseDriver({
-*     places: new PlacesClient({
-*         apiKey: "rbx-your-key",
-*         httpClient: universeBodyHttpClient,
-*         sleep: async () => {},
-*     }),
-*     universes: new UniversesClient({
+* const driver = createPlaceDriver({
+*     client: new PlacesClient({
 *         apiKey: "rbx-your-key",
-*         httpClient: universeBodyHttpClient,
+*         httpClient,
 *         sleep: async () => {},
 *     }),
+*     readFile: async () =>
+*         new Uint8Array([
+*             0x3c, 0x72, 0x6f, 0x62, 0x6c, 0x6f, 0x78, 0x21, 0x89, 0xff, 0x0d, 0x0a, 0x1a,
+*             0x0a,
+*         ]),
+*     universeId: asRobloxAssetId("1234567890"),
 * });
 *
 * return driver
 *     .create({
-*         consoleEnabled: undefined,
-*         desktopEnabled: true,
+*         description: undefined,
 *         displayName: undefined,
-*         key: UNIVERSE_SINGLETON_KEY,
-*         kind: "universe",
-*         mobileEnabled: undefined,
-*         privateServerPriceRobux: undefined,
-*         tabletEnabled: undefined,
-*         universeId: asRobloxAssetId("1234567890"),
-*         voiceChatEnabled: true,
-*         vrEnabled: undefined,
+*         fileHash: asSha256Hex(
+*             "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+*         ),
+*         filePath: "places/start.rbxl",
+*         key: asResourceKey("start-place"),
+*         kind: "place",
+*         placeId: asRobloxAssetId("4711"),
+*         serverSize: undefined,
 *     })
 *     .then((result) => {
 *         expect(result.success).toBeTrue();
 *         if (result.success) {
-*             expect(result.data.outputs.rootPlaceId).toBe("4711");
+*             expect(result.data.outputs.versionNumber).toBe(1);
 *         }
 *     });
 * ```
 */
-function createUniverseDriver(deps) {
+function createPlaceDriver(deps) {
 	return {
 		async create(desired) {
-			return reconcileUniverse({
-				deps,
-				desired
-			});
+			return publishPlace(deps, desired);
 		},
 		async update(_current, desired) {
-			return reconcileUniverse({
-				deps,
-				desired
-			});
+			return publishPlace(deps, desired);
 		}
 	};
 }
-function toCurrentState(desired, rootPlaceId) {
-	return {
-		...desired,
-		outputs: { rootPlaceId: asRobloxAssetId(rootPlaceId) }
-	};
-}
-function buildParameters(desired) {
-	const base = UNIVERSE_MANAGED_FLAGS.reduce((accumulator, flag) => {
-		const isEnabled = desired[flag];
-		return isEnabled === void 0 ? accumulator : {
+function buildMetadataParameters(universeId, desired) {
+	const metadata = PLACE_MANAGED_METADATA_FIELDS.reduce((accumulator, field) => {
+		const value = desired[field];
+		return value === void 0 ? accumulator : {
 			...accumulator,
-			[flag]: isEnabled
+			[field]: value
 		};
-	}, { universeId: desired.universeId });
+	}, {});
+	if (Object.keys(metadata).length === 0) return;
 	return {
-		..."privateServerPriceRobux" in desired ? {
-			...base,
-			privateServerPriceRobux: desired.privateServerPriceRobux
-		} : base,
-		...copyDeclaredSocialLinks(desired)
+		...metadata,
+		placeId: desired.placeId,
+		universeId
 	};
 }
-function wrapUpdateError(err, desired) {
-	if (err instanceof ApiError && err.statusCode === 404) return new ApiError(`Universe ${desired.universeId} (key '${desired.key}') was not found; adoption failed`, { statusCode: 404 });
-	return err;
-}
-function hasUniverseLevelUpdate(desired) {
-	if (UNIVERSE_MANAGED_FLAGS.some((flag) => desired[flag] !== void 0)) return true;
-	if ("privateServerPriceRobux" in desired) return true;
-	return SOCIAL_LINK_FIELDS.some((field) => field in desired);
+function detectFormat(filePath) {
+	if (filePath.endsWith(".rbxlx")) return "rbxlx";
+	if (filePath.endsWith(".rbxl")) return "rbxl";
 }
-async function resolveUniverse(deps, desired) {
-	const result = hasUniverseLevelUpdate(desired) ? await deps.universes.update(buildParameters(desired)) : await deps.universes.get({ universeId: desired.universeId });
-	if (!result.success) return {
-		err: wrapUpdateError(result.err, desired),
-		success: false
-	};
-	const { rootPlaceId } = result.data;
-	if (rootPlaceId === void 0) return {
-		err: new ApiError(`Malformed universe response for ${desired.universeId}: rootPlaceId missing`, { statusCode: 200 }),
+async function publishVersion(deps, desired) {
+	const format = detectFormat(desired.filePath);
+	if (format === void 0) return {
+		err: new ApiError(`Unsupported place file extension for ${desired.filePath}; expected .rbxl or .rbxlx`, { statusCode: 0 }),
 		success: false
-	};
-	return {
-		data: { rootPlaceId },
-		success: true
-	};
-}
-async function reconcileUniverse(inputs) {
-	const { deps, desired } = inputs;
-	const universeResult = await resolveUniverse(deps, desired);
-	if (!universeResult.success) return universeResult;
-	const { rootPlaceId } = universeResult.data;
-	if (desired.displayName !== void 0) {
-		const placesResult = await deps.places.update({
-			displayName: desired.displayName,
-			placeId: rootPlaceId,
-			universeId: desired.universeId
-		});
-		if (!placesResult.success) return {
-			err: placesResult.err,
-			success: false
-		};
-	}
-	return {
-		data: toCurrentState(desired, rootPlaceId),
-		success: true
-	};
-}
-//#endregion
-//#region src/cli/clack-port.ts
-/**
-* Construct a `ClackPort` whose methods delegate to `@clack/prompts`. The
-* resulting port writes to `process.stdout` via clack's defaults. Kept in
-* its own module so consumers that never need the clack-backed rendering
-* (programmatic deploys, custom adapters) do not pull `@clack/prompts`
-* into their bundle.
-*
-* @example
-*
-* ```ts
-* import { createClackPort } from "@bedrock-rbx/core";
-*
-* const port = createClackPort();
-*
-* expect(typeof port.logSuccess).toBe("function");
-* ```
-*
-* @returns A port whose six methods each invoke the matching clack helper.
-*/
-function createClackPort() {
-	return {
-		cancel: (message) => {
-			cancel(message);
-		},
-		intro: (message) => {
-			intro(message);
-		},
-		logError: (message) => {
-			log.error(message);
-		},
-		logMessage: (message) => {
-			log.message(message);
-		},
-		logSuccess: (message) => {
-			log.success(message);
-		},
-		outro: (message) => {
-			outro(message);
-		}
-	};
-}
-//#endregion
-//#region src/core/validate-universe-xor.ts
-/**
-* Walk the loose authored-shape and surface every place the
-* universeId-XOR-between-root-and-env rule is violated. Pure: returns
-* the issue list; the caller hands it to arktype's `ctx.reject` so each
-* one lands at the offending config path. The schema's runtime narrow
-* uses this to enforce the rule at validation time before the validated
-* value is cast to the strict `Config` discriminated union.
-*
-* @param value - Parsed config the schema is validating.
-* @returns Zero or more issues. Empty when the config satisfies the rule.
-*/
-function collectUniverseIdIssues(value) {
-	const rootUniverseId = value.universe?.universeId;
-	const hasRootUniverseBlock = value.universe !== void 0;
-	const environmentEntries = Object.entries(value.environments);
-	const hasEnvironmentUniverseId = environmentEntries.some(([, environment]) => environment.universe?.universeId !== void 0);
-	const environmentIssues = collectEnvironmentIssues(rootUniverseId, environmentEntries);
-	const rootIssues = hasRootUniverseBlock && rootUniverseId === void 0 && !hasEnvironmentUniverseId ? [{
-		message: "universeId must be declared on the root universe block, or on every environment that declares its own universe overlay.",
-		path: ["universe", "universeId"]
-	}] : [];
-	return [...environmentIssues, ...rootIssues];
-}
-function collectEnvironmentIssues(rootUniverseId, environmentEntries) {
-	return environmentEntries.flatMap(([environmentName, environment]) => {
-		if (environment.universe === void 0) return [];
-		if (rootUniverseId !== void 0 && environment.universe.universeId !== void 0) return [{
-			message: "universeId is declared at the root universe block; remove it from this environment overlay (root is authoritative) or remove it from the root and declare it on every environment.",
-			path: [
-				"environments",
-				environmentName,
-				"universe",
-				"universeId"
-			]
-		}];
-		if (rootUniverseId === void 0 && environment.universe.universeId === void 0) return [{
-			message: "universeId must be declared on this environment overlay because the root universe block does not provide one.",
-			path: [
-				"environments",
-				environmentName,
-				"universe",
-				"universeId"
-			]
-		}];
-		return [];
+	};
+	const body = await deps.readFile(desired.filePath);
+	return deps.client.publish({
+		body: Uint8Array.from(body),
+		format,
+		placeId: desired.placeId,
+		universeId: deps.universeId
 	});
 }
+async function publishPlace(deps, desired) {
+	const publishResult = await publishVersion(deps, desired);
+	if (!publishResult.success) return publishResult;
+	const metadataParameters = buildMetadataParameters(deps.universeId, desired);
+	if (metadataParameters !== void 0) {
+		const metadataResult = await deps.client.update(metadataParameters);
+		if (!metadataResult.success) return metadataResult;
+	}
+	return {
+		data: {
+			...desired,
+			outputs: publishResult.data
+		},
+		success: true
+	};
+}
 //#endregion
-//#region src/core/schema.ts
+//#region src/adapters/universe-driver.ts
 /**
-* Narrow a `StateConfig` to the `GistStateConfig` arm. The `(string & {})`
-* autocomplete idiom prevents TypeScript from narrowing on
-* `backend === "gist"` alone, so dispatch sites use this guard to
-* preserve the `gistId` field shape.
+* Wraps {@link UniversesClient} as a `ResourceDriver<"universe">`. `create`
+* and `update` both delegate to a shared reconcile helper because Open
+* Cloud cannot mint universes; the user supplies an existing `universeId`
+* and bedrock adopts the universe on first apply.
+*
+* A `NotFound` error (HTTP 404) from `UniversesClient.update` is repackaged
+* as an adoption-error `ApiError` whose message names the config key and
+* the `universeId`, so operators can tell adoption failure apart from
+* transient upstream errors. A successful response whose `rootPlaceId` is
+* absent surfaces as an `ApiError` with status 200, mirroring the
+* malformed-response guard in `GamePassDriver`.
+*
+* When `displayName` is declared, the driver routes that field through
+* `PlacesClient.update` on the root place after the universe PATCH
+* succeeds. A subsequent places failure surfaces to the caller as the
+* driver's error result without rolling back the prior universe patch,
+* so callers observing a partial failure should reconcile by
+* reapplying rather than assuming the universe-level fields are
+* unchanged.
+*
+* @param deps - Injected ocale clients (universes plus places for the
+*   read-only universe fields Roblox derives from the root place).
+* @returns A driver indexable by `"universe"` in a `DriverRegistry`.
 *
 * @example
 *
 * ```ts
-* import { isGistStateConfig } from "@bedrock-rbx/core";
-* import type { StateConfig } from "@bedrock-rbx/core/config";
+* import type { HttpClient } from "@bedrock-rbx/ocale";
+* import { PlacesClient } from "@bedrock-rbx/ocale/places";
+* import { UniversesClient } from "@bedrock-rbx/ocale/universes";
+* import { validUniverseBody } from "@bedrock-rbx/ocale/testing";
+* import {
+*     asRobloxAssetId,
+*     createUniverseDriver,
+*     UNIVERSE_SINGLETON_KEY,
+* } from "@bedrock-rbx/core";
 *
-* const config: StateConfig = { backend: "gist", gistId: "abc" };
+* const universeBodyHttpClient: HttpClient = {
+*     async request() {
+*         return {
+*             data: {
+*                 body: validUniverseBody({
+*                     path: "universes/1234567890",
+*                     rootPlace: "universes/1234567890/places/4711",
+*                 }),
+*                 headers: {},
+*                 status: 200,
+*             },
+*             success: true,
+*         };
+*     },
+* };
 *
-* expect(isGistStateConfig(config)).toBeTrue();
-* if (isGistStateConfig(config)) {
-*     expect(config.gistId).toBe("abc");
-* }
-* ```
+* const driver = createUniverseDriver({
+*     places: new PlacesClient({
+*         apiKey: "rbx-your-key",
+*         httpClient: universeBodyHttpClient,
+*         sleep: async () => {},
+*     }),
+*     universes: new UniversesClient({
+*         apiKey: "rbx-your-key",
+*         httpClient: universeBodyHttpClient,
+*         sleep: async () => {},
+*     }),
+* });
 *
-* @param config - Resolved state config to inspect.
-* @returns `true` when `config.backend === "gist"`; otherwise `false`.
+* return driver
+*     .create({
+*         consoleEnabled: undefined,
+*         desktopEnabled: true,
+*         displayName: undefined,
+*         key: UNIVERSE_SINGLETON_KEY,
+*         kind: "universe",
+*         mobileEnabled: undefined,
+*         privateServerPriceRobux: undefined,
+*         tabletEnabled: undefined,
+*         universeId: asRobloxAssetId("1234567890"),
+*         voiceChatEnabled: true,
+*         vrEnabled: undefined,
+*     })
+*     .then((result) => {
+*         expect(result.success).toBeTrue();
+*         if (result.success) {
+*             expect(result.data.outputs.rootPlaceId).toBe("4711");
+*         }
+*     });
+* ```
 */
-function isGistStateConfig(config) {
-	return config.backend === "gist";
+function createUniverseDriver(deps) {
+	return {
+		async create(desired) {
+			return reconcileUniverse({
+				deps,
+				desired
+			});
+		},
+		async update(_current, desired) {
+			return reconcileUniverse({
+				deps,
+				desired
+			});
+		}
+	};
 }
-const OPTIONAL_BOOLEAN$2 = "boolean | undefined";
-const OPTIONAL_STRING = "string | undefined";
-/**
-* Shared arktype constraint for any optional positive-integer field.
-* Reused by per-kind entry schemas so positive-integer fields validate
-* identically.
-*/
-const OPTIONAL_POSITIVE_INTEGER = "(number.integer >= 1) | undefined";
-/**
-* Shared arktype constraint for any optional Robux-price field. The schema
-* rejects negatives, fractional values, `NaN`, and `Infinity` at config
-* validation time so a malformed price surfaces with a path attributing the
-* failure to the offending field, rather than slipping through to the
-* Roblox API and surfacing as an opaque error at apply time. Per-kind entry
-* schemas reuse this constant so all Robux-price fields validate
-* identically.
-*/
-const OPTIONAL_ROBUX_PRICE = "number.integer >= 0 | undefined";
-const gamePassEntry = type({
-	"name": "string",
-	"description": "string",
-	"icon": iconMap,
-	"price?": OPTIONAL_ROBUX_PRICE
-});
-const passesCollection = type({ [`[/${RESOURCE_KEY_PATTERN_SOURCE}/]`]: gamePassEntry }).onUndeclaredKey("reject");
-const developerProductEntry = type({
-	"name": "string",
-	"description": "string",
-	"icon?": iconMap,
-	"isRegionalPricingEnabled?": OPTIONAL_BOOLEAN$2,
-	"price?": OPTIONAL_ROBUX_PRICE,
-	"storePageEnabled?": OPTIONAL_BOOLEAN$2
-}).onUndeclaredKey("reject");
-const productsCollection = type({ [`[/${RESOURCE_KEY_PATTERN_SOURCE}/]`]: developerProductEntry }).onUndeclaredKey("reject");
-const ROBLOX_ID_DIGITS = "string.digits";
-const placeEntry = type({
-	"description?": OPTIONAL_STRING,
-	"displayName?": OPTIONAL_STRING,
-	"filePath": "string",
-	"serverSize?": OPTIONAL_POSITIVE_INTEGER
-}).onUndeclaredKey("reject");
-const placesCollection = type({ [`[/${RESOURCE_KEY_PATTERN_SOURCE}/]`]: placeEntry }).onUndeclaredKey("reject");
-const socialLinkOrUndefined$1 = type({
-	title: "string",
-	uri: "string"
-}).onUndeclaredKey("reject").or("undefined");
-const universeEntry = type({
-	"consoleEnabled?": OPTIONAL_BOOLEAN$2,
-	"desktopEnabled?": OPTIONAL_BOOLEAN$2,
-	"discordSocialLink?": socialLinkOrUndefined$1,
-	"displayName?": OPTIONAL_STRING,
-	"facebookSocialLink?": socialLinkOrUndefined$1,
-	"guildedSocialLink?": socialLinkOrUndefined$1,
-	"mobileEnabled?": OPTIONAL_BOOLEAN$2,
-	"privateServerPriceRobux?": OPTIONAL_ROBUX_PRICE,
-	"robloxGroupSocialLink?": socialLinkOrUndefined$1,
-	"tabletEnabled?": OPTIONAL_BOOLEAN$2,
-	"twitchSocialLink?": socialLinkOrUndefined$1,
-	"twitterSocialLink?": socialLinkOrUndefined$1,
-	"universeId?": ROBLOX_ID_DIGITS,
-	"voiceChatEnabled?": OPTIONAL_BOOLEAN$2,
-	"vrEnabled?": OPTIONAL_BOOLEAN$2,
-	"youtubeSocialLink?": socialLinkOrUndefined$1
-}).onUndeclaredKey("reject");
-const stateConfig = type({
-	"backend": "string",
-	"gistId?": "string > 0"
-}).onUndeclaredKey("reject");
-const gamePassOverlay = type({
-	"description?": "string",
-	"icon?": iconMap,
-	"name?": "string",
-	"price?": OPTIONAL_ROBUX_PRICE
-}).onUndeclaredKey("reject");
-const passesOverlayCollection = type({ [`[/${RESOURCE_KEY_PATTERN_SOURCE}/]`]: gamePassOverlay }).onUndeclaredKey("reject");
-const developerProductOverlay = type({
-	"description?": "string",
-	"icon?": iconMap,
-	"isRegionalPricingEnabled?": OPTIONAL_BOOLEAN$2,
-	"name?": "string",
-	"price?": OPTIONAL_ROBUX_PRICE,
-	"storePageEnabled?": OPTIONAL_BOOLEAN$2
-}).onUndeclaredKey("reject");
-const productsOverlayCollection = type({ [`[/${RESOURCE_KEY_PATTERN_SOURCE}/]`]: developerProductOverlay }).onUndeclaredKey("reject");
-const placeOverlay = type({
-	"description?": OPTIONAL_STRING,
-	"displayName?": OPTIONAL_STRING,
-	"filePath?": "string",
-	"placeId": ROBLOX_ID_DIGITS,
-	"serverSize?": OPTIONAL_POSITIVE_INTEGER
-}).onUndeclaredKey("reject");
-const environmentEntry = type({
-	"label?": OPTIONAL_STRING,
-	"passes?": passesOverlayCollection,
-	"places?": type({ [`[/${RESOURCE_KEY_PATTERN_SOURCE}/]`]: placeOverlay }).onUndeclaredKey("reject"),
-	"products?": productsOverlayCollection,
-	"state?": stateConfig,
-	"universe?": universeEntry
-}).onUndeclaredKey("reject");
-const rootSchema = type({
-	"displayNamePrefix?": type({
-		"enabled?": OPTIONAL_BOOLEAN$2,
-		"format?": OPTIONAL_STRING
-	}).onUndeclaredKey("reject"),
-	"environments": type({ [`[/${ENV_NAME_PATTERN_SOURCE}/]`]: environmentEntry }).onUndeclaredKey("reject").narrow((value, ctx) => {
-		if (Object.keys(value).length === 0) return ctx.mustBe("an environments record with at least one declared environment");
-		return true;
-	}),
-	"extends?": "unknown",
-	"passes?": passesCollection,
-	"places?": placesCollection,
-	"products?": productsCollection,
-	"state?": stateConfig,
-	"universe?": universeEntry
-}).onUndeclaredKey("reject").narrow((value, ctx) => {
-	return collectUniverseIdIssues(value).reduce((_accumulator, issue) => {
-		return ctx.reject({
-			message: issue.message,
-			path: [...issue.path]
+function toCurrentState(desired, rootPlaceId) {
+	return {
+		...desired,
+		outputs: { rootPlaceId: asRobloxAssetId(rootPlaceId) }
+	};
+}
+function buildParameters(desired) {
+	const base = UNIVERSE_MANAGED_FLAGS.reduce((accumulator, flag) => {
+		const isEnabled = desired[flag];
+		return isEnabled === void 0 ? accumulator : {
+			...accumulator,
+			[flag]: isEnabled
+		};
+	}, { universeId: desired.universeId });
+	return {
+		..."privateServerPriceRobux" in desired ? {
+			...base,
+			privateServerPriceRobux: desired.privateServerPriceRobux
+		} : base,
+		...copyDeclaredSocialLinks(desired)
+	};
+}
+function wrapUpdateError(err, desired) {
+	if (err instanceof ApiError && err.statusCode === 404) return new ApiError(`Universe ${desired.universeId} (key '${desired.key}') was not found; adoption failed`, { statusCode: 404 });
+	return err;
+}
+function hasUniverseLevelUpdate(desired) {
+	if (UNIVERSE_MANAGED_FLAGS.some((flag) => desired[flag] !== void 0)) return true;
+	if ("privateServerPriceRobux" in desired) return true;
+	return SOCIAL_LINK_FIELDS.some((field) => field in desired);
+}
+async function resolveUniverse(deps, desired) {
+	const result = hasUniverseLevelUpdate(desired) ? await deps.universes.update(buildParameters(desired)) : await deps.universes.get({ universeId: desired.universeId });
+	if (!result.success) return {
+		err: wrapUpdateError(result.err, desired),
+		success: false
+	};
+	const { rootPlaceId } = result.data;
+	if (rootPlaceId === void 0) return {
+		err: new ApiError(`Malformed universe response for ${desired.universeId}: rootPlaceId missing`, { statusCode: 200 }),
+		success: false
+	};
+	return {
+		data: { rootPlaceId },
+		success: true
+	};
+}
+async function reconcileUniverse(inputs) {
+	const { deps, desired } = inputs;
+	const universeResult = await resolveUniverse(deps, desired);
+	if (!universeResult.success) return universeResult;
+	const { rootPlaceId } = universeResult.data;
+	if (desired.displayName !== void 0) {
+		const placesResult = await deps.places.update({
+			displayName: desired.displayName,
+			placeId: rootPlaceId,
+			universeId: desired.universeId
 		});
-	}, true);
-});
+		if (!placesResult.success) return {
+			err: placesResult.err,
+			success: false
+		};
+	}
+	return {
+		data: toCurrentState(desired, rootPlaceId),
+		success: true
+	};
+}
+//#endregion
+//#region src/cli/clack-port.ts
 /**
-* Validate a parsed config value against the runtime schema. Returns the
-* validated `Config` on success or a `validationFailed` `ConfigError` with
-* one issue per problem, each attributed to a field path. `sourceFile`
-* appears in the error so callers can point a human at the offending file.
+* Construct a `ClackPort` whose methods delegate to `@clack/prompts`. The
+* resulting port writes to `process.stdout` via clack's defaults. Kept in
+* its own module so consumers that never need the clack-backed rendering
+* (programmatic deploys, custom adapters) do not pull `@clack/prompts`
+* into their bundle.
 *
-* @param input - Parsed value from a config source (object tree from a
-* config loader, or a hand-built literal). Shape is checked, not assumed.
-* @param sourceFile - Path or identifier of the source file, used in the
-* `validationFailed` error.
-* @returns `Ok` with the validated `Config`, or `Err` with a
-* `validationFailed` error carrying each issue's field path.
 * @example
 *
 * ```ts
-* import { validateConfig } from "@bedrock-rbx/core";
+* import { createClackPort } from "@bedrock-rbx/core";
 *
-* const ok = validateConfig(
-*     {
-*         environments: { production: {} },
-*         passes: {
-*             "vip-pass": {
-*                 description: "VIP perks.",
-*                 icon: { "en-us": "assets/vip.png" },
-*                 name: "VIP Pass",
-*                 price: 500,
-*             },
-*         },
-*     },
-*     "bedrock.config.ts",
-* );
-* expect(ok.success).toBeTrue();
+* const port = createClackPort();
 *
-* const err = validateConfig(
-*     { environments: { production: {} }, passes: { "vip-pass": { name: "VIP" } } },
-*     "bedrock.config.ts",
-* );
-* expect(err.success).toBeFalse();
-* if (!err.success) {
-*     expect(err.err.kind).toBe("validationFailed");
-* }
+* expect(typeof port.logSuccess).toBe("function");
 * ```
+*
+* @returns A port whose six methods each invoke the matching clack helper.
 */
-function validateConfig(input, sourceFile) {
-	const validated = rootSchema(input);
-	if (validated instanceof ArkErrors) return {
-		err: {
-			issues: Array.from(validated, (issue) => {
-				return {
-					message: issue.message,
-					path: [...issue.path].map((segment) => String(segment))
-				};
-			}),
-			kind: "validationFailed",
-			sourceFile
-		},
-		success: false
-	};
+function createClackPort() {
 	return {
-		data: validated,
-		success: true
+		cancel: (message) => {
+			cancel(message);
+		},
+		intro: (message) => {
+			intro(message);
+		},
+		logError: (message) => {
+			log.error(message);
+		},
+		logMessage: (message) => {
+			log.message(message);
+		},
+		logSuccess: (message) => {
+			log.success(message);
+		},
+		outro: (message) => {
+			outro(message);
+		}
 	};
 }
 //#endregion
@@ -2083,6 +2521,7 @@ const entrySchema$3 = type({
 	"icon?": iconMap,
 	"isRegionalPricingEnabled?": OPTIONAL_BOOLEAN$1,
 	"price?": OPTIONAL_ROBUX_PRICE,
+	"redacted?": "boolean | undefined",
 	"storePageEnabled?": OPTIONAL_BOOLEAN$1
 });
 function flatten$3(config) {
@@ -2130,8 +2569,19 @@ async function normalize$3(input, io) {
 		success: true
 	};
 }
+function changedFieldsBetween$3(desired, current) {
+	return [
+		...desired.description === current.description ? [] : ["description"],
+		...desired.icon?.["en-us"] === current.icon?.["en-us"] ? [] : ["icon"],
+		...iconHashesEqual(current.iconFileHashes, desired.iconFileHashes) ? [] : ["iconFileHashes"],
+		...desired.name === current.name ? [] : ["name"],
+		...desired.price === current.price ? [] : ["price"],
+		...desired.isRegionalPricingEnabled === void 0 || desired.isRegionalPricingEnabled === current.isRegionalPricingEnabled ? [] : ["isRegionalPricingEnabled"],
+		...desired.storePageEnabled === void 0 || desired.storePageEnabled === current.storePageEnabled ? [] : ["storePageEnabled"]
+	];
+}
 function fieldsEqual$3(desired, current) {
-	return desired.description === current.description && desired.icon?.["en-us"] === current.icon?.["en-us"] && iconHashesEqual(current.iconFileHashes, desired.iconFileHashes) && desired.name === current.name && desired.price === current.price && (desired.isRegionalPricingEnabled === void 0 || desired.isRegionalPricingEnabled === current.isRegionalPricingEnabled) && (desired.storePageEnabled === void 0 || desired.storePageEnabled === current.storePageEnabled);
+	return changedFieldsBetween$3(desired, current).length === 0;
 }
 function assertReconcilable(current, desired) {
 	if (current.iconFileHashes !== void 0 && desired.iconFileHashes === void 0) return {
@@ -2154,6 +2604,7 @@ function assertReconcilable(current, desired) {
 */
 const developerProductKind = {
 	assertReconcilable,
+	changedFieldsBetween: changedFieldsBetween$3,
 	entrySchema: entrySchema$3,
 	fieldsEqual: fieldsEqual$3,
 	flatten: flatten$3,
@@ -2166,7 +2617,8 @@ const entrySchema$2 = type({
 	"name": "string",
 	"description": "string",
 	"icon": iconMap,
-	"price?": OPTIONAL_ROBUX_PRICE
+	"price?": OPTIONAL_ROBUX_PRICE,
+	"redacted?": "boolean | undefined"
 });
 function flatten$2(config) {
 	return Object.entries(config.passes ?? {}).map(([key, entry]) => {
@@ -2199,8 +2651,17 @@ async function normalize$2(input, io) {
 		success: true
 	};
 }
+function changedFieldsBetween$2(desired, current) {
+	return [
+		...desired.description === current.description ? [] : ["description"],
+		...desired.icon["en-us"] === current.icon["en-us"] ? [] : ["icon"],
+		...iconHashesEqual(current.iconFileHashes, desired.iconFileHashes) ? [] : ["iconFileHashes"],
+		...desired.name === current.name ? [] : ["name"],
+		...desired.price === current.price ? [] : ["price"]
+	];
+}
 function fieldsEqual$2(desired, current) {
-	return desired.description === current.description && desired.icon["en-us"] === current.icon["en-us"] && iconHashesEqual(current.iconFileHashes, desired.iconFileHashes) && desired.name === current.name && desired.price === current.price;
+	return changedFieldsBetween$2(desired, current).length === 0;
 }
 /**
 * Resource-kind module for Roblox game passes. Owns the entry schema,
@@ -2208,6 +2669,7 @@ function fieldsEqual$2(desired, current) {
 * `gamePass` kind.
 */
 const gamePassKind = {
+	changedFieldsBetween: changedFieldsBetween$2,
 	entrySchema: entrySchema$2,
 	fieldsEqual: fieldsEqual$2,
 	flatten: flatten$2,
@@ -2256,12 +2718,19 @@ async function normalize$1(input, io) {
 		success: true
 	};
 }
+function changedFieldsBetween$1(desired, current) {
+	return [
+		...desired.fileHash === current.fileHash ? [] : ["fileHash"],
+		...desired.filePath === current.filePath ? [] : ["filePath"],
+		...desired.placeId === current.placeId ? [] : ["placeId"],
+		...PLACE_MANAGED_METADATA_FIELDS.filter((field) => {
+			const desiredValue = desired[field];
+			return desiredValue !== void 0 && desiredValue !== current[field];
+		})
+	];
+}
 function fieldsEqual$1(desired, current) {
-	if (desired.fileHash !== current.fileHash || desired.filePath !== current.filePath || desired.placeId !== current.placeId) return false;
-	return PLACE_MANAGED_METADATA_FIELDS.every((field) => {
-		const desiredValue = desired[field];
-		return desiredValue === void 0 || desiredValue === current[field];
-	});
+	return changedFieldsBetween$1(desired, current).length === 0;
 }
 /**
 * Resource-kind module for Roblox places. Owns the entry schema,
@@ -2269,6 +2738,7 @@ function fieldsEqual$1(desired, current) {
 * kind.
 */
 const placeKind = {
+	changedFieldsBetween: changedFieldsBetween$1,
 	entrySchema: entrySchema$1,
 	fieldsEqual: fieldsEqual$1,
 	flatten: flatten$1,
@@ -2351,22 +2821,20 @@ function socialLinkEqual(a, b) {
 	if (b === void 0) return false;
 	return a.title === b.title && a.uri === b.uri;
 }
-function declaredSocialLinksEqual(desired, current) {
-	for (const field of SOCIAL_LINK_FIELDS) {
-		if (!(field in desired)) continue;
-		if (!socialLinkEqual(desired[field], current[field])) return false;
-	}
-	return true;
+function changedFieldsBetween(desired, current) {
+	return [
+		...desired.universeId === current.universeId ? [] : ["universeId"],
+		...UNIVERSE_MANAGED_FLAGS.filter((flag) => {
+			const isDesiredEnabled = desired[flag];
+			return isDesiredEnabled !== void 0 && isDesiredEnabled !== current[flag];
+		}),
+		...desired.displayName === void 0 || desired.displayName === current.displayName ? [] : ["displayName"],
+		..."privateServerPriceRobux" in desired && desired.privateServerPriceRobux !== current.privateServerPriceRobux ? ["privateServerPriceRobux"] : [],
+		...SOCIAL_LINK_FIELDS.filter((field) => field in desired && !socialLinkEqual(desired[field], current[field]))
+	];
 }
 function fieldsEqual(desired, current) {
-	if (desired.universeId !== current.universeId) return false;
-	for (const flag of UNIVERSE_MANAGED_FLAGS) {
-		const isDesiredEnabled = desired[flag];
-		if (isDesiredEnabled !== void 0 && isDesiredEnabled !== current[flag]) return false;
-	}
-	if (desired.displayName !== void 0 && desired.displayName !== current.displayName) return false;
-	if ("privateServerPriceRobux" in desired && desired.privateServerPriceRobux !== current.privateServerPriceRobux) return false;
-	return declaredSocialLinksEqual(desired, current);
+	return changedFieldsBetween(desired, current).length === 0;
 }
 //#endregion
 //#region src/core/kinds/index.ts
@@ -2392,6 +2860,7 @@ const defaultKindRegistry = {
 	gamePass: gamePassKind,
 	place: placeKind,
 	universe: {
+		changedFieldsBetween,
 		entrySchema,
 		fieldsEqual,
 		flatten,
@@ -2412,8 +2881,12 @@ const defaultKindRegistry = {
 * `update` op if any declared field differs or a `noop` op if every field
 * matches.
 *
-* Ops appear in the order their desired entries appear in the input array so
-* callers can rely on declaration order when logging or applying ops.
+* Ops appear in the order their desired entries appear in the input array.
+* `applyOps` regroups them into Phase 1 (universe) and Phase 2 (everything
+* else) when dispatching; the execution order within Phase 2 is not
+* guaranteed because Phase 2 dispatches concurrently. Persisted state-file
+* order is determined by the merge in `deploy.runReconcile` (which retains
+* prior-snapshot positions for unchanged keys), not by this diff output.
 *
 * @param desired - Declared desired state from user config, already normalized
 *   (file hashes computed, nullable wire values mapped to `undefined`).
@@ -2477,6 +2950,11 @@ const defaultKindRegistry = {
 * const ops = diff([unchanged, drifted, fresh], current);
 *
 * expect(ops.map((op) => op.type)).toEqual(["noop", "update", "create"]);
+*
+* const updateOp = ops[1]!;
+* if (updateOp.type === "update") {
+*     expect(updateOp.changedFields).toStrictEqual(["name"]);
+* }
 * ```
 */
 function diff(desired, current) {
@@ -2486,21 +2964,21 @@ function diff(desired, current) {
 function compositeKey$1(resource) {
 	return `${resource.kind}:${resource.key}`;
 }
-function desiredFieldsEqual(desired, current) {
-	return defaultKindRegistry[desired.kind].fieldsEqual(desired, current);
-}
 function operationFor(desired, current) {
 	if (current === void 0) return {
 		key: desired.key,
 		desired,
 		type: "create"
 	};
-	if (desiredFieldsEqual(desired, current)) return {
+	const changedFields = defaultKindRegistry[desired.kind].changedFieldsBetween(desired, current);
+	if (changedFields.length === 0) return {
 		key: desired.key,
+		kind: desired.kind,
 		type: "noop"
 	};
 	return {
 		key: desired.key,
+		changedFields,
 		current,
 		desired,
 		type: "update"
@@ -2596,59 +3074,316 @@ function capitalize(value) {
 function flattenConfig(config) {
 	return Object.values(defaultKindRegistry).flatMap((module) => module.flatten(config));
 }
-//#endregion
-//#region src/core/resolve-state-config.ts
 /**
-* Pick the `StateConfig` that applies to `environment`. Per-environment
-* overrides win over the root block; if neither is present, returns
-* `Err(stateNotConfigured)` so the deploy boundary can surface a typed
-* error instead of silently falling back.
-*
-* @param config - Validated project config.
-* @param environment - Target environment name.
-* @returns The resolved `StateConfig`, or `Err(stateNotConfigured)` when
-* neither the environment override nor the root block is set.
-* @example
-*
-* ```ts
-* import { resolveStateConfig } from "@bedrock-rbx/core";
-*
-* const result = resolveStateConfig(
-*     {
-*         state: { backend: "gist", gistId: "root-gist" },
-*         environments: {
-*             production: { state: { backend: "gist", gistId: "prod-gist" } },
-*         },
-*     },
-*     "production",
-* );
+* Common prefix used to build the default name pushed for a redacted
+* developer-product. The full default produced by {@link defaultRedactedProductName}
+* is `${REDACTED_PRODUCT_NAME} ${suffix}`, where `suffix` is a 6-hex-char
+* digest of the resource key (see {@link redactedNameSuffix}). The suffix is
+* required because Roblox enforces per-universe uniqueness on
+* developer-product names, so a shared bare placeholder would collide across
+* multiple redacted entries. The prefix avoids the word `Redacted` and the
+* `#` separator because Roblox's text-moderation filter has been observed
+* silently replacing names matching `Redacted Product #<hex>` with
+* `########################`, which then causes downstream `DuplicateProductName`
+* errors when other redacted entries are moderated to the same string.
+*/
+const REDACTED_PRODUCT_NAME = "Hidden Product";
+const PASS_PRODUCT_ENV_FIELDS = [
+	"description",
+	"icon",
+	"name",
+	"price"
+];
+const PLACE_ENV_FIELDS = ["description", "displayName"];
+/**
+* Six-character lowercase hex digest of `SHA-256(key)`, used as the
+* disambiguating suffix on a redacted developer-product's default `name`.
+* Stable across config edits (driven only by the bedrock resource key, not
+* declaration order) and opaque to a Roblox player browsing the marketplace.
+* A natural collision is caught at plan time by `validatePlan`.
+*
+* @param key - Bedrock resource key for the developer product being redacted.
+* @returns The first six lowercase hex characters of the SHA-256 digest of `key`.
+*/
+function redactedNameSuffix(key) {
+	return createHash("sha256").update(key).digest("hex").slice(0, 6);
+}
+/**
+* Default redacted name for a developer product with the given resource key.
+* Combines {@link REDACTED_PRODUCT_NAME} with {@link redactedNameSuffix} so
+* each redacted entry resolves to a unique value the upstream API will accept.
 *
-* expect(result.success).toBeTrue();
-* if (result.success) {
-*     expect(result.data).toContainEntry(["gistId", "prod-gist"]);
-* }
-* ```
+* @param key - Bedrock resource key for the developer product being redacted.
+* @returns The placeholder name pushed to Roblox for this product.
+*/
+function defaultRedactedProductName(key) {
+	return `${REDACTED_PRODUCT_NAME} ${redactedNameSuffix(key)}`;
+}
+/**
+* Pure transform that substitutes bedrock-supplied placeholder content for
+* every resource whose effective redaction state is truthy. Three layers
+* compose field-by-field per resource: env-resource (most-specific, from
+* `inputs.envResource`), root-resource (the `redacted` field on the
+* passed-in entry), and env-level (least-specific, `inputs.envLevel`).
+* The first non-undefined value sets state (`false` carves out); object
+* layers then contribute fields with the most-specific layer winning per
+* field, and bedrock defaults fill any field nobody set. Runs between
+* env-overlay merge and display-name prefix render so the rest of the
+* pipeline (flatten, normalize, diff, apply) operates on already-redacted
+* values and needs no special-case redaction logic.
+*
+* @param config - Post-merge `ResolvedConfig` produced by `selectEnvironment`.
+* @param inputs - Aggregated redaction layers. Omit to skip redaction
+*   entirely. See {@link RedactionInputs} for the shape.
+* @returns A `ResolvedConfig` whose redacted entries carry placeholder
+*   values; non-redacted entries pass through verbatim, and the input is
+*   not mutated.
+*/
+function applyRedaction(config, inputs) {
+	const environmentLevel = inputs?.envLevel;
+	const environmentResource = inputs?.envResource;
+	const passes = redactPasses({
+		collection: config.passes,
+		envLevel: environmentLevel,
+		envResource: environmentResource?.passes
+	});
+	const places = redactPlaces({
+		collection: config.places,
+		envLevel: environmentLevel,
+		envResource: environmentResource?.places
+	});
+	const products = redactProducts({
+		collection: config.products,
+		envLevel: environmentLevel,
+		envResource: environmentResource?.products
+	});
+	if (passes === config.passes && places === config.places && products === config.products) return config;
+	return {
+		...config,
+		...passes === void 0 ? {} : { passes },
+		...places === void 0 ? {} : { places },
+		...products === void 0 ? {} : { products }
+	};
+}
+/**
+* Inspect the pre-redaction merged config and produce one annotation per
+* resource flagged `redacted: true` at either the root entry or its
+* env-overlay counterpart. Callers thread the result into plan output so
+* authors can see which resources are redacted in the active environment
+* and whether their real-value edits are being suppressed.
+*
+* Operates on the pre-redaction view because the post-redaction config no
+* longer carries the real `name`/`description`/`icon` values needed to
+* detect divergence from the placeholder defaults.
+*
+* @param merged - `ResolvedConfig` produced by environment overlay merge,
+*   before `applyRedaction` has substituted placeholders.
+* @param environmentResource - Per-kind env-overlay redaction layers
+*   extracted from the active env entry. Omit when the caller has no
+*   env-overlay layer.
+* @returns Zero or more annotations, one per redacted resource. Empty when
+*   the config declares no redacted resources.
+*/
+function collectRedactionAnnotations(merged, environmentResource) {
+	const passes = Object.entries(merged.passes ?? {}).filter(([key, entry]) => entry.redacted === true || environmentResource?.passes?.[key] === true).map(([key, entry]) => {
+		return {
+			key: asResourceKey(key),
+			hasRealValueEdits: passHasRealValueEdits(entry),
+			kind: "gamePass"
+		};
+	});
+	const products = Object.entries(merged.products ?? {}).filter(([key, entry]) => entry.redacted === true || environmentResource?.products?.[key] === true).map(([key, entry]) => {
+		return {
+			key: asResourceKey(key),
+			hasRealValueEdits: productHasRealValueEdits(key, entry),
+			kind: "developerProduct"
+		};
+	});
+	return [...passes, ...products];
+}
+function pickEnvironmentFields(environmentLevel, fields) {
+	if (environmentLevel === void 0 || typeof environmentLevel === "boolean") return environmentLevel;
+	return Object.fromEntries(fields.map((field) => [field, environmentLevel[field]]));
+}
+/**
+* Walk redaction layers most-specific to least-specific and produce the
+* effective per-field override for one resource. Returns `undefined` when the
+* resource is not redacted; returns a (possibly empty) object when it is.
+* State step: the first non-undefined layer sets state -- `false` carves out,
+* `true` or object enables. Fields step: walk every object layer in the same
+* order, taking the first value per field. A field's value may itself be
+* `undefined` (the env-level projection produced by {@link pickEnvironmentFields}
+* includes every projected key, even when the env override left it absent);
+* downstream per-kind redact functions collapse those back to bedrock
+* placeholder defaults via `??`.
+*
+* @template Override - Per-kind override type the resource accepts.
+* @param layers - Layers ordered most-specific (index 0) to least-specific.
+* @returns The effective override, or `undefined` when not redacted.
+*/
+function resolveEffectiveOverride(layers) {
+	const firstNonUndefined = layers.find((layer) => layer !== void 0);
+	if (firstNonUndefined === void 0 || firstNonUndefined === false) return;
+	const effective = {};
+	for (const layer of layers) {
+		if (typeof layer !== "object") continue;
+		for (const [field, value] of Object.entries(layer)) if (!(field in effective)) effective[field] = value;
+	}
+	return effective;
+}
+function resolveEntries(inputs) {
+	const { collection, environmentForKind, envResource } = inputs;
+	return Object.entries(collection).map(([key, entry]) => {
+		return {
+			key,
+			entry,
+			override: resolveEffectiveOverride([
+				envResource?.[key],
+				entry.redacted,
+				environmentForKind
+			])
+		};
+	});
+}
+function redactCollection(inputs) {
+	const { collection, environmentForKind, envResource, redact } = inputs;
+	if (collection === void 0) return;
+	const resolved = resolveEntries({
+		collection,
+		environmentForKind,
+		envResource
+	});
+	if (resolved.every((item) => item.override === void 0)) return collection;
+	return Object.fromEntries(resolved.map((item) => {
+		return item.override === void 0 ? [item.key, item.entry] : [item.key, redact({
+			key: item.key,
+			entry: item.entry,
+			override: item.override
+		})];
+	}));
+}
+function redactPass(entry, override) {
+	return {
+		...entry,
+		name: override.name ?? "Redacted Pass",
+		description: override.description ?? "",
+		icon: override.icon ?? { "en-us": "<bedrock:redacted-icon.png>" },
+		...entry.price === void 0 ? {} : { price: override.price ?? 99999 }
+	};
+}
+function redactPasses(inputs) {
+	const { collection, envLevel, envResource } = inputs;
+	return redactCollection({
+		collection,
+		environmentForKind: pickEnvironmentFields(envLevel, PASS_PRODUCT_ENV_FIELDS),
+		envResource,
+		redact: (item) => redactPass(item.entry, item.override)
+	});
+}
+function redactPlace(entry, override) {
+	return {
+		...entry,
+		description: override.description ?? "",
+		displayName: override.displayName ?? entry.displayName
+	};
+}
+function redactPlaces(inputs) {
+	const { collection, envLevel, envResource } = inputs;
+	return redactCollection({
+		collection,
+		environmentForKind: pickEnvironmentFields(envLevel, PLACE_ENV_FIELDS),
+		envResource,
+		redact: (item) => redactPlace(item.entry, item.override)
+	});
+}
+function redactProduct(inputs) {
+	const { key, entry, override } = inputs;
+	return {
+		...entry,
+		name: override.name ?? defaultRedactedProductName(key),
+		description: override.description ?? "",
+		icon: override.icon ?? { "en-us": "<bedrock:redacted-icon.png>" },
+		...entry.price === void 0 ? {} : { price: override.price ?? 99999 }
+	};
+}
+function redactProducts(inputs) {
+	const { collection, envLevel, envResource } = inputs;
+	return redactCollection({
+		collection,
+		environmentForKind: pickEnvironmentFields(envLevel, PASS_PRODUCT_ENV_FIELDS),
+		envResource,
+		redact: redactProduct
+	});
+}
+function passHasRealValueEdits(entry) {
+	return entry.name !== "Redacted Pass" || entry.description !== "" || entry.icon["en-us"] !== "<bedrock:redacted-icon.png>" || entry.price !== void 0 && entry.price !== 99999;
+}
+function productHasRealValueEdits(key, entry) {
+	return !(entry.name === defaultRedactedProductName(key) || entry.name === "Hidden Product") || entry.description !== "" || entry.icon !== void 0 && entry.icon["en-us"] !== "<bedrock:redacted-icon.png>" || entry.price !== void 0 && entry.price !== 99999;
+}
+//#endregion
+//#region src/core/select-environment.ts
+/**
+* Project a `Config` onto a single environment up to the pre-redaction
+* merge boundary. Looks up the env entry, deep-merges its resource overlay
+* over the root config, and runs the same pass, place, and universe
+* completeness checks {@link selectEnvironment} runs, so the returned
+* `merged` config honours the full `ResolvedConfig` contract. Real
+* `name`, `description`, and `icon` values on redacted resources stay
+* intact, letting callers inspect divergence from placeholder defaults
+* before {@link selectEnvironment} substitutes them.
+*
+* @param config - Validated project config.
+* @param environment - Environment name to project onto.
+* @returns The matched env entry plus the merged config, or any of the
+*   `SelectEnvironmentError` failure modes.
 */
-function resolveStateConfig(config, environment) {
-	const override = config.environments[environment]?.state;
-	if (override !== void 0) return {
-		data: override,
-		success: true
+function selectMergedEnvironment(config, environment) {
+	const entry = config.environments[environment];
+	if (entry === void 0) return {
+		err: unknownEnvironment(config, environment),
+		success: false
 	};
-	if (config.state !== void 0) return {
-		data: config.state,
-		success: true
+	const merged = mergeOverlays(config, entry);
+	const incompletePass = findIncompletePass(merged, environment);
+	if (incompletePass !== void 0) return {
+		err: incompletePass,
+		success: false
+	};
+	const incompletePlace = findIncompletePlace(merged, environment);
+	if (incompletePlace !== void 0) return {
+		err: incompletePlace,
+		success: false
+	};
+	const incompleteUniverse = findIncompleteUniverse(merged, environment);
+	if (incompleteUniverse !== void 0) return {
+		err: incompleteUniverse,
+		success: false
 	};
 	return {
-		err: {
-			environment,
-			kind: "stateNotConfigured"
+		data: {
+			entry,
+			merged
 		},
-		success: false
+		success: true
+	};
+}
+/**
+* Build the per-resource env-overlay redaction layer that `applyRedaction`
+* and `collectRedactionAnnotations` consume. Reads each redactable kind off
+* the environment entry and projects every entry's `redacted` field into
+* the layer; omits kinds the env entry does not declare.
+*
+* @param entry - Environment entry whose overlay redaction values to extract.
+* @returns A `EnvironmentResourceRedaction` ready to pass downstream.
+*/
+function extractResourceRedaction(entry) {
+	return {
+		...entry.passes ? { passes: extractRedactionLayer(entry.passes) } : {},
+		...entry.places ? { places: extractRedactionLayer(entry.places) } : {},
+		...entry.products ? { products: extractRedactionLayer(entry.products) } : {}
 	};
 }
-//#endregion
-//#region src/core/select-environment.ts
 /**
 * Project a validated `Config` onto a single environment. Looks up the
 * matching `environments[environment]` entry, deep-merges its resource
@@ -2727,28 +3462,87 @@ function resolveStateConfig(config, environment) {
 * projection failed.
 */
 function selectEnvironment(config, environment) {
-	const entry = config.environments[environment];
-	if (entry === void 0) return {
-		err: unknownEnvironment(config, environment),
-		success: false
+	const mergedResult = selectMergedEnvironment(config, environment);
+	if (!mergedResult.success) return mergedResult;
+	const { entry, merged } = mergedResult.data;
+	return {
+		data: redactAndPrefix({
+			config,
+			entry,
+			merged
+		}),
+		success: true
 	};
-	const projected = projectConfig({
-		config,
-		entry
-	});
-	const incompletePlace = findIncompletePlace(projected, environment);
-	if (incompletePlace !== void 0) return {
-		err: incompletePlace,
-		success: false
+}
+function findIncompletePass(merged, environment) {
+	const { passes } = merged;
+	if (passes === void 0) return;
+	const candidates = passes;
+	for (const [key, entry] of Object.entries(candidates)) {
+		if (entry.name === void 0) return {
+			key,
+			environment,
+			kind: "incompletePassEntry",
+			missingField: "name"
+		};
+		if (entry.description === void 0) return {
+			key,
+			environment,
+			kind: "incompletePassEntry",
+			missingField: "description"
+		};
+		if (entry.icon === void 0) return {
+			key,
+			environment,
+			kind: "incompletePassEntry",
+			missingField: "icon"
+		};
+	}
+}
+function mergeEntry(overlay, base) {
+	return defu(overlay, base ?? {});
+}
+function mergeKeyedRecord(overlay, base) {
+	if (overlay === void 0) return base;
+	return {
+		...base ?? {},
+		...Object.fromEntries(Object.entries(overlay).map(([key, partial]) => {
+			return [key, mergeEntry(partial, base?.[key])];
+		}))
 	};
-	const incompleteUniverse = findIncompleteUniverse(projected, environment);
-	if (incompleteUniverse !== void 0) return {
-		err: incompleteUniverse,
-		success: false
+}
+function mergeUniverse(overlay, base) {
+	if (overlay === void 0 && base === void 0) return;
+	return defu(overlay ?? {}, base ?? {});
+}
+function stripRedacted(overlay) {
+	if (overlay === void 0) return;
+	return Object.fromEntries(Object.entries(overlay).map(([key, entryValue]) => {
+		const { redacted: _redacted, ...rest } = entryValue;
+		return [key, rest];
+	}));
+}
+function mergeOverlays(config, entry) {
+	const passes = mergeKeyedRecord(stripRedacted(entry.passes), config.passes);
+	const places = mergeKeyedRecord(stripRedacted(entry.places), config.places);
+	const products = mergeKeyedRecord(stripRedacted(entry.products), config.products);
+	const universe = mergeUniverse(entry.universe, config.universe);
+	const state = entry.state ?? config.state;
+	const { places: _placesRoot, products: _productsRoot, universe: _universeRoot, ...rest } = config;
+	return {
+		...rest,
+		...passes === void 0 ? {} : { passes },
+		...places === void 0 ? {} : { places },
+		...products === void 0 ? {} : { products },
+		...state === void 0 ? {} : { state },
+		...universe === void 0 ? {} : { universe }
 	};
+}
+function unknownEnvironment(config, environment) {
 	return {
-		data: projected,
-		success: true
+		declared: Object.keys(config.environments),
+		environment,
+		kind: "unknownEnvironment"
 	};
 }
 function findIncompleteUniverse(projected, environment) {
@@ -2779,21 +3573,10 @@ function findIncompletePlace(projected, environment) {
 		};
 	}
 }
-function mergeEntry(overlay, base) {
-	return defu(overlay, base ?? {});
-}
-function mergeKeyedRecord(overlay, base) {
-	if (overlay === void 0) return base;
-	return {
-		...base ?? {},
-		...Object.fromEntries(Object.entries(overlay).map(([key, partial]) => {
-			return [key, mergeEntry(partial, base?.[key])];
-		}))
-	};
-}
-function mergeUniverse(overlay, base) {
-	if (overlay === void 0 && base === void 0) return;
-	return defu(overlay ?? {}, base ?? {});
+function extractRedactionLayer(overlay) {
+	const layer = {};
+	for (const [key, entryValue] of Object.entries(overlay)) if (entryValue.redacted !== void 0) layer[key] = entryValue.redacted;
+	return layer;
 }
 function resolvePrefix(config, entry) {
 	if (config.displayNamePrefix?.enabled === false) return;
@@ -2818,33 +3601,21 @@ function applyPlacesPrefix(places, prefix) {
 		}];
 	}));
 }
-function projectConfig(inputs) {
-	const { config, entry } = inputs;
-	const passes = mergeKeyedRecord(entry.passes, config.passes);
-	const mergedPlaces = mergeKeyedRecord(entry.places, config.places);
-	const products = mergeKeyedRecord(entry.products, config.products);
-	const merged = mergeUniverse(entry.universe, config.universe);
+function redactAndPrefix(inputs) {
+	const { config, entry, merged } = inputs;
+	const redacted = applyRedaction(merged, {
+		envLevel: entry.redacted,
+		envResource: extractResourceRedaction(entry)
+	});
 	const prefix = resolvePrefix(config, entry);
-	const universe = applyUniversePrefix(merged, prefix);
-	const places = applyPlacesPrefix(mergedPlaces, prefix);
-	const state = entry.state ?? config.state;
-	const { places: _placesRoot, products: _productsRoot, universe: _universeRoot, ...rest } = config;
+	const places = applyPlacesPrefix(redacted.places, prefix);
+	const universe = applyUniversePrefix(redacted.universe, prefix);
 	return {
-		...rest,
-		...passes === void 0 ? {} : { passes },
+		...redacted,
 		...places === void 0 ? {} : { places },
-		...products === void 0 ? {} : { products },
-		...state === void 0 ? {} : { state },
 		...universe === void 0 ? {} : { universe }
 	};
 }
-function unknownEnvironment(config, environment) {
-	return {
-		declared: Object.keys(config.environments),
-		environment,
-		kind: "unknownEnvironment"
-	};
-}
 //#endregion
 //#region src/core/validate-plan.ts
 /**
@@ -2907,6 +3678,8 @@ function unknownEnvironment(config, environment) {
 * ```
 */
 function validatePlan(desired, current) {
+	const collision = detectProductNameCollision(desired);
+	if (collision !== void 0) return collision;
 	const currentByKey = new Map(current.map((entry) => [compositeKey(entry), entry]));
 	for (const entry of desired) {
 		const matched = currentByKey.get(compositeKey(entry));
@@ -2922,136 +3695,116 @@ function validatePlan(desired, current) {
 function compositeKey(resource) {
 	return `${resource.kind}:${resource.key}`;
 }
+function detectProductNameCollision(desired) {
+	const seenByName = /* @__PURE__ */ new Map();
+	for (const entry of desired) {
+		if (entry.kind !== "developerProduct") continue;
+		const prior = seenByName.get(entry.name);
+		if (prior === void 0) {
+			seenByName.set(entry.name, entry.key);
+			continue;
+		}
+		return {
+			err: {
+				keys: [prior, entry.key],
+				kind: "redactedNameCollision",
+				message: `developer products '${prior}' and '${entry.key}' both resolve to the wire name '${entry.name}'. Roblox enforces per-universe uniqueness on developer-product names, so the second update would be rejected as DuplicateProductName. Set 'redacted: { name: "<unique>" }' on one of them to disambiguate.`,
+				resolvedName: entry.name
+			},
+			success: false
+		};
+	}
+}
 //#endregion
 //#region src/shell/apply-ops.ts
 /**
-* Dispatch each reconciliation operation to the matching resource driver
-* with first-fail semantics: on the first `Err` (driver failure or
-* `updateUnsupported`), the remaining operations are skipped and the error
-* is returned verbatim.
+* Dispatch reconciliation operations to their matching drivers in two phases
+* with continue-on-failure semantics. Phase 1 runs universe ops sequentially
+* (singleton per environment; sequencing it before everything else avoids the
+* `displayName` race against the root `Place`). Phase 2 dispatches every
+* remaining non-noop op concurrently via `Promise.all`; every op is
+* attempted regardless of earlier failures.
 *
 * Behaviour:
-* - `create` operations are routed to `registry[op.desired.kind].create`.
-* - `update` operations are routed to `registry[op.desired.kind].update`
-*   when the driver exposes it; otherwise they short-circuit to an
-*   `updateUnsupported` Err without invoking the driver.
+* - `create` operations route to `registry[op.desired.kind].create`.
+* - `update` operations route to `registry[op.desired.kind].update` when the
+*   driver exposes it; otherwise they yield an `updateUnsupported`
+*   `ApplyError` without invoking the driver.
 * - `noop` operations are skipped entirely (no I/O, no dispatch).
-*
-* On success the returned array carries the driver outputs for every
-* non-noop op, in dispatched order. Noops are not represented; callers
-* needing a full post-apply snapshot merge with the pre-apply current
-* state keyed by `ResourceKey`.
-*
-* @param ops - Reconciliation operations produced by `diff`, applied in order.
-* @param registry - Per-kind driver table; dispatch uses `op.desired.kind` as the index.
-* @returns `Ok(state)` when every operation succeeds, where `state` holds
-*   driver outputs for each non-noop op in dispatched order; or the first
-*   failure encountered.
-* @throws Whatever the dispatched driver rejects with outside its `Result`
-*   return. A driver whose injected I/O (file reads, network calls, etc.)
-*   throws will surface that rejection here rather than translating it into
-*   a `Result` failure; wrap the call site in a try/catch when drivers are
-*   not trusted to contain their own rejections.
+* - A driver that throws outside its `Result` contract is caught at the
+*   dispatch boundary and translated to an `unexpectedThrow` `ApplyError`
+*   scoped to that op alone; the rest of the batch keeps running.
+*
+* On Ok the returned array carries driver outputs for every non-noop op
+* in phase order: Phase 1 universe entries first, then Phase 2 entries in
+* their input order. Noops are not represented; callers needing a full
+* post-apply snapshot merge with the pre-apply current state keyed by
+* `ResourceKey`.
+*
+* On Err the aggregate carries every survivor in `applied` (Phase 1 first,
+* then Phase 2 input order) and every failure in `failures` with the same
+* grouping. Neither array reflects completion order.
+*
+* @param ops - Reconciliation operations produced by `diff`, applied in
+*   declaration order.
+* @param registry - Per-kind driver table; dispatch uses `op.desired.kind`
+*   as the index.
+* @param reporting - Optional progress wiring. When supplied, `applyOps`
+*   emits one `resourceOpStarted` and one terminal event per non-noop op,
+*   one `resourceOpNoop` per noop op, and a final `applySummary` carrying
+*   the per-type counts and the wall-clock apply duration. When omitted,
+*   no events fire.
+* @returns `Ok(state)` when every op succeeded; otherwise
+*   `Err(AggregateApplyError)` with the survivors and the non-empty
+*   failures tuple.
 * @example
 *
 * ```ts
-* import {
-*     applyOps,
-*     asResourceKey,
-*     asRobloxAssetId,
-*     asSha256Hex,
-*     type DriverRegistry,
-*     type Operation,
-* } from "@bedrock-rbx/core";
+* import { applyOps, type DriverRegistry } from "@bedrock-rbx/core";
 *
-* const registry: DriverRegistry = {
-*     gamePass: {
-*         async create(desired) {
-*             return {
-*                 data: {
-*                     ...desired,
-*                     outputs: {
-*                         assetId: asRobloxAssetId("9876543210"),
-*                         iconAssetIds: { "en-us": asRobloxAssetId("1122334455") },
-*                     },
-*                 },
-*                 success: true,
-*             };
-*         },
-*     },
-*     place: {
-*         async create(desired) {
-*             return {
-*                 data: { ...desired, outputs: { versionNumber: 1 } },
-*                 success: true,
-*             };
-*         },
-*     },
-*     universe: {
-*         async create(desired) {
-*             return {
-*                 data: { ...desired, outputs: { rootPlaceId: asRobloxAssetId("4711") } },
-*                 success: true,
-*             };
-*         },
-*     },
-*     developerProduct: {
-*         async create(desired) {
-*             return {
-*                 data: {
-*                     ...desired,
-*                     outputs: { productId: asRobloxAssetId("8172635495") },
-*                 },
-*                 success: true,
-*             };
-*         },
-*     },
+* const noopRegistry: DriverRegistry = {
+*     developerProduct: { create: async () => ({ err: new Error("stub") as never, success: false }) },
+*     gamePass: { create: async () => ({ err: new Error("stub") as never, success: false }) },
+*     place: { create: async () => ({ err: new Error("stub") as never, success: false }) },
+*     universe: { create: async () => ({ err: new Error("stub") as never, success: false }) },
 * };
 *
-* const ops: ReadonlyArray<Operation> = [
-*     {
-*         key: asResourceKey("vip-pass"),
-*         type: "create",
-*         desired: {
-*             key: asResourceKey("vip-pass"),
-*             name: "VIP Pass",
-*             description: "Grants VIP perks.",
-*             icon: { "en-us": "assets/vip-icon.png" },
-*             iconFileHashes: {
-*                 "en-us": asSha256Hex(
-*                     "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-*                 ),
-*             },
-*             kind: "gamePass",
-*             price: 500,
-*         },
-*     },
-* ];
-*
-* return applyOps(ops, registry).then((result) => {
-*     expect(result.success).toBe(true);
-*     expect(result.success && result.data).toHaveLength(1);
+* return applyOps([], noopRegistry).then((result) => {
+*     expect(result).toStrictEqual({ data: [], success: true });
 * });
 * ```
 */
-async function applyOps(ops, registry) {
-	const applied = [];
-	for (const op of ops) {
-		if (op.type === "noop") continue;
-		const outcome = await dispatchOp(op, registry);
-		if (!outcome.success) return {
-			err: {
-				...outcome.err,
-				appliedSoFar: applied
-			},
-			success: false
-		};
-		applied.push(outcome.data);
-	}
-	return {
+async function applyOps(ops, registry, reporting) {
+	const start = Date.now();
+	const { noopCount, phase1, phase2 } = partitionAndEmitNoops(ops, reporting);
+	const pairs = await dispatchInPhases({
+		phase1,
+		phase2,
+		registry,
+		reporting
+	});
+	const end = Date.now();
+	const { applied, failures } = partitionOutcomes(pairs.map((pair) => pair.outcome));
+	emitApplySummary({
+		end,
+		failures,
+		noopCount,
+		pairs,
+		reporting,
+		start
+	});
+	const [head, ...tail] = failures;
+	if (head === void 0) return {
 		data: applied,
 		success: true
 	};
+	return {
+		err: {
+			applied,
+			failures: [head, ...tail]
+		},
+		success: false
+	};
 }
 function driverFailure(key, cause) {
 	return {
@@ -3085,7 +3838,7 @@ async function applyOne(op, driver) {
 	const updated = await driver.update(op.current, op.desired);
 	return updated.success ? updated : driverFailure(op.key, updated.err);
 }
-async function dispatchOp(op, registry) {
+async function dispatchByKind(op, registry) {
 	switch (op.desired.kind) {
 		case "developerProduct": return applyOne(op, registry.developerProduct);
 		case "gamePass": return applyOne(op, registry.gamePass);
@@ -3093,6 +3846,161 @@ async function dispatchOp(op, registry) {
 		case "universe": return applyOne(op, registry.universe);
 	}
 }
+async function dispatchOp(op, registry) {
+	try {
+		return await dispatchByKind(op, registry);
+	} catch (err) {
+		return {
+			err: {
+				key: op.key,
+				cause: err,
+				kind: "unexpectedThrow"
+			},
+			success: false
+		};
+	}
+}
+function createSucceededEvent(input) {
+	const { key, environment, state } = input;
+	switch (state.kind) {
+		case "developerProduct": return {
+			key,
+			environment,
+			kind: "resourceOpSucceeded",
+			opType: "create",
+			outputs: state.outputs,
+			resourceKind: "developerProduct"
+		};
+		case "gamePass": return {
+			key,
+			environment,
+			kind: "resourceOpSucceeded",
+			opType: "create",
+			outputs: state.outputs,
+			resourceKind: "gamePass"
+		};
+		case "place": return {
+			key,
+			environment,
+			kind: "resourceOpSucceeded",
+			opType: "create",
+			outputs: state.outputs,
+			resourceKind: "place"
+		};
+		case "universe": return {
+			key,
+			environment,
+			kind: "resourceOpSucceeded",
+			opType: "create",
+			outputs: state.outputs,
+			resourceKind: "universe"
+		};
+	}
+}
+function toTerminalEvent(input) {
+	const { environment, op, outcome } = input;
+	if (!outcome.success) return {
+		key: op.key,
+		environment,
+		error: outcome.err,
+		kind: "resourceOpFailed",
+		opType: op.type,
+		resourceKind: op.desired.kind
+	};
+	if (op.type === "update") return {
+		key: op.key,
+		changedFields: op.changedFields,
+		environment,
+		kind: "resourceOpSucceeded",
+		opType: "update",
+		resourceKind: op.desired.kind
+	};
+	return createSucceededEvent({
+		key: op.key,
+		environment,
+		state: outcome.data
+	});
+}
+async function reportAndDispatch(input) {
+	const { op, registry, reporting } = input;
+	if (reporting !== void 0) reporting.progress.emit({
+		key: op.key,
+		environment: reporting.environment,
+		kind: "resourceOpStarted",
+		opType: op.type,
+		resourceKind: op.desired.kind
+	});
+	const outcome = await dispatchOp(op, registry);
+	if (reporting !== void 0) reporting.progress.emit(toTerminalEvent({
+		environment: reporting.environment,
+		op,
+		outcome
+	}));
+	return {
+		op,
+		outcome
+	};
+}
+async function dispatchInPhases(input) {
+	const phase1Pairs = [];
+	for (const op of input.phase1) phase1Pairs.push(await reportAndDispatch({
+		op,
+		registry: input.registry,
+		reporting: input.reporting
+	}));
+	const phase2Pairs = await Promise.all(input.phase2.map(async (op) => {
+		return reportAndDispatch({
+			op,
+			registry: input.registry,
+			reporting: input.reporting
+		});
+	}));
+	return [...phase1Pairs, ...phase2Pairs];
+}
+function emitApplySummary(input) {
+	if (input.reporting === void 0) return;
+	const created = input.pairs.filter((pair) => pair.outcome.success && pair.op.type === "create").length;
+	const updated = input.pairs.filter((pair) => pair.outcome.success && pair.op.type === "update").length;
+	input.reporting.progress.emit({
+		created,
+		durationMs: input.end - input.start,
+		environment: input.reporting.environment,
+		failed: input.failures.length,
+		kind: "applySummary",
+		noop: input.noopCount,
+		updated
+	});
+}
+function partitionOutcomes(outcomes) {
+	return {
+		applied: outcomes.flatMap((outcome) => outcome.success ? [outcome.data] : []),
+		failures: outcomes.flatMap((outcome) => outcome.success ? [] : [outcome.err])
+	};
+}
+function emitNoop(op, reporting) {
+	if (reporting === void 0) return;
+	reporting.progress.emit({
+		key: op.key,
+		environment: reporting.environment,
+		kind: "resourceOpNoop",
+		resourceKind: op.kind
+	});
+}
+function partitionAndEmitNoops(ops, reporting) {
+	const phase1 = [];
+	const phase2 = [];
+	let noopCount = 0;
+	for (const op of ops) if (op.type === "noop") {
+		noopCount += 1;
+		emitNoop(op, reporting);
+	} else if (op.desired.kind === "universe") phase1.push(op);
+	else phase2.push(op);
+	return {
+		noopCount,
+		phase1,
+		phase2
+	};
+}
 //#endregion
 //#region src/shell/build-default-registry.ts
 /**
@@ -3816,6 +4724,7 @@ async function resolveDeps(options) {
 	return {
 		data: {
 			config: effective,
+			progress: options.progress,
 			readFile: readFile$2,
 			registry: registry.data,
 			statePort: statePort.data
@@ -3830,7 +4739,7 @@ function mergeResources(pre, applied) {
 	return [...byKey.values()];
 }
 function buildSnapshot(inputs) {
-	const appliedResources = inputs.applied.success ? inputs.applied.data : inputs.applied.err.appliedSoFar;
+	const appliedResources = inputs.applied.success ? inputs.applied.data : inputs.applied.err.applied;
 	return {
 		environment: inputs.environment,
 		resources: mergeResources(inputs.priorResources, appliedResources),
@@ -3838,13 +4747,6 @@ function buildSnapshot(inputs) {
 	};
 }
 function finalize(inputs) {
-	if (!inputs.applied.success) return {
-		err: {
-			cause: inputs.applied.err,
-			kind: "applyFailed"
-		},
-		success: false
-	};
 	if (!inputs.written.success) return {
 		err: {
 			cause: inputs.written.err,
@@ -3853,6 +4755,13 @@ function finalize(inputs) {
 		},
 		success: false
 	};
+	if (!inputs.applied.success) return {
+		err: {
+			cause: inputs.applied.err,
+			kind: "applyFailed"
+		},
+		success: false
+	};
 	return {
 		data: inputs.merged,
 		success: true
@@ -3884,16 +4793,24 @@ async function runReconcile(environment, deps) {
 		},
 		success: false
 	};
-	const applied = await applyOps(diff(desired.data, priorResources), deps.registry);
+	const applied = await applyOps(diff(desired.data, priorResources), deps.registry, deps.progress === void 0 ? void 0 : {
+		environment,
+		progress: deps.progress
+	});
 	const merged = buildSnapshot({
 		applied,
 		environment,
 		priorResources
 	});
+	const written = await deps.statePort.write(merged);
+	if (written.success) deps.progress?.emit({
+		environment,
+		kind: "stateWritten"
+	});
 	return finalize({
 		applied,
 		merged,
-		written: await deps.statePort.write(merged)
+		written
 	});
 }
 //#endregion
@@ -4462,6 +5379,14 @@ function buildRootPasses(primaryFold) {
 	if (primaryFold.passes.length === 0) return;
 	return Object.fromEntries(primaryFold.passes.map(({ key, entry }) => [key, entry]));
 }
+function buildFullPassOverlay(entry) {
+	return {
+		name: entry.name,
+		description: entry.description,
+		icon: entry.icon,
+		...entry.price !== void 0 && { price: entry.price }
+	};
+}
 function buildPassOverlayEntry(entry, primary) {
 	const overlay = {};
 	if (!Object.is(primary.name, entry.name)) overlay.name = entry.name;
@@ -4475,7 +5400,7 @@ function buildPassesOverlay(fold, primary) {
 	const overlay = {};
 	for (const { key, entry } of fold.passes) {
 		const primaryEntry = primaryByKey.get(key);
-		const passOverlay = primaryEntry === void 0 ? { ...entry } : buildPassOverlayEntry(entry, primaryEntry);
+		const passOverlay = primaryEntry === void 0 ? buildFullPassOverlay(entry) : buildPassOverlayEntry(entry, primaryEntry);
 		if (passOverlay !== void 0) overlay[key] = passOverlay;
 	}
 	return Object.keys(overlay).length === 0 ? void 0 : overlay;
@@ -5008,7 +5933,7 @@ const PRODUCT_ICON_KIND = "productIcon";
 * and the Roblox-assigned `iconImageAssetId` lands on the outputs.
 *
 * Resources whose payload is malformed (non-object, missing required string
-* field, missing `productId`, malformed `fileHash`) are dropped silently.
+* field, missing `assetId`, malformed `fileHash`) are dropped silently.
 * Orphan `productIcon_<k>` resources (no matching product) emit one
 * `ambiguous` warning each.
 *
@@ -5071,7 +5996,7 @@ function readProductInputs(raw) {
 }
 function readProductOutputs(raw) {
 	if (!isObjectPayload$1(raw)) return;
-	const productId = coerceRobloxId$2(raw["productId"]);
+	const productId = coerceRobloxId$2(raw["assetId"]);
 	if (productId === void 0) return;
 	return { productId };
 }
@@ -6038,6 +6963,6 @@ function isFileMissing(err) {
 	return typeof err === "object" && err !== null && "code" in err && typeof err.code === "string" && FILE_MISSING_CODES.has(err.code);
 }
 //#endregion
-export { shouldReuploadIcon as A, renderDeployError as B, UNIVERSE_SINGLETON_KEY as C, validateEnvironmentName as D, serializeStateFile as E, isRobloxAssetId as F, renderStateWriteError as G, renderMigrateParseError as H, isSha256Hex as I, derivePriceFields as L, asRobloxAssetId as M, asSha256Hex as N, createGamePassDriver as O, isResourceKey as P, createClackProgressAdapter as R, SOCIAL_LINK_FIELDS as S, parseStateFile as T, renderMigrationSummary as U, renderMigrateError as V, renderParseError as W, isGistStateConfig as _, buildStatePort as a, createUniverseDriver as b, applyOps as c, resolveStateConfig as d, flattenConfig as f, defaultKindRegistry as g, diff as h, loadConfig$1 as i, asResourceKey as j, createDeveloperProductDriver as k, validatePlan as l, renderDisplayNamePrefix as m, serializeConfig as n, buildDesired as o, DEFAULT_PREFIX_FORMAT as p, deploy as r, buildDefaultRegistry as s, migrateMantleState as t, selectEnvironment as u, validateConfig as v, createGistStateAdapter as w, createPlaceDriver as x, createClackPort as y, renderBuildStatePortError as z };
+export { createClackProgressAdapter as A, isSha256Hex as B, UNIVERSE_SINGLETON_KEY as C, createGamePassDriver as D, serializeStateFile as E, asResourceKey as F, renderMigrateParseError as G, renderBuildStatePortError as H, asRobloxAssetId as I, renderStateWriteError as J, renderMigrationSummary as K, asSha256Hex as L, validateConfig as M, shouldReuploadIcon as N, createDeveloperProductDriver as O, validateEnvironmentName as P, isResourceKey as R, SOCIAL_LINK_FIELDS as S, parseStateFile as T, renderDeployError as U, resolveStateConfig as V, renderMigrateError as W, diff as _, buildStatePort as a, createUniverseDriver as b, applyOps as c, selectEnvironment as d, selectMergedEnvironment as f, renderDisplayNamePrefix as g, DEFAULT_PREFIX_FORMAT as h, loadConfig$1 as i, isGistStateConfig as j, derivePriceFields as k, validatePlan as l, flattenConfig as m, serializeConfig as n, buildDesired as o, collectRedactionAnnotations as p, renderParseError as q, deploy as r, buildDefaultRegistry as s, migrateMantleState as t, extractResourceRedaction as u, defaultKindRegistry as v, createGistStateAdapter as w, createPlaceDriver as x, createClackPort as y, isRobloxAssetId as z };
 
-//# sourceMappingURL=migrate-mantle-state-Dkk5zGHw.mjs.map
+//# sourceMappingURL=migrate-mantle-state-qejWFAR0.mjs.map