@timber-js/app 0.2.0-alpha.186 → 0.2.0-alpha.187

package/dist/_chunks/rsc-media-type-DRqE_lD_.js

@@ -0,0 +1,46 @@
+//#region src/shared/rsc-media-type.ts
+/**
+* The RSC Flight media type, and the request predicate over it.
+*
+* One module owns the string because two independently-written spellings of
+* "is this an RSC request?" must agree, and the consequence of them
+* disagreeing is cache poisoning rather than a visible bug. The Cloudflare
+* adapter's `isRsc` decides what may enter the edge cache; the origin's
+* pipeline decides which headers may vary the response. TIM-1269 made the
+* adapter's `VARY_HONORED` allowlist exempt `Accept` *because* `isRsc`
+* excludes Flight responses from the cache, and exempt the `X-Timber-*`
+* headers *because* the origin reads them only behind its own RSC check. If
+* one predicate is ever tightened (a real media-type parse, a
+* parameter-aware match) and the other is not, the adapter can classify a
+* request as a document while the origin treats it as RSC, and store a
+* Flight payload under the document's key — the class
+* `design/48-payload-addressing.md` exists to prevent.
+*
+* `tests/rsc-media-type-single-source.test.ts` fails if the literal reappears
+* in executable source outside this file.
+*
+* Isomorphic: zero imports, so `adapters/cloudflare.ts` — which Node's native
+* ESM loader evaluates before Vite's resolver exists — can load it and
+* interpolate the value into the generated worker. Same precedent as
+* `shared/rsc-cache-key.ts`.
+*
+* See design/19-client-navigation.md, design/25-production-deployments.md
+* §"`Vary` and the Workers Cache API".
+*/
+/** Media type of a React Flight payload. */
+var RSC_CONTENT_TYPE = "text/x-component";
+/**
+* Is this request asking for an RSC payload rather than a full document?
+*
+* Substring containment, deliberately: `Accept` is a list, and a client may
+* send `text/x-component;charset=utf-8` or list it alongside other types.
+* Tightening this to a real media-type parse is a behaviour change that has
+* to move the adapter's generated `isRsc` in the same commit — see above.
+*/
+function isRscRequest(req) {
+	return (req.headers.get("Accept") ?? "").includes(RSC_CONTENT_TYPE);
+}
+//#endregion
+export { isRscRequest as n, RSC_CONTENT_TYPE as t };
+
+//# sourceMappingURL=rsc-media-type-DRqE_lD_.js.map

package/dist/_chunks/rsc-media-type-DRqE_lD_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsc-media-type-DRqE_lD_.js","names":[],"sources":["../../src/shared/rsc-media-type.ts"],"sourcesContent":["/**\n * The RSC Flight media type, and the request predicate over it.\n *\n * One module owns the string because two independently-written spellings of\n * \"is this an RSC request?\" must agree, and the consequence of them\n * disagreeing is cache poisoning rather than a visible bug. The Cloudflare\n * adapter's `isRsc` decides what may enter the edge cache; the origin's\n * pipeline decides which headers may vary the response. TIM-1269 made the\n * adapter's `VARY_HONORED` allowlist exempt `Accept` *because* `isRsc`\n * excludes Flight responses from the cache, and exempt the `X-Timber-*`\n * headers *because* the origin reads them only behind its own RSC check. If\n * one predicate is ever tightened (a real media-type parse, a\n * parameter-aware match) and the other is not, the adapter can classify a\n * request as a document while the origin treats it as RSC, and store a\n * Flight payload under the document's key — the class\n * `design/48-payload-addressing.md` exists to prevent.\n *\n * `tests/rsc-media-type-single-source.test.ts` fails if the literal reappears\n * in executable source outside this file.\n *\n * Isomorphic: zero imports, so `adapters/cloudflare.ts` — which Node's native\n * ESM loader evaluates before Vite's resolver exists — can load it and\n * interpolate the value into the generated worker. Same precedent as\n * `shared/rsc-cache-key.ts`.\n *\n * See design/19-client-navigation.md, design/25-production-deployments.md\n * §\"`Vary` and the Workers Cache API\".\n */\n\n/** Media type of a React Flight payload. */\nexport const RSC_CONTENT_TYPE = 'text/x-component';\n\n/**\n * Is this request asking for an RSC payload rather than a full document?\n *\n * Substring containment, deliberately: `Accept` is a list, and a client may\n * send `text/x-component;charset=utf-8` or list it alongside other types.\n * Tightening this to a real media-type parse is a behaviour change that has\n * to move the adapter's generated `isRsc` in the same commit — see above.\n */\nexport function isRscRequest(req: Request): boolean {\n  return (req.headers.get('Accept') ?? '').includes(RSC_CONTENT_TYPE);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,mBAAmB;;;;;;;;;AAUhC,SAAgB,aAAa,KAAuB;CAClD,QAAQ,IAAI,QAAQ,IAAI,QAAQ,KAAK,GAAA,CAAI,SAAS,gBAAgB;AACpE"}

package/dist/_chunks/{cli-schema-sync-CKgHC2MB.js → scanner-C8b0Gcw3.js}

@@ -1,10 +1,8 @@
-import { o as __exportAll } from "./dist-BA3u1z3W.js";
 import { i as NULL_BYTE_RE, n as treePathDepth, r as ENCODED_SEPARATOR_RE, s as classifyMetadataRoute, t as computeSegmentTreePaths, u as isDynamicMetadataExtension } from "./segment-keys-BawYuNFO.js";
 import { i as DEFAULT_PAGE_EXTENSIONS, n as classifyUrlSegment, r as effectiveUrlSegment, t as classifySegment } from "./segment-classify-C539Pa2O.js";
-import { h as swallow } from "./logger-N7e5auP0.js";
-import { a as resolveAppDir } from "./plugin-context-DEGLSJs3.js";
+import { h as swallow } from "./logger-D8xJZXIN.js";
 import { basename, extname, join } from "node:path";
-import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { readdirSync, statSync } from "node:fs";
 //#region src/server/tree-match.ts
 /**
 * Match URL path parts against a segment tree.
@@ -1200,8 +1198,7 @@ var PAGE_EXT_CONVENTIONS = /* @__PURE__ */ new Set([
 var FIXED_CONVENTIONS = /* @__PURE__ */ new Set([
 	"middleware",
 	"access",
-	"route",
-	"params"
+	"route"
 ]);
 /**
 * Status-code file patterns:
@@ -1562,296 +1559,6 @@ function findPageExtFile(dirPath, name, extSet) {
 	}
 }
 //#endregion
-//#region src/cli-schema-sync.ts
-/**
-* `timber schema sync` — scan filesystem for dynamic segments, append
-* missing entries with `codec.string` defaults, and remove stale entries
-* whose segments no longer exist in the filesystem.
-*
-* Design doc: design/41-global-params.md §Auto-Scaffolding
-*/
-var cli_schema_sync_exports = /* @__PURE__ */ __exportAll({
-	collectDynamicSegments: () => collectDynamicSegments,
-	defaultCodecForSegment: () => defaultCodecForSegment,
-	findSchemaFile: () => findSchemaFile,
-	findSegmentParamsBlock: () => findSegmentParamsBlock,
-	parseExistingSchemaKeys: () => parseExistingSchemaKeys,
-	runSchemaSync: () => runSchemaSync
-});
-function toBracketKey(node) {
-	if (node.paramPrefix || node.paramSuffix) return `[${node.paramName}]`;
-	switch (node.segmentType) {
-		case "catch-all": return `[...${node.paramName}]`;
-		case "optional-catch-all": return `[[...${node.paramName}]]`;
-		default: return `[${node.paramName}]`;
-	}
-}
-/**
-* Collect all unique bracket-keyed dynamic segment names from the route tree.
-* Returns entries like '[artistSlug]', '[...slug]', '[[...topic]]'.
-*/
-function collectDynamicSegments(appDir) {
-	const tree = scanRoutes(appDir);
-	const segments = /* @__PURE__ */ new Set();
-	walkSegments(tree.root, segments);
-	return [...segments].sort();
-}
-function walkSegments(node, segments) {
-	if (node.paramName) segments.add(toBracketKey(node));
-	for (const child of node.children) walkSegments(child, segments);
-	for (const slot of Object.values(node.slots)) walkSegments(slot, segments);
-}
-/**
-* Replace comment bodies (and optionally string contents) with spaces,
-* preserving length and newlines so every index maps 1:1 to the original.
-* Lets the structural scanning below ignore `segmentParams` mentions and
-* braces inside comments/strings without a TS parser (fine pre-alpha,
-* see TIM-1066).
-*
-* With `maskStrings`, string contents are blanked too — except literal
-* 'segmentParams' strings, kept so a quoted property key stays findable.
-*/
-function maskSource(content, maskStrings) {
-	const out = content.split("");
-	const n = content.length;
-	let i = 0;
-	const blank = (from, to) => {
-		for (let j = from; j < to; j++) if (content[j] !== "\n") out[j] = " ";
-	};
-	while (i < n) {
-		const ch = content[i];
-		const next = content[i + 1];
-		if (ch === "/" && next === "/") {
-			const start = i;
-			while (i < n && content[i] !== "\n") i++;
-			blank(start, i);
-		} else if (ch === "/" && next === "*") {
-			const start = i;
-			i += 2;
-			while (i < n && !(content[i] === "*" && content[i + 1] === "/")) i++;
-			i = Math.min(i + 2, n);
-			blank(start, i);
-		} else if (ch === "\"" || ch === "'" || ch === "`") {
-			const start = i;
-			i++;
-			while (i < n && content[i] !== ch) {
-				if (content[i] === "\\") i++;
-				i++;
-			}
-			const end = i;
-			if (maskStrings && content.slice(start + 1, end) !== "segmentParams") blank(start + 1, end);
-			i++;
-		} else i++;
-	}
-	return out.join("");
-}
-/**
-* Locate the `segmentParams: { ... }` block in a schema file.
-* Returns the indices of the opening and matching closing brace, or null
-* if no segmentParams property is found. Comments and strings are masked
-* first, so a JSDoc example mentioning `segmentParams: { ... }` above the
-* real defineSchema call is not mistaken for the block, and braces inside
-* comments/strings don't skew the depth count. The search is anchored to
-* the `defineSchema(` call when present, so helper objects with their own
-* segmentParams property earlier in the file are skipped.
-*/
-function findSegmentParamsBlock(content) {
-	const masked = maskSource(content, true);
-	const defineCall = /\bdefineSchema\s*\(/.exec(masked);
-	const keyRe = /(['"]?)segmentParams\1\s*:\s*\{/g;
-	keyRe.lastIndex = defineCall ? defineCall.index + defineCall[0].length : 0;
-	const keyMatch = keyRe.exec(masked);
-	if (!keyMatch) return null;
-	const openBrace = keyMatch.index + keyMatch[0].length - 1;
-	let depth = 1;
-	let i = openBrace + 1;
-	while (i < masked.length && depth > 0) {
-		if (masked[i] === "{") depth++;
-		else if (masked[i] === "}") depth--;
-		i++;
-	}
-	if (depth > 0) return null;
-	return {
-		openBrace,
-		closeBrace: i - 1
-	};
-}
-/**
-* Parse existing bracket keys from an app/schema.ts file.
-* Scoped to the segmentParams: { ... } block — bracket keys elsewhere in
-* the file (unrelated objects, comments above defineSchema) are ignored.
-* Comments inside the block are masked, so a commented-out entry does not
-* count as registered.
-*
-* The key charset matches the route classifier (segment-classify.ts):
-* any character except `]`, so hyphenated params like '[my-param]' parse.
-*/
-function parseExistingSchemaKeys(content) {
-	const block = findSegmentParamsBlock(content);
-	if (!block) return [];
-	const blockContent = maskSource(content, false).slice(block.openBrace, block.closeBrace);
-	const keys = [];
-	const re = /['"](\[{1,2}(?:\.{3})?[^\]]+\]{1,2})['"]\s*:/g;
-	let m;
-	while ((m = re.exec(blockContent)) !== null) keys.push(m[1]);
-	return keys;
-}
-/** Schema file extensions to check. */
-var SCHEMA_EXTENSIONS = [
-	".ts",
-	".tsx",
-	".js",
-	".jsx"
-];
-/**
-* Find the schema file path if it exists.
-*/
-function findSchemaFile(appDir) {
-	for (const ext of SCHEMA_EXTENSIONS) {
-		const p = join(appDir, `schema${ext}`);
-		if (existsSync(p)) return p;
-	}
-}
-function defaultCodecForSegment(seg) {
-	if (seg.startsWith("[[...")) return "codec.optionalCatchAll(codec.string)";
-	if (seg.startsWith("[...")) return "codec.stringArray";
-	return "codec.string";
-}
-/**
-* Generate the content for a new app/schema.ts with the given segment keys.
-*/
-function generateNewSchema(segments) {
-	const lines = [];
-	lines.push("import { defineSchema } from '@timber-js/app/params';");
-	lines.push("import { codec } from '@timber-js/app/codec';");
-	lines.push("");
-	lines.push("export default defineSchema({");
-	lines.push("  segmentParams: {");
-	for (const seg of segments) lines.push(`    '${seg}': ${defaultCodecForSegment(seg)},`);
-	lines.push("  },");
-	lines.push("});");
-	lines.push("");
-	return lines.join("\n");
-}
-/**
-* Append missing segment entries to an existing schema file.
-* Inserts new entries before the closing `}` of segmentParams.
-*/
-var CODEC_IMPORT = "import { codec } from '@timber-js/app/codec';";
-function hasCodecImport(content) {
-	return /import\s+\{[^}]*\bcodec\b[^}]*\}\s+from\s+['"]@timber-js\/app\/codec['"]/.test(content);
-}
-function ensureCodecImport(content) {
-	if (hasCodecImport(content)) return content;
-	const lines = content.split("\n");
-	let lastImportIndex = -1;
-	for (let i = 0; i < lines.length; i++) if (/^\s*import\s/.test(lines[i])) lastImportIndex = i;
-	if (lastImportIndex === -1) return "import { codec } from '@timber-js/app/codec';\n" + content;
-	lines.splice(lastImportIndex + 1, 0, CODEC_IMPORT);
-	return lines.join("\n");
-}
-function appendToSchema(content, newSegments) {
-	content = ensureCodecImport(content);
-	const block = findSegmentParamsBlock(content);
-	if (!block) throw new Error("[timber] Could not find segmentParams in schema file. Expected a defineSchema({ segmentParams: { ... } }) call.");
-	const { openBrace, closeBrace } = block;
-	const existingLine = content.slice(openBrace, closeBrace).match(/^(\s+)['"]\[/m);
-	const indent = existingLine ? existingLine[1] : "    ";
-	const insertion = newSegments.map((seg) => `${indent}'${seg}': ${defaultCodecForSegment(seg)},`).join("\n");
-	const before = content.slice(0, closeBrace);
-	const after = content.slice(closeBrace);
-	return before + (before.trimEnd().endsWith(",") ? "\n" : "\n") + insertion + "\n" + after;
-}
-/**
-* Remove entries from the segmentParams block whose keys match `staleSegments`.
-* Removes the entire entry including trailing comma/whitespace. Scoped to
-* the segmentParams block — identical keys in unrelated objects elsewhere
-* in the file are left untouched.
-*/
-function removeFromSchema(content, staleSegments) {
-	const block = findSegmentParamsBlock(content);
-	if (!block) return content;
-	let blockContent = content.slice(block.openBrace, block.closeBrace);
-	let blockMasked = maskSource(blockContent, false);
-	for (const seg of staleSegments) {
-		const escaped = seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-		const keyRe = new RegExp(`^[ \t]*['"]${escaped}['"][ \t]*:`, "gm");
-		let m;
-		while ((m = keyRe.exec(blockMasked)) !== null) {
-			const start = m.index;
-			let i = m.index + m[0].length;
-			let depth = 0;
-			let inString = null;
-			while (i < blockMasked.length) {
-				const ch = blockMasked[i];
-				if (inString) {
-					if (ch === "\\") i++;
-					else if (ch === inString) inString = null;
-				} else if (ch === "\"" || ch === "'" || ch === "`") inString = ch;
-				else if (ch === "(" || ch === "{" || ch === "[") depth++;
-				else if (ch === ")" || ch === "}" || ch === "]") depth--;
-				else if (depth === 0 && ch === ",") {
-					i++;
-					break;
-				} else if (depth === 0 && (ch === "\n" || ch === "}")) break;
-				i++;
-			}
-			if (i < blockMasked.length && blockMasked[i] === "\n") i++;
-			blockContent = blockContent.slice(0, start) + blockContent.slice(i);
-			blockMasked = blockMasked.slice(0, start) + blockMasked.slice(i);
-			keyRe.lastIndex = start;
-		}
-	}
-	return content.slice(0, block.openBrace) + blockContent + content.slice(block.closeBrace);
-}
-/**
-* Run the schema sync: scan filesystem, diff against schema, append missing.
-*/
-function runSchemaSync(projectRoot) {
-	const appDir = resolveAppDir(projectRoot);
-	const filesystemSegments = collectDynamicSegments(appDir);
-	const schemaPath = findSchemaFile(appDir);
-	if (filesystemSegments.length === 0 && !schemaPath) return {
-		filesystemSegments: [],
-		existingSegments: [],
-		addedSegments: [],
-		removedSegments: [],
-		created: false
-	};
-	if (!schemaPath) {
-		writeFileSync(join(appDir, "schema.ts"), generateNewSchema(filesystemSegments), "utf-8");
-		return {
-			filesystemSegments,
-			existingSegments: [],
-			addedSegments: filesystemSegments,
-			removedSegments: [],
-			created: true
-		};
-	}
-	const content = readFileSync(schemaPath, "utf-8");
-	const existingSegments = parseExistingSchemaKeys(content);
-	const missing = filesystemSegments.filter((seg) => !existingSegments.includes(seg));
-	const stale = existingSegments.filter((seg) => !filesystemSegments.includes(seg));
-	if (missing.length === 0 && stale.length === 0) return {
-		filesystemSegments,
-		existingSegments,
-		addedSegments: [],
-		removedSegments: [],
-		created: false
-	};
-	let updated = content;
-	if (stale.length > 0) updated = removeFromSchema(updated, stale);
-	if (missing.length > 0) updated = appendToSchema(updated, missing);
-	writeFileSync(schemaPath, updated, "utf-8");
-	return {
-		filesystemSegments,
-		existingSegments,
-		addedSegments: missing,
-		removedSegments: stale,
-		created: false
-	};
-}
-//#endregion
-export { collectInterceptionRewrites as a, scanRoutes as i, findSchemaFile as n, matchUrlParts as o, parseExistingSchemaKeys as r, cli_schema_sync_exports as t };
+export { collectInterceptionRewrites as n, matchUrlParts as r, scanRoutes as t };
 
-//# sourceMappingURL=cli-schema-sync-CKgHC2MB.js.map
+//# sourceMappingURL=scanner-C8b0Gcw3.js.map