@timber-js/app 0.2.0-alpha.21 → 0.2.0-alpha.210

package/dist/_chunks/cloudflare-Byxl8FWP.js

@@ -0,0 +1,1333 @@
+import { t as RSC_CONTENT_TYPE } from "./rsc-media-type-DDc7duTD.js";
+import { t as RSC_KEY_HEADERS } from "./rsc-cache-key-ClUiXQnK.js";
+import { n as runSharedBuildSteps, o as adapterBase, r as writeHeadersFile, t as buildStaticDirectoryOutput } from "./build-output-helper-RV_BRcF1.js";
+import { join } from "node:path";
+import { access, cp, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { tmpdir } from "node:os";
+import { execFile } from "node:child_process";
+//#region ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
+/**
+* Creates a JSON scanner on the given text.
+* If ignoreTrivia is set, whitespaces or comments are ignored.
+*/
+function createScanner(text, ignoreTrivia = false) {
+	const len = text.length;
+	let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+	function scanHexDigits(count, exact) {
+		let digits = 0;
+		let value = 0;
+		while (digits < count || !exact) {
+			let ch = text.charCodeAt(pos);
+			if (ch >= 48 && ch <= 57) value = value * 16 + ch - 48;
+			else if (ch >= 65 && ch <= 70) value = value * 16 + ch - 65 + 10;
+			else if (ch >= 97 && ch <= 102) value = value * 16 + ch - 97 + 10;
+			else break;
+			pos++;
+			digits++;
+		}
+		if (digits < count) value = -1;
+		return value;
+	}
+	function setPosition(newPosition) {
+		pos = newPosition;
+		value = "";
+		tokenOffset = 0;
+		token = 16;
+		scanError = 0;
+	}
+	function scanNumber() {
+		let start = pos;
+		if (text.charCodeAt(pos) === 48) pos++;
+		else {
+			pos++;
+			while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+		}
+		if (pos < text.length && text.charCodeAt(pos) === 46) {
+			pos++;
+			if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+				pos++;
+				while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+			} else {
+				scanError = 3;
+				return text.substring(start, pos);
+			}
+		}
+		let end = pos;
+		if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+			pos++;
+			if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) pos++;
+			if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+				pos++;
+				while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+				end = pos;
+			} else scanError = 3;
+		}
+		return text.substring(start, end);
+	}
+	function scanString() {
+		let result = "", start = pos;
+		while (true) {
+			if (pos >= len) {
+				result += text.substring(start, pos);
+				scanError = 2;
+				break;
+			}
+			const ch = text.charCodeAt(pos);
+			if (ch === 34) {
+				result += text.substring(start, pos);
+				pos++;
+				break;
+			}
+			if (ch === 92) {
+				result += text.substring(start, pos);
+				pos++;
+				if (pos >= len) {
+					scanError = 2;
+					break;
+				}
+				switch (text.charCodeAt(pos++)) {
+					case 34:
+						result += "\"";
+						break;
+					case 92:
+						result += "\\";
+						break;
+					case 47:
+						result += "/";
+						break;
+					case 98:
+						result += "\b";
+						break;
+					case 102:
+						result += "\f";
+						break;
+					case 110:
+						result += "\n";
+						break;
+					case 114:
+						result += "\r";
+						break;
+					case 116:
+						result += "	";
+						break;
+					case 117:
+						const ch3 = scanHexDigits(4, true);
+						if (ch3 >= 0) result += String.fromCharCode(ch3);
+						else scanError = 4;
+						break;
+					default: scanError = 5;
+				}
+				start = pos;
+				continue;
+			}
+			if (ch >= 0 && ch <= 31) {
+				if (isLineBreak(ch)) {
+					result += text.substring(start, pos);
+					scanError = 2;
+					break;
+				} else scanError = 6;
+			}
+			pos++;
+		}
+		return result;
+	}
+	function scanNext() {
+		value = "";
+		scanError = 0;
+		tokenOffset = pos;
+		lineStartOffset = lineNumber;
+		prevTokenLineStartOffset = tokenLineStartOffset;
+		if (pos >= len) {
+			tokenOffset = len;
+			return token = 17;
+		}
+		let code = text.charCodeAt(pos);
+		if (isWhiteSpace(code)) {
+			do {
+				pos++;
+				value += String.fromCharCode(code);
+				code = text.charCodeAt(pos);
+			} while (isWhiteSpace(code));
+			return token = 15;
+		}
+		if (isLineBreak(code)) {
+			pos++;
+			value += String.fromCharCode(code);
+			if (code === 13 && text.charCodeAt(pos) === 10) {
+				pos++;
+				value += "\n";
+			}
+			lineNumber++;
+			tokenLineStartOffset = pos;
+			return token = 14;
+		}
+		switch (code) {
+			case 123:
+				pos++;
+				return token = 1;
+			case 125:
+				pos++;
+				return token = 2;
+			case 91:
+				pos++;
+				return token = 3;
+			case 93:
+				pos++;
+				return token = 4;
+			case 58:
+				pos++;
+				return token = 6;
+			case 44:
+				pos++;
+				return token = 5;
+			case 34:
+				pos++;
+				value = scanString();
+				return token = 10;
+			case 47:
+				const start = pos - 1;
+				if (text.charCodeAt(pos + 1) === 47) {
+					pos += 2;
+					while (pos < len) {
+						if (isLineBreak(text.charCodeAt(pos))) break;
+						pos++;
+					}
+					value = text.substring(start, pos);
+					return token = 12;
+				}
+				if (text.charCodeAt(pos + 1) === 42) {
+					pos += 2;
+					const safeLength = len - 1;
+					let commentClosed = false;
+					while (pos < safeLength) {
+						const ch = text.charCodeAt(pos);
+						if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+							pos += 2;
+							commentClosed = true;
+							break;
+						}
+						pos++;
+						if (isLineBreak(ch)) {
+							if (ch === 13 && text.charCodeAt(pos) === 10) pos++;
+							lineNumber++;
+							tokenLineStartOffset = pos;
+						}
+					}
+					if (!commentClosed) {
+						pos++;
+						scanError = 1;
+					}
+					value = text.substring(start, pos);
+					return token = 13;
+				}
+				value += String.fromCharCode(code);
+				pos++;
+				return token = 16;
+			case 45:
+				value += String.fromCharCode(code);
+				pos++;
+				if (pos === len || !isDigit(text.charCodeAt(pos))) return token = 16;
+			case 48:
+			case 49:
+			case 50:
+			case 51:
+			case 52:
+			case 53:
+			case 54:
+			case 55:
+			case 56:
+			case 57:
+				value += scanNumber();
+				return token = 11;
+			default:
+				while (pos < len && isUnknownContentCharacter(code)) {
+					pos++;
+					code = text.charCodeAt(pos);
+				}
+				if (tokenOffset !== pos) {
+					value = text.substring(tokenOffset, pos);
+					switch (value) {
+						case "true": return token = 8;
+						case "false": return token = 9;
+						case "null": return token = 7;
+					}
+					return token = 16;
+				}
+				value += String.fromCharCode(code);
+				pos++;
+				return token = 16;
+		}
+	}
+	function isUnknownContentCharacter(code) {
+		if (isWhiteSpace(code) || isLineBreak(code)) return false;
+		switch (code) {
+			case 125:
+			case 93:
+			case 123:
+			case 91:
+			case 34:
+			case 58:
+			case 44:
+			case 47: return false;
+		}
+		return true;
+	}
+	function scanNextNonTrivia() {
+		let result;
+		do
+			result = scanNext();
+		while (result >= 12 && result <= 15);
+		return result;
+	}
+	return {
+		setPosition,
+		getPosition: () => pos,
+		scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+		getToken: () => token,
+		getTokenValue: () => value,
+		getTokenOffset: () => tokenOffset,
+		getTokenLength: () => pos - tokenOffset,
+		getTokenStartLine: () => lineStartOffset,
+		getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+		getTokenError: () => scanError
+	};
+}
+function isWhiteSpace(ch) {
+	return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+	return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+	return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes) {
+	CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
+	CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
+	CharacterCodes[CharacterCodes["space"] = 32] = "space";
+	CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
+	CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
+	CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
+	CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
+	CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
+	CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
+	CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
+	CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
+	CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
+	CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
+	CharacterCodes[CharacterCodes["a"] = 97] = "a";
+	CharacterCodes[CharacterCodes["b"] = 98] = "b";
+	CharacterCodes[CharacterCodes["c"] = 99] = "c";
+	CharacterCodes[CharacterCodes["d"] = 100] = "d";
+	CharacterCodes[CharacterCodes["e"] = 101] = "e";
+	CharacterCodes[CharacterCodes["f"] = 102] = "f";
+	CharacterCodes[CharacterCodes["g"] = 103] = "g";
+	CharacterCodes[CharacterCodes["h"] = 104] = "h";
+	CharacterCodes[CharacterCodes["i"] = 105] = "i";
+	CharacterCodes[CharacterCodes["j"] = 106] = "j";
+	CharacterCodes[CharacterCodes["k"] = 107] = "k";
+	CharacterCodes[CharacterCodes["l"] = 108] = "l";
+	CharacterCodes[CharacterCodes["m"] = 109] = "m";
+	CharacterCodes[CharacterCodes["n"] = 110] = "n";
+	CharacterCodes[CharacterCodes["o"] = 111] = "o";
+	CharacterCodes[CharacterCodes["p"] = 112] = "p";
+	CharacterCodes[CharacterCodes["q"] = 113] = "q";
+	CharacterCodes[CharacterCodes["r"] = 114] = "r";
+	CharacterCodes[CharacterCodes["s"] = 115] = "s";
+	CharacterCodes[CharacterCodes["t"] = 116] = "t";
+	CharacterCodes[CharacterCodes["u"] = 117] = "u";
+	CharacterCodes[CharacterCodes["v"] = 118] = "v";
+	CharacterCodes[CharacterCodes["w"] = 119] = "w";
+	CharacterCodes[CharacterCodes["x"] = 120] = "x";
+	CharacterCodes[CharacterCodes["y"] = 121] = "y";
+	CharacterCodes[CharacterCodes["z"] = 122] = "z";
+	CharacterCodes[CharacterCodes["A"] = 65] = "A";
+	CharacterCodes[CharacterCodes["B"] = 66] = "B";
+	CharacterCodes[CharacterCodes["C"] = 67] = "C";
+	CharacterCodes[CharacterCodes["D"] = 68] = "D";
+	CharacterCodes[CharacterCodes["E"] = 69] = "E";
+	CharacterCodes[CharacterCodes["F"] = 70] = "F";
+	CharacterCodes[CharacterCodes["G"] = 71] = "G";
+	CharacterCodes[CharacterCodes["H"] = 72] = "H";
+	CharacterCodes[CharacterCodes["I"] = 73] = "I";
+	CharacterCodes[CharacterCodes["J"] = 74] = "J";
+	CharacterCodes[CharacterCodes["K"] = 75] = "K";
+	CharacterCodes[CharacterCodes["L"] = 76] = "L";
+	CharacterCodes[CharacterCodes["M"] = 77] = "M";
+	CharacterCodes[CharacterCodes["N"] = 78] = "N";
+	CharacterCodes[CharacterCodes["O"] = 79] = "O";
+	CharacterCodes[CharacterCodes["P"] = 80] = "P";
+	CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
+	CharacterCodes[CharacterCodes["R"] = 82] = "R";
+	CharacterCodes[CharacterCodes["S"] = 83] = "S";
+	CharacterCodes[CharacterCodes["T"] = 84] = "T";
+	CharacterCodes[CharacterCodes["U"] = 85] = "U";
+	CharacterCodes[CharacterCodes["V"] = 86] = "V";
+	CharacterCodes[CharacterCodes["W"] = 87] = "W";
+	CharacterCodes[CharacterCodes["X"] = 88] = "X";
+	CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
+	CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+	CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
+	CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+	CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
+	CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
+	CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+	CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
+	CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+	CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+	CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
+	CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
+	CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
+	CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
+	CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+	CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
+	CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+new Array(20).fill(0).map((_, index) => {
+	return " ".repeat(index);
+});
+var maxCachedValues = 200;
+new Array(maxCachedValues).fill(0).map((_, index) => {
+	return "\n" + " ".repeat(index);
+}), new Array(maxCachedValues).fill(0).map((_, index) => {
+	return "\r" + " ".repeat(index);
+}), new Array(maxCachedValues).fill(0).map((_, index) => {
+	return "\r\n" + " ".repeat(index);
+}), new Array(maxCachedValues).fill(0).map((_, index) => {
+	return "\n" + "	".repeat(index);
+}), new Array(maxCachedValues).fill(0).map((_, index) => {
+	return "\r" + "	".repeat(index);
+}), new Array(maxCachedValues).fill(0).map((_, index) => {
+	return "\r\n" + "	".repeat(index);
+});
+//#endregion
+//#region ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions) {
+	ParseOptions.DEFAULT = { allowTrailingComma: false };
+})(ParseOptions || (ParseOptions = {}));
+/**
+* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+* Therefore always check the errors list to find out if the input was valid.
+*/
+function parse$1(text, errors = [], options = ParseOptions.DEFAULT) {
+	let currentProperty = null;
+	let currentParent = [];
+	const previousParents = [];
+	function onValue(value) {
+		if (Array.isArray(currentParent)) currentParent.push(value);
+		else if (currentProperty !== null) currentParent[currentProperty] = value;
+	}
+	visit(text, {
+		onObjectBegin: () => {
+			const object = {};
+			onValue(object);
+			previousParents.push(currentParent);
+			currentParent = object;
+			currentProperty = null;
+		},
+		onObjectProperty: (name) => {
+			currentProperty = name;
+		},
+		onObjectEnd: () => {
+			currentParent = previousParents.pop();
+		},
+		onArrayBegin: () => {
+			const array = [];
+			onValue(array);
+			previousParents.push(currentParent);
+			currentParent = array;
+			currentProperty = null;
+		},
+		onArrayEnd: () => {
+			currentParent = previousParents.pop();
+		},
+		onLiteralValue: onValue,
+		onError: (error, offset, length) => {
+			errors.push({
+				error,
+				offset,
+				length
+			});
+		}
+	}, options);
+	return currentParent[0];
+}
+/**
+* Parses the given text and invokes the visitor functions for each object, array and literal reached.
+*/
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+	const _scanner = createScanner(text, false);
+	const _jsonPath = [];
+	let suppressedCallbacks = 0;
+	function toNoArgVisit(visitFunction) {
+		return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+	}
+	function toOneArgVisit(visitFunction) {
+		return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+	}
+	function toOneArgVisitWithPath(visitFunction) {
+		return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+	}
+	function toBeginVisit(visitFunction) {
+		return visitFunction ? () => {
+			if (suppressedCallbacks > 0) suppressedCallbacks++;
+			else if (visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) === false) suppressedCallbacks = 1;
+		} : () => true;
+	}
+	function toEndVisit(visitFunction) {
+		return visitFunction ? () => {
+			if (suppressedCallbacks > 0) suppressedCallbacks--;
+			if (suppressedCallbacks === 0) visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+		} : () => true;
+	}
+	const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+	const disallowComments = options && options.disallowComments;
+	const allowTrailingComma = options && options.allowTrailingComma;
+	function scanNext() {
+		while (true) {
+			const token = _scanner.scan();
+			switch (_scanner.getTokenError()) {
+				case 4:
+					handleError(14);
+					break;
+				case 5:
+					handleError(15);
+					break;
+				case 3:
+					handleError(13);
+					break;
+				case 1:
+					if (!disallowComments) handleError(11);
+					break;
+				case 2:
+					handleError(12);
+					break;
+				case 6: handleError(16);
+			}
+			switch (token) {
+				case 12:
+				case 13:
+					if (disallowComments) handleError(10);
+					else onComment();
+					break;
+				case 16:
+					handleError(1);
+					break;
+				case 15:
+				case 14: break;
+				default: return token;
+			}
+		}
+	}
+	function handleError(error, skipUntilAfter = [], skipUntil = []) {
+		onError(error);
+		if (skipUntilAfter.length + skipUntil.length > 0) {
+			let token = _scanner.getToken();
+			while (token !== 17) {
+				if (skipUntilAfter.indexOf(token) !== -1) {
+					scanNext();
+					break;
+				} else if (skipUntil.indexOf(token) !== -1) break;
+				token = scanNext();
+			}
+		}
+	}
+	function parseString(isValue) {
+		const value = _scanner.getTokenValue();
+		if (isValue) onLiteralValue(value);
+		else {
+			onObjectProperty(value);
+			_jsonPath.push(value);
+		}
+		scanNext();
+		return true;
+	}
+	function parseLiteral() {
+		switch (_scanner.getToken()) {
+			case 11:
+				const tokenValue = _scanner.getTokenValue();
+				let value = Number(tokenValue);
+				if (isNaN(value)) {
+					handleError(2);
+					value = 0;
+				}
+				onLiteralValue(value);
+				break;
+			case 7:
+				onLiteralValue(null);
+				break;
+			case 8:
+				onLiteralValue(true);
+				break;
+			case 9:
+				onLiteralValue(false);
+				break;
+			default: return false;
+		}
+		scanNext();
+		return true;
+	}
+	function parseProperty() {
+		if (_scanner.getToken() !== 10) {
+			handleError(3, [], [2, 5]);
+			return false;
+		}
+		parseString(false);
+		if (_scanner.getToken() === 6) {
+			onSeparator(":");
+			scanNext();
+			if (!parseValue()) handleError(4, [], [2, 5]);
+		} else handleError(5, [], [2, 5]);
+		_jsonPath.pop();
+		return true;
+	}
+	function parseObject() {
+		onObjectBegin();
+		scanNext();
+		let needsComma = false;
+		while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+			if (_scanner.getToken() === 5) {
+				if (!needsComma) handleError(4, [], []);
+				onSeparator(",");
+				scanNext();
+				if (_scanner.getToken() === 2 && allowTrailingComma) break;
+			} else if (needsComma) handleError(6, [], []);
+			if (!parseProperty()) handleError(4, [], [2, 5]);
+			needsComma = true;
+		}
+		onObjectEnd();
+		if (_scanner.getToken() !== 2) handleError(7, [2], []);
+		else scanNext();
+		return true;
+	}
+	function parseArray() {
+		onArrayBegin();
+		scanNext();
+		let isFirstElement = true;
+		let needsComma = false;
+		while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+			if (_scanner.getToken() === 5) {
+				if (!needsComma) handleError(4, [], []);
+				onSeparator(",");
+				scanNext();
+				if (_scanner.getToken() === 4 && allowTrailingComma) break;
+			} else if (needsComma) handleError(6, [], []);
+			if (isFirstElement) {
+				_jsonPath.push(0);
+				isFirstElement = false;
+			} else _jsonPath[_jsonPath.length - 1]++;
+			if (!parseValue()) handleError(4, [], [4, 5]);
+			needsComma = true;
+		}
+		onArrayEnd();
+		if (!isFirstElement) _jsonPath.pop();
+		if (_scanner.getToken() !== 4) handleError(8, [4], []);
+		else scanNext();
+		return true;
+	}
+	function parseValue() {
+		switch (_scanner.getToken()) {
+			case 3: return parseArray();
+			case 1: return parseObject();
+			case 10: return parseString(true);
+			default: return parseLiteral();
+		}
+	}
+	scanNext();
+	if (_scanner.getToken() === 17) {
+		if (options.allowEmptyContent) return true;
+		handleError(4, [], []);
+		return false;
+	}
+	if (!parseValue()) {
+		handleError(4, [], []);
+		return false;
+	}
+	if (_scanner.getToken() !== 17) handleError(9, [], []);
+	return true;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError) {
+	ScanError[ScanError["None"] = 0] = "None";
+	ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+	ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+	ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+	ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
+	ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+	ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind) {
+	SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
+	SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
+	SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
+	SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
+	SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
+	SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
+	SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
+	SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
+	SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
+	SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
+	SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
+	SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+	SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+	SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+	SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
+	SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
+	SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+/**
+* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+* Therefore, always check the errors list to find out if the input was valid.
+*/
+var parse = parse$1;
+var ParseErrorCode;
+(function(ParseErrorCode) {
+	ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
+	ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+	ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+	ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
+	ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
+	ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
+	ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+	ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+	ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+	ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+	ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+	ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+	ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+	ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
+	ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+	ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+//#endregion
+//#region src/adapters/cloudflare.ts
+var BINDINGS_ALS_KEY = Symbol.for("timber:cf-bindings-als");
+function getBindingsAls() {
+	let als = globalThis[BINDINGS_ALS_KEY];
+	if (!als) {
+		als = new AsyncLocalStorage();
+		globalThis[BINDINGS_ALS_KEY] = als;
+	}
+	return als;
+}
+/**
+* Get Cloudflare Worker bindings for the current request.
+*
+* Returns the `env` object passed to the Worker's `fetch` handler,
+* giving direct access to KV, D1, Durable Objects, R2, Queues, and
+* any other bindings configured in `wrangler.jsonc`.
+*
+* Must be called within a request context (server component, middleware,
+* server action). Throws outside a request.
+*
+* @example
+* ```ts
+* import { getCloudflareBindings } from '@timber-js/app/adapters/cloudflare'
+*
+* export default async function Page() {
+*   const { MY_KV, MY_DB } = getCloudflareBindings()
+*   const data = await MY_KV.get('key')
+*   return <div>{data}</div>
+* }
+* ```
+*/
+function getCloudflareBindings() {
+	const env = getBindingsAls().getStore();
+	if (!env) throw new Error("getCloudflareBindings() called outside a Cloudflare Workers request context. It can only be called from server components, middleware, or server actions when running on the Cloudflare adapter.");
+	return env;
+}
+/**
+* Run a function with Cloudflare bindings available via getCloudflareBindings().
+* @internal Used by cloudflareDevBindings() to wrap dev-server requests.
+*/
+function runWithBindings(env, fn) {
+	return getBindingsAls().run(env, fn);
+}
+/**
+* Create a Cloudflare Workers adapter.
+*
+* @example
+* ```ts
+* import { cloudflare } from '@timber-js/app/adapters/cloudflare'
+*
+* export default {
+*   output: 'server',
+*   adapter: cloudflare(),
+* }
+* ```
+*/
+function cloudflare(options = {}) {
+	return {
+		name: "cloudflare",
+		async buildOutput(config, artifacts) {
+			const outDir = join(artifacts.outputDir, "cloudflare");
+			if (artifacts.output === "static") {
+				await buildStaticOutput(config, artifacts, outDir, options);
+				return;
+			}
+			await rm(join(outDir, "prebuilt"), {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			await rm(join(outDir, "static", "prebuilt"), {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			await runSharedBuildSteps({
+				config,
+				artifacts: {
+					...artifacts,
+					prebuilt: void 0
+				},
+				outDir,
+				publicDirName: "static"
+			});
+			let hasWorkerHandlers = false;
+			if (options.workerHandlers) {
+				const handlersEntry = join(process.cwd(), options.workerHandlers);
+				const { build: viteBuild } = await import("vite");
+				await viteBuild({
+					configFile: false,
+					logLevel: "info",
+					build: {
+						lib: {
+							entry: handlersEntry,
+							formats: ["es"],
+							fileName: () => "_worker-handlers.js"
+						},
+						outDir,
+						emptyOutDir: false,
+						minify: false,
+						rollupOptions: { external: [/^node:/, /^cloudflare:/] }
+					}
+				});
+				hasWorkerHandlers = true;
+			}
+			const prebuiltData = artifacts.prebuilt ? await readPrebuiltData(artifacts.prebuilt.path) : null;
+			await writeFile(join(outDir, "_timber-prebuilt-source.js"), generatePrebuiltSourceModule(prebuiltData));
+			await writeFile(join(outDir, "_timber-runtime-init.js"), generateRuntimeInitModule());
+			const workerEntry = generateWorkerEntry(!!artifacts.manifestInit, hasWorkerHandlers);
+			await writeFile(join(outDir, "_worker.js"), workerEntry);
+			const wranglerConfig = generateWranglerConfig(config, options, await readUserWranglerConfig(config.root ?? process.cwd()));
+			await writeFile(join(outDir, "wrangler.jsonc"), JSON.stringify(wranglerConfig, null, 2));
+		},
+		async preview(config, target) {
+			const base = adapterBase(config);
+			if (target.output !== "static" || base === "/") {
+				const cmd = generatePreviewCommand(target);
+				await spawnPreviewProcess(cmd.command, cmd.args, cmd.cwd);
+				return;
+			}
+			const stage = await mkdtemp(join(tmpdir(), "timber-pages-preview-"));
+			try {
+				await stagePagesPreview(join(target.outputDir, "cloudflare"), base, stage);
+				const cmd = generatePreviewCommand(target, stage);
+				await spawnPreviewProcess(cmd.command, cmd.args, cmd.cwd);
+			} finally {
+				await rm(stage, {
+					recursive: true,
+					force: true
+				});
+			}
+		}
+	};
+}
+/** @internal Exported for testing. */
+function generateWorkerEntry(hasManifestInit = false, hasWorkerHandlers = false) {
+	const manifestImport = hasManifestInit ? "import './_timber-manifest-init.js'\n" : "";
+	const handlersImport = hasWorkerHandlers ? "import * as workerHandlers from './_worker-handlers.js'\n" : "";
+	const handlersSpread = hasWorkerHandlers ? "  ...workerHandlers,\n" : "";
+	return `// Generated by @timber-js/app/adapters/cloudflare
+// Do not edit — this file is regenerated on each build.
+
+import { AsyncLocalStorage } from 'node:async_hooks'
+// Side-effect imports: evaluated IN ORDER before the _worker.js body runs.
+// _timber-runtime-init.js sets TIMBER_RUNTIME before createRequestHandler()
+// runs (during the RSC entry's top-level await) so the auto-wire for
+// WorkersCachePurge can detect the Cloudflare runtime (TIM-1170).
+// _timber-prebuilt-source.js sets globalThis.__TIMBER_PREBUILT_SOURCE__
+// for cache.component payloads.
+import './_timber-runtime-init.js'
+import './_timber-prebuilt-source.js'
+${manifestImport}import handler, { runWithWaitUntil, runWithWorkersCachePurge, stripHeadBody } from './rsc/index.js'
+${handlersImport}
+
+// Bind Cloudflare env to ALS so getCloudflareBindings() works at runtime.
+// Uses the same Symbol.for key as getCloudflareBindings() reads from.
+const ALS_KEY = Symbol.for('timber:cf-bindings-als')
+let bindingsAls = globalThis[ALS_KEY]
+if (!bindingsAls) {
+  bindingsAls = new AsyncLocalStorage()
+  globalThis[ALS_KEY] = bindingsAls
+}
+
+// Register timber's platform tracer so pipeline phase spans (timber.proxy,
+// timber.middleware, timber.render, timber.access, timber.action, …) appear
+// as native Cloudflare spans in the Observability dashboard, nested under
+// the auto-instrumented fetch/KV/D1 spans. Requires observability.traces
+// enabled in wrangler.jsonc (generated by default).
+//
+// Lazily imported and guarded: runtimes without the custom spans API
+// (older compatibility dates, older local workerd) fall back to OTEL-only
+// emission. withSpan() in the framework composes both channels.
+const TRACER_KEY = Symbol.for('timber:platform-tracer')
+let tracerInit
+function initPlatformTracer() {
+  tracerInit ??= import('cloudflare:workers')
+    .then(({ tracing }) => {
+      if (tracing && typeof tracing.enterSpan === 'function') {
+        globalThis[TRACER_KEY] ??= {
+          enterSpan: (name, fn) => tracing.enterSpan(name, fn),
+        }
+      }
+    })
+    .catch(() => {})
+  return tracerInit
+}
+
+// The \`Vary\` tokens this cache can serve a correct answer for.
+//
+// Cloudflare's Cache API keys on the request URL. It does not implement
+// RFC 9111 §4.1 secondary key selection, so a stored response is handed to
+// every request for that URL regardless of what \`Vary\` nominates — except
+// \`Accept-Encoding\`, which the platform segregates itself. Storing a
+// response whose \`Vary\` says "this answer is specific to header H" under a
+// key that ignores H is cross-client reuse (TIM-1269): a developer writing
+// the correct \`public, s-maxage=60\` + \`Vary: Cookie\` gets their logged-in
+// page served to anonymous visitors. Refusing to store is the conservative
+// answer, and the only one available without rewriting the key.
+//
+// The framework's own tokens are on this list because the adapter already
+// segregates them, more strictly than \`Vary\` would:
+//
+//   - \`Accept\` — \`isRsc\` above excludes \`text/x-component\` from both lookup
+//     and store, so the HTML/Flight split \`Vary: Accept\` exists to protect
+//     never reaches this cache in the first place.
+//   - \`X-Timber-State-Tree\`, \`X-Timber-URL\`, \`X-Timber-Deployment-Id\` — the
+//     origin reads all three only on RSC requests (version skew at
+//     \`server/pipeline-phases.ts\`, interception rewrites likewise, state-tree
+//     diffing at \`server/rsc-entry/render-route.ts\`). On the non-RSC requests
+//     this cache stores, they cannot change the response.
+//
+// That second bullet is a coupling, not an observation: if any of those
+// headers ever starts varying a document response, this list is wrong and
+// the cache poisons. Because the list is derived, a header added to
+// \`RSC_KEY_HEADERS\` inherits the exemption silently — so
+// \`tests/adapters/cloudflare-vary.test.ts\` fails until that header is named
+// there alongside the evidence for its gate, and the gates themselves are
+// covered there, in \`tests/render-route.test.ts\`, and in
+// \`tests/interception-x-timber-url.test.ts\`.
+//
+// Interpolated from \`RSC_KEY_HEADERS\` rather than spelled again — "which
+// headers vary an RSC response" has one answer, and a hand-copied second
+// list here would drift silently on the fallback path nobody exercises.
+//
+// Known residual: a route handler that content-negotiates on \`Accept\`
+// (JSON vs HTML) *and* marks itself \`public\` is still mis-keyed, because the
+// \`isRsc\` split is binary and does not separate those two. That is no worse
+// than the pre-TIM-1269 behaviour, which stored every \`Vary\` but \`*\`.
+const VARY_HONORED = new Set(${JSON.stringify(["accept-encoding", ...RSC_KEY_HEADERS.map((h) => h.toLowerCase())])})
+
+// Applied to BOTH sides of the cache — what may be stored, and what a hit
+// may serve. Refusing to store only stops new poisoning: entries a previous
+// deployment wrote under the old predicate stay servable for whatever
+// s-maxage the developer chose, which can be a day. Checking on the way out
+// makes the fix take effect on deploy rather than on expiry, and costs one
+// header read per hit. A rejected entry falls through to the origin and is
+// then declined by the same predicate on the way back in, so it is not
+// rewritten — it simply ages out.
+function canHonorVary(vary) {
+  // Absent or empty Vary nominates nothing — the URL is the whole key.
+  if (!vary) return true
+  return vary.split(',').every((token) => VARY_HONORED.has(token.trim().toLowerCase()))
+}
+
+export default {
+${handlersSpread}  async fetch(request, env, ctx) {
+    // One-time on first request; resolved-promise await thereafter.
+    await initPlatformTracer()
+
+    // Edge-cache GET/HEAD responses via the Cache API (caches.default).
+    // caches.default and ctx.cache.purge() operate on the same underlying
+    // Cloudflare CDN cache — "independent" in the CF docs means independent
+    // write APIs, not independent stores (TIM-1172). Tag-based purging via
+    // revalidateTag() clears entries stored here when their Cache-Tag header
+    // matches the invalidated tag. See design/25 §TIM-1172.
+    //
+    // RSC navigation requests (Accept: text/x-component) are excluded.
+    // Their varying inputs are now in the URL via ?_rsc= (TIM-1268), but
+    // this cache keys on the request URL alone and cannot honour Vary, so a
+    // payload request that arrives without the param — stripped query,
+    // hand-rolled client — would share a key with the document.
+    //
+    // This exclusion is load-bearing in the other direction too: the store
+    // predicate below treats "Vary: Accept" as honoured *because* of it
+    // (see VARY_HONORED). Removing it would make that allowlist unsound.
+    const isRsc = request.headers.get('Accept')?.includes(${JSON.stringify(RSC_CONTENT_TYPE)})
+    const reqCc = request.headers.get('Cache-Control') || ''
+    const bypassCache = reqCc.includes('no-cache') || reqCc.includes('max-age=0')
+        || request.headers.has('Pragma')
+    const cacheable = !isRsc && !bypassCache
+        && (request.method === 'GET' || request.method === 'HEAD')
+    const cache = cacheable && typeof caches !== 'undefined' ? caches.default : null
+    if (cache) {
+      const cached = await cache.match(request)
+      // A hit whose Vary this cache cannot key on is treated as a miss —
+      // see canHonorVary. Entries written before that predicate existed are
+      // exactly the ones that would be served to the wrong client.
+      if (cached) {
+        if (canHonorVary(cached.headers.get('Vary'))) return stripHeadBody(cached, request.method)
+        // Declining the hit means nobody will ever read this body. Release
+        // it rather than leaving the stream dangling for the rest of the
+        // request (design/02-rendering-pipeline.md §"Cancel Readers When You
+        // No Longer Need the Stream").
+        cached.body?.cancel().catch(() => {})
+      }
+    }
+
+    // Bridge ctx.cache into the per-request ALS so WorkersCachePurge can
+    // call ctx.cache.purge({ tags }) during cache.invalidate/revalidateTag.
+    // Workers Cache is available on all Cloudflare plans — no API token needed.
+    const workersCacheCtx = ctx.cache && typeof ctx.cache.purge === 'function' ? ctx.cache : null
+    const runHandler = () =>
+      runWithWaitUntil((promise) => ctx.waitUntil(promise), () => handler(request))
+    const response = await bindingsAls.run(env, () =>
+      workersCacheCtx
+        ? runWithWorkersCachePurge(workersCacheCtx, runHandler)
+        : runHandler()
+    )
+
+    // Cache public responses at the edge. A response is edge-cacheable if
+    // it has 'public' or 's-maxage' (a shared-cache TTL directive) and no
+    // 'no-store' or 'private'. Cloudflare's cache.put() only accepts GET
+    // requests and rejects 206, so only store GET 200s. HEAD requests
+    // are served from cache.match() hits with the body stripped (TIM-1325).
+    // See design/25-production-deployments.md §"CDN / Edge Cache".
+    if (cache && request.method === 'GET' && response.status === 200) {
+      const cc = response.headers.get('Cache-Control')
+      if (cc && !cc.includes('no-store') && !cc.includes('private')
+          && (cc.includes('public') || cc.includes('s-maxage'))
+          && canHonorVary(response.headers.get('Vary'))
+          && !response.headers.has('Set-Cookie')) {
+        ctx.waitUntil(cache.put(request, response.clone()))
+      }
+    }
+
+    return response
+  }
+}
+`;
+}
+/**
+* Read the prebuilt flight payloads the capture pass wrote. Called only
+* when the build produced a `prebuilt` artifact, which always carries its
+* `manifest.json` — so a read failure here is a real error, not absence.
+*
+* @internal Exported for testing.
+*/
+async function readPrebuiltData(prebuiltDir) {
+	const manifestJson = await readFile(join(prebuiltDir, "manifest.json"), "utf-8");
+	const payloads = [];
+	const componentDirs = await readdir(prebuiltDir, { withFileTypes: true });
+	for (const dir of componentDirs) {
+		if (!dir.isDirectory()) continue;
+		const files = await readdir(join(prebuiltDir, dir.name));
+		for (const file of files) if (file.endsWith(".flight")) {
+			const filePath = `${dir.name}/${file}`;
+			const bytes = await readFile(join(prebuiltDir, filePath));
+			payloads.push({
+				file: filePath,
+				bytes
+			});
+		}
+	}
+	return {
+		manifestJson,
+		payloads
+	};
+}
+/**
+* Generate the prebuilt payload source module for Cloudflare Workers.
+*
+* Inlines manifest JSON and flight payload bytes directly into the module
+* so they're part of the worker's JS bundle — no external Text/Data module
+* imports needed. This avoids depending on wrangler's find_additional_modules
+* to discover non-JS files, which doesn't reliably resolve Text/Data imports.
+*
+* @internal Exported for testing.
+*/
+function generatePrebuiltSourceModule(data) {
+	if (!data) return `// Generated by @timber-js/app/adapters/cloudflare
+// No prebuilt artifacts — all cache.component wrappers render dynamically.
+globalThis.__TIMBER_PREBUILT_SOURCE__ = {
+  async loadManifest() { return null },
+  async readPayload() { return null },
+}
+`;
+	const entries = [];
+	for (const { file, bytes } of data.payloads) {
+		const b64 = Buffer.from(bytes).toString("base64");
+		entries.push(`  ${JSON.stringify(file)}: ${JSON.stringify(b64)}`);
+	}
+	return `// Generated by @timber-js/app/adapters/cloudflare
+// Prebuilt payload source — inlines cache.component flight payloads
+// directly into the worker bundle (TIM-1162).
+const _manifest = ${data.manifestJson.trim()}
+
+function _decode(b64) {
+  const bin = atob(b64)
+  const buf = new Uint8Array(bin.length)
+  for (let i = 0; i < bin.length; i++) buf[i] = bin.charCodeAt(i)
+  return buf
+}
+
+const _payloads = {
+${entries.join(",\n")}
+}
+
+globalThis.__TIMBER_PREBUILT_SOURCE__ = {
+  async loadManifest() { return _manifest },
+  async readPayload(file) {
+    const b64 = _payloads[file]
+    return b64 ? _decode(b64) : null
+  },
+}
+`;
+}
+/**
+* Generate the runtime init module that sets TIMBER_RUNTIME before the
+* RSC entry evaluates. Imported as a side-effect module in _worker.js.
+*
+* @internal Exported for testing.
+*/
+function generateRuntimeInitModule() {
+	return `// Generated by @timber-js/app/adapters/cloudflare
+// Sets TIMBER_RUNTIME before the RSC handler evaluates (TIM-1170).
+// Must be a separate module imported before rsc/index.js so that ESM
+// evaluation order guarantees the env var is set when
+// createRequestHandler() runs its auto-wire logic.
+globalThis.process ??= { env: {} }
+process.env.TIMBER_RUNTIME = 'cloudflare'
+`;
+}
+/**
+* Convert declarative `CloudflareBindings` into wrangler.jsonc binding sections.
+*
+* Maps:
+* - `kv`             → `kv_namespaces`
+* - `d1`             → `d1_databases`
+* - `r2`             → `r2_buckets`
+* - `queues`         → `queues` (producers + consumers)
+* - `durableObjects` → `durable_objects`
+*
+* Empty arrays are omitted from the output.
+*
+* @internal Exported for testing.
+*/
+function generateBindingsConfig(bindings) {
+	if (!bindings) return {};
+	const result = {};
+	if (bindings.kv && bindings.kv.length > 0) result.kv_namespaces = bindings.kv.map((kv) => ({
+		binding: kv.name,
+		id: kv.id ?? ""
+	}));
+	if (bindings.d1 && bindings.d1.length > 0) result.d1_databases = bindings.d1.map((d1) => ({
+		binding: d1.name,
+		database_id: d1.database_id
+	}));
+	if (bindings.r2 && bindings.r2.length > 0) result.r2_buckets = bindings.r2.map((r2) => ({
+		binding: r2.name,
+		bucket_name: r2.bucket_name
+	}));
+	if (bindings.queues) {
+		const queues = {};
+		if (bindings.queues.producers && bindings.queues.producers.length > 0) queues.producers = bindings.queues.producers.map((p) => ({
+			binding: p.name,
+			queue: p.queue
+		}));
+		if (bindings.queues.consumers && bindings.queues.consumers.length > 0) queues.consumers = bindings.queues.consumers.map((c) => {
+			const consumer = { queue: c.queue };
+			if (c.max_batch_size !== void 0) consumer.max_batch_size = c.max_batch_size;
+			if (c.max_retries !== void 0) consumer.max_retries = c.max_retries;
+			if (c.dead_letter_queue !== void 0) consumer.dead_letter_queue = c.dead_letter_queue;
+			return consumer;
+		});
+		if (Object.keys(queues).length > 0) result.queues = queues;
+	}
+	if (bindings.durableObjects && bindings.durableObjects.length > 0) result.durable_objects = { bindings: bindings.durableObjects.map((dobj) => {
+		const entry = {
+			name: dobj.name,
+			class_name: dobj.class_name
+		};
+		if (dobj.script_name) entry.script_name = dobj.script_name;
+		return entry;
+	}) };
+	return result;
+}
+/**
+* One-level deep merge: for each key in `override`, if both the base and
+* override values are plain objects (not arrays, not null), merge their
+* keys with override winning on conflicts. Everything else (primitives,
+* arrays, null) is replaced outright — matching the intuitive behavior
+* where `kv_namespaces: [...]` replaces fully but
+* `durable_objects: { migrations }` merges with generated `bindings`.
+*/
+function shallowDeepMerge(base, override) {
+	const result = { ...base };
+	for (const key of Object.keys(override)) {
+		const baseVal = result[key];
+		const overVal = override[key];
+		if (isPlainObject(baseVal) && isPlainObject(overVal)) result[key] = {
+			...baseVal,
+			...overVal
+		};
+		else result[key] = overVal;
+	}
+	return result;
+}
+/** True for `{}` literals — false for arrays, null, Date, etc. */
+function isPlainObject(val) {
+	return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+var WRANGLER_CONFIG_FILES = ["wrangler.jsonc", "wrangler.json"];
+/**
+* Read the user's wrangler config from the project root, if one exists.
+* Checks wrangler.jsonc first, then wrangler.json.
+* @internal Exported for testing.
+*/
+async function readUserWranglerConfig(root) {
+	for (const filename of WRANGLER_CONFIG_FILES) {
+		const filepath = join(root, filename);
+		try {
+			await access(filepath);
+		} catch {
+			continue;
+		}
+		return parse(await readFile(filepath, "utf-8"));
+	}
+	return null;
+}
+/** @internal Exported for testing. */
+function generateWranglerConfig(config, options, userConfig) {
+	const base = {
+		name: "timber-app",
+		main: "_worker.js",
+		compatibility_date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+		compatibility_flags: ["nodejs_compat"],
+		no_bundle: true,
+		find_additional_modules: true,
+		rules: [{
+			type: "ESModule",
+			globs: ["**/*.js"]
+		}],
+		assets: {
+			directory: "./static",
+			binding: "ASSETS"
+		},
+		observability: { traces: { enabled: true } }
+	};
+	let merged = userConfig ? shallowDeepMerge(base, userConfig) : base;
+	const explicit = {};
+	if (options.name != null) explicit.name = options.name;
+	if (options.compatibilityDate != null) explicit.compatibility_date = options.compatibilityDate;
+	if (options.compatibilityFlags != null) explicit.compatibility_flags = options.compatibilityFlags;
+	if (Object.keys(explicit).length > 0) merged = {
+		...merged,
+		...explicit
+	};
+	const bindingsConfig = generateBindingsConfig(options.bindings);
+	merged = shallowDeepMerge(merged, bindingsConfig);
+	if (options.wrangler) merged = shallowDeepMerge(merged, options.wrangler);
+	delete merged.env;
+	merged.main = "_worker.js";
+	merged.find_additional_modules = true;
+	return merged;
+}
+/**
+* Build a Cloudflare Pages-compatible static output directory.
+*
+* No Workers entry — just pre-rendered HTML, RSC flight files, and client
+* assets in a flat directory. Uses the shared buildStaticDirectoryOutput
+* then adds a `_headers` file for cache control.
+*
+* @internal Exported for testing.
+*/
+async function buildStaticOutput(config, artifacts, outDir, _options) {
+	await buildStaticDirectoryOutput(config, artifacts, outDir, ".");
+	await writeHeadersFile(outDir, config, artifacts);
+}
+/**
+* A server build runs its Worker under `wrangler dev` with the generated
+* wrangler.jsonc. A static build writes no Worker and no wrangler.jsonc — its
+* output is a Pages directory (`_headers`, `_redirects`, the site) — so it
+* is served by `wrangler pages dev`, which applies those files as Pages does.
+*
+* @internal Exported for testing.
+*/
+function generatePreviewCommand({ output, outputDir }, pagesRoot = join(outputDir, "cloudflare")) {
+	if (output === "static") return {
+		command: "wrangler",
+		args: [
+			"pages",
+			"dev",
+			pagesRoot
+		],
+		cwd: pagesRoot
+	};
+	const cfDir = join(outputDir, "cloudflare");
+	return {
+		command: "wrangler",
+		args: [
+			"dev",
+			"--local",
+			"--config",
+			join(cfDir, "wrangler.jsonc")
+		],
+		cwd: cfDir
+	};
+}
+/** Pages config files, read from the served root; their rules are in deployed-URL space. */
+var PAGES_ROOT_FILES = ["_headers", "_redirects"];
+/**
+* Stage a static Cloudflare build for `wrangler pages dev` under a non-root
+* base. The build writes the site at the directory root (a Pages project is
+* served at its domain root, and the base path is supplied by whatever routes
+* to it), but its HTML requests `/repo/...` and its `_headers`/`_redirects`
+* rules are base-prefixed. Serving the directory as-is would 404 every page
+* and asset, so the preview mounts the site at the base and keeps the rule
+* files at the root, where Pages reads them and where their prefixed
+* patterns match.
+*
+* @param base Normalized deployment base, not `/`.
+* @internal Exported for testing.
+*/
+async function stagePagesPreview(siteDir, base, stageDir) {
+	const mount = join(stageDir, ...base.split("/").filter(Boolean));
+	await cp(siteDir, mount, { recursive: true });
+	const rootFiles = new Set(await readdir(mount));
+	for (const name of PAGES_ROOT_FILES) if (rootFiles.has(name)) await rename(join(mount, name), join(stageDir, name));
+}
+/**
+* Spawn a long-running preview process and pipe stdio to the parent.
+* Resolves when the process exits.
+*/
+function spawnPreviewProcess(command, args, cwd) {
+	return new Promise((resolve, reject) => {
+		const child = execFile(command, args, { cwd }, (err) => {
+			if (err) reject(err);
+			else resolve();
+		});
+		child.stdout?.pipe(process.stdout);
+		child.stderr?.pipe(process.stderr);
+	});
+}
+//#endregion
+export { generatePreviewCommand as a, generateWranglerConfig as c, readUserWranglerConfig as d, runWithBindings as f, generatePrebuiltSourceModule as i, getCloudflareBindings as l, cloudflare as n, generateRuntimeInitModule as o, stagePagesPreview as p, generateBindingsConfig as r, generateWorkerEntry as s, buildStaticOutput as t, readPrebuiltData as u };
+
+//# sourceMappingURL=cloudflare-Byxl8FWP.js.map