vinext 1.3.1 → 1.4.1

package/dist/build/route-classification-injector.js

@@ -1,59 +0,0 @@
-import { buildClassificationReplacement, buildReasonsReplacement } from "./route-classification-manifest.js";
-import { classifyLayoutByModuleGraph, isStaticModuleGraphResult, moduleGraphReason } from "./layout-classification.js";
-//#region src/build/route-classification-injector.ts
-const CLASS_STUB_RE = /function __VINEXT_CLASS\(routeIdx\)\s*\{\s*return null;?\s*\}/;
-const REASONS_STUB_RE = /function __VINEXT_CLASS_REASONS\(routeIdx\)\s*\{\s*return null;?\s*\}/;
-function identityPath(path) {
-	return path;
-}
-function findClassificationChunk(chunks) {
-	const chunksMentioningStub = chunks.filter((chunk) => chunk.code.includes("__VINEXT_CLASS"));
-	const chunksWithStubBody = chunksMentioningStub.filter((chunk) => CLASS_STUB_RE.test(chunk.code));
-	const chunkWithStubBody = chunksWithStubBody[0];
-	if (chunksMentioningStub.length === 0) return null;
-	if (chunkWithStubBody === void 0) throw new Error(`vinext: build-time classification — __VINEXT_CLASS is referenced in ${chunksMentioningStub.map((chunk) => chunk.fileName).join(", ")} but no chunk contains the stub body. The generator and the classification injector have drifted.`);
-	if (chunksWithStubBody.length > 1) throw new Error(`vinext: build-time classification — expected __VINEXT_CLASS stub in exactly one RSC chunk, found ${chunksWithStubBody.length}`);
-	return chunkWithStubBody;
-}
-function buildLayer2Classifications(options) {
-	const canonicalizeLayoutPath = options.canonicalizeLayoutPath ?? identityPath;
-	const layer2PerRoute = /* @__PURE__ */ new Map();
-	const graphCache = /* @__PURE__ */ new Map();
-	for (let routeIdx = 0; routeIdx < options.manifest.routes.length; routeIdx++) {
-		const route = options.manifest.routes[routeIdx];
-		const perRoute = /* @__PURE__ */ new Map();
-		for (let layoutIdx = 0; layoutIdx < route.layoutPaths.length; layoutIdx++) {
-			if (route.layer1.has(layoutIdx)) continue;
-			const layoutModuleId = canonicalizeLayoutPath(route.layoutPaths[layoutIdx]);
-			if (!options.moduleInfo.getModuleInfo(layoutModuleId)) continue;
-			let graphResult = graphCache.get(layoutModuleId);
-			if (graphResult === void 0) {
-				graphResult = classifyLayoutByModuleGraph(layoutModuleId, options.dynamicShimPaths, options.moduleInfo);
-				graphCache.set(layoutModuleId, graphResult);
-			}
-			if (isStaticModuleGraphResult(graphResult)) perRoute.set(layoutIdx, moduleGraphReason(graphResult));
-		}
-		if (perRoute.size > 0) layer2PerRoute.set(routeIdx, perRoute);
-	}
-	return layer2PerRoute;
-}
-function planRouteClassificationInjection(options) {
-	const target = findClassificationChunk(options.chunks);
-	if (!target) return { kind: "skip" };
-	if (options.enableDebugReasons && !REASONS_STUB_RE.test(target.code)) throw new Error("vinext: build-time classification — __VINEXT_CLASS_REASONS stub is missing alongside __VINEXT_CLASS. The generator and the classification injector have drifted.");
-	const layer2PerRoute = buildLayer2Classifications(options);
-	const patchedBody = `function __VINEXT_CLASS(routeIdx) { return (${buildClassificationReplacement(options.manifest, layer2PerRoute)})(routeIdx); }`;
-	let code = target.code.replace(CLASS_STUB_RE, patchedBody);
-	if (options.enableDebugReasons) {
-		const patchedReasonsBody = `function __VINEXT_CLASS_REASONS(routeIdx) { return (${buildReasonsReplacement(options.manifest, layer2PerRoute)})(routeIdx); }`;
-		code = code.replace(REASONS_STUB_RE, patchedReasonsBody);
-	}
-	return {
-		code,
-		fileName: target.fileName,
-		kind: "patch",
-		map: null
-	};
-}
-//#endregion
-export { planRouteClassificationInjection };

package/dist/build/route-classification-manifest.d.ts

@@ -1,54 +0,0 @@
-import { AppRoute } from "../routing/app-route-graph.js";
-import { ClassificationReason, ModuleGraphStaticReason } from "./layout-classification-types.js";
-//#region src/build/route-classification-manifest.d.ts
-type Layer1Class = "static" | "dynamic";
-type RouteManifestEntry = {
-  /** Route pattern for diagnostics (e.g. "/blog/:slug"). */
-  pattern: string;
-  /** Absolute file paths for each layout, ordered root → leaf. */
-  layoutPaths: string[];
-  /** Layer 1 (segment config) results keyed by numeric layout index. */
-  layer1: Map<number, Layer1Class>;
-  /**
-   * Structured reasons for every Layer 1 decision, keyed by the same layout
-   * index. Always populated in lockstep with `layer1` so the debug channel
-   * can surface which segment-config field produced the decision.
-   */
-  layer1Reasons: Map<number, ClassificationReason>;
-};
-export type RouteClassificationManifest = {
-  routes: RouteManifestEntry[];
-};
-/**
- * Reads each layout's source at build time and runs Layer 1 segment-config
- * classification. Fails loudly if any layout file is missing — a missing
- * layout means the routing scan and the filesystem have drifted, and shipping
- * a build in that state would silently break layout rendering.
- */
-export declare function collectRouteClassificationManifest(routes: readonly AppRoute[]): RouteClassificationManifest;
-/**
- * Builds a JavaScript arrow-function expression that dispatches route index
- * to a pre-computed `Map<layoutIndex, "static" | "dynamic">` of build-time
- * classifications. The returned string is suitable for embedding into the
- * generated RSC entry via the `renderChunk` hook.
- *
- * `layer2PerRoute` is typed to only carry `"static"` entries — the
- * module-graph classifier can only prove static, so "needs-probe" results
- * are omitted by the caller before this map is constructed.
- */
-export declare function buildClassificationReplacement(manifest: RouteClassificationManifest, layer2PerRoute: ReadonlyMap<number, ReadonlyMap<number, ModuleGraphStaticReason>>): string;
-/**
- * Sibling of `buildClassificationReplacement`: emits a dispatch function
- * that returns `Map<layoutIndex, ClassificationReason>` per route.
- *
- * The runtime consults this map only when `VINEXT_DEBUG_CLASSIFICATION` is
- * set, and the plugin only patches this dispatcher into the built bundle when
- * that env var is present at build time.
- *
- * Layer 1 priority applies the same way as in `buildClassificationReplacement`:
- * a segment-config reason must override a module-graph reason for the same
- * layout index.
- */
-export declare function buildReasonsReplacement(manifest: RouteClassificationManifest, layer2PerRoute: ReadonlyMap<number, ReadonlyMap<number, ModuleGraphStaticReason>>): string;
-//#endregion
-export {};

package/dist/build/route-classification-manifest.js

@@ -1,143 +0,0 @@
-import { classifyLayoutSegmentConfig } from "./report.js";
-import fs from "node:fs";
-//#region src/build/route-classification-manifest.ts
-/**
-* Build-time layout classification manifest.
-*
-* Bridges the classifier in `./layout-classification.ts` with the RSC entry
-* codegen so that the per-layout static/dynamic classifications produced at
-* build time are visible to the runtime probe loop in
-* `server/app-page-execution.ts`.
-*
-* The runtime probe looks up entries by numeric `layoutIndex`, so this module
-* is responsible for flattening the classifier's string-keyed layout IDs into
-* a per-route, index-keyed structure that can be emitted from codegen.
-*/
-/**
-* Reads each layout's source at build time and runs Layer 1 segment-config
-* classification. Fails loudly if any layout file is missing — a missing
-* layout means the routing scan and the filesystem have drifted, and shipping
-* a build in that state would silently break layout rendering.
-*/
-function collectRouteClassificationManifest(routes) {
-	const manifestRoutes = [];
-	const sourceCache = /* @__PURE__ */ new Map();
-	for (const route of routes) {
-		const layer1 = /* @__PURE__ */ new Map();
-		const layer1Reasons = /* @__PURE__ */ new Map();
-		for (let layoutIndex = 0; layoutIndex < route.layouts.length; layoutIndex++) {
-			const layoutPath = route.layouts[layoutIndex];
-			let source = sourceCache.get(layoutPath);
-			if (source === void 0) try {
-				source = fs.readFileSync(layoutPath, "utf8");
-				sourceCache.set(layoutPath, source);
-			} catch (cause) {
-				throw new Error(`vinext: failed to read layout for route ${route.pattern} at ${layoutPath}`, { cause });
-			}
-			const result = classifyLayoutSegmentConfig(source);
-			if (result.kind === "static" || result.kind === "dynamic") {
-				layer1.set(layoutIndex, result.kind);
-				layer1Reasons.set(layoutIndex, result.reason);
-			}
-		}
-		manifestRoutes.push({
-			pattern: route.pattern,
-			layoutPaths: [...route.layouts],
-			layer1,
-			layer1Reasons
-		});
-	}
-	return { routes: manifestRoutes };
-}
-/**
-* Merges Layer 1 (segment config) and Layer 2 (module graph) into a single
-* per-route map, applying the Layer-1-wins priority rule.
-*
-* Layer 1 always takes priority over Layer 2 for the same layout index:
-* segment config is a user-authored guarantee, so a layout that explicitly
-* says `force-dynamic` must never be demoted to "static" because its module
-* graph happened to be clean.
-*/
-function mergeLayersForRoute(route, layer2) {
-	const merged = /* @__PURE__ */ new Map();
-	if (layer2) for (const [layoutIdx, reason] of layer2) merged.set(layoutIdx, {
-		kind: "static",
-		reason
-	});
-	for (const [layoutIdx, kind] of route.layer1) {
-		const reason = route.layer1Reasons.get(layoutIdx);
-		if (reason === void 0) throw new Error(`vinext: layout ${layoutIdx} in route ${route.pattern} has a Layer 1 decision without a reason`);
-		merged.set(layoutIdx, {
-			kind,
-			reason
-		});
-	}
-	return merged;
-}
-function serializeReasonExpression(reason) {
-	switch (reason.layer) {
-		case "segment-config": {
-			const value = reason.value === Infinity ? "Infinity" : JSON.stringify(reason.value);
-			return `{ layer: "segment-config", key: ${JSON.stringify(reason.key)}, value: ${value} }`;
-		}
-		case "module-graph": {
-			const props = [`layer: "module-graph"`, `result: ${JSON.stringify(reason.result)}`];
-			if (reason.firstShimMatch !== void 0) props.push(`firstShimMatch: ${JSON.stringify(reason.firstShimMatch)}`);
-			return `{ ${props.join(", ")} }`;
-		}
-		case "runtime-probe": {
-			const props = [`layer: "runtime-probe"`, `outcome: ${JSON.stringify(reason.outcome)}`];
-			if (reason.error !== void 0) props.push(`error: ${JSON.stringify(reason.error)}`);
-			return `{ ${props.join(", ")} }`;
-		}
-		case "no-classifier": return `{ layer: "no-classifier" }`;
-	}
-}
-function buildRouteDispatchReplacement(manifest, layer2PerRoute, serializeEntry) {
-	const cases = [];
-	for (let routeIdx = 0; routeIdx < manifest.routes.length; routeIdx++) {
-		const route = manifest.routes[routeIdx];
-		const merged = mergeLayersForRoute(route, layer2PerRoute.get(routeIdx));
-		if (merged.size === 0) continue;
-		const entries = [...merged.entries()].sort((a, b) => a[0] - b[0]).map(([idx, value]) => `[${idx}, ${serializeEntry(value)}]`).join(", ");
-		cases.push(`      case ${routeIdx}: return new Map([${entries}]);`);
-	}
-	return [
-		"(routeIdx) => {",
-		"    switch (routeIdx) {",
-		...cases,
-		"      default: return null;",
-		"    }",
-		"  }"
-	].join("\n");
-}
-/**
-* Builds a JavaScript arrow-function expression that dispatches route index
-* to a pre-computed `Map<layoutIndex, "static" | "dynamic">` of build-time
-* classifications. The returned string is suitable for embedding into the
-* generated RSC entry via the `renderChunk` hook.
-*
-* `layer2PerRoute` is typed to only carry `"static"` entries — the
-* module-graph classifier can only prove static, so "needs-probe" results
-* are omitted by the caller before this map is constructed.
-*/
-function buildClassificationReplacement(manifest, layer2PerRoute) {
-	return buildRouteDispatchReplacement(manifest, layer2PerRoute, (value) => JSON.stringify(value.kind));
-}
-/**
-* Sibling of `buildClassificationReplacement`: emits a dispatch function
-* that returns `Map<layoutIndex, ClassificationReason>` per route.
-*
-* The runtime consults this map only when `VINEXT_DEBUG_CLASSIFICATION` is
-* set, and the plugin only patches this dispatcher into the built bundle when
-* that env var is present at build time.
-*
-* Layer 1 priority applies the same way as in `buildClassificationReplacement`:
-* a segment-config reason must override a module-graph reason for the same
-* layout index.
-*/
-function buildReasonsReplacement(manifest, layer2PerRoute) {
-	return buildRouteDispatchReplacement(manifest, layer2PerRoute, (value) => serializeReasonExpression(value.reason));
-}
-//#endregion
-export { buildClassificationReplacement, buildReasonsReplacement, collectRouteClassificationManifest };

package/dist/server/app-browser-client-reuse-manifest.d.ts

@@ -1,11 +0,0 @@
-import { DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS } from "./client-reuse-manifest.js";
-import { AppRouterState } from "./app-browser-state.js";
-//#region src/server/app-browser-client-reuse-manifest.d.ts
-type ClientReuseManifestLimits = typeof DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS;
-type VisibleAppState = Pick<AppRouterState, "elements" | "visibleCommitVersion">;
-type CreateClientReuseManifestHeaderOptions = Readonly<{
-  limits?: ClientReuseManifestLimits;
-}>;
-export declare function createClientReuseManifestHeaderFromVisibleAppState(state: VisibleAppState, options?: CreateClientReuseManifestHeaderOptions): string | null;
-//#endregion
-export {};

package/dist/server/app-browser-client-reuse-manifest.js

@@ -1,101 +0,0 @@
-import { AppElementsWire } from "./app-elements-wire.js";
-import "./app-elements.js";
-import { DEFAULT_CACHE_VARIANT_BUDGET, buildCacheVariantWithRouteBudget } from "./cache-proof.js";
-import { DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS, countUtf8Bytes, serializeClientReuseManifest } from "./client-reuse-manifest.js";
-import { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId } from "./static-layout-client-reuse-proof.js";
-//#region src/server/app-browser-client-reuse-manifest.ts
-function capClientReuseManifestProducerLimits(limits) {
-	return {
-		...limits,
-		maxEntryCount: Math.min(limits.maxEntryCount, 8)
-	};
-}
-function serializeBoundedClientReuseManifest(input) {
-	const entries = input.entries.slice(0, input.limits.maxEntryCount);
-	let low = 1;
-	let high = entries.length;
-	let best = null;
-	while (low <= high) {
-		const size = Math.floor((low + high) / 2);
-		const serialized = serializeClientReuseManifest({
-			entries: entries.slice(0, size),
-			replayWindow: {
-				validFromVisibleCommitVersion: input.visibleCommitVersion,
-				validUntilVisibleCommitVersion: input.visibleCommitVersion
-			},
-			visibleCommitVersion: input.visibleCommitVersion
-		});
-		if (countUtf8Bytes(serialized) <= input.limits.maxManifestBytes) {
-			best = serialized;
-			low = size + 1;
-		} else high = size - 1;
-	}
-	return best;
-}
-function hasRetainedElement(elements, elementId) {
-	return Object.hasOwn(elements, elementId);
-}
-function createStaticLayoutEntry(input) {
-	const routeId = createStaticLayoutClientReuseRouteId(input.layoutId);
-	const output = {
-		kind: "layout",
-		layoutId: input.layoutId,
-		rootBoundaryId: input.artifactCompatibility.rootBoundaryId,
-		routeId
-	};
-	const candidateVariant = buildCacheVariantWithRouteBudget({
-		budget: DEFAULT_CACHE_VARIANT_BUDGET,
-		dimensions: [],
-		output,
-		routeBudget: {
-			routeId: output.routeId,
-			variantCacheKeys: []
-		}
-	});
-	if (candidateVariant.kind !== "variant") return null;
-	const artifactCompatibility = createStaticLayoutClientReuseArtifactCompatibility({
-		artifactCompatibility: input.artifactCompatibility,
-		layoutId: input.layoutId,
-		rootBoundaryId: output.rootBoundaryId,
-		routeId: output.routeId,
-		variantCacheKey: candidateVariant.variant.cacheKey
-	});
-	return {
-		artifactCompatibility,
-		id: input.layoutId,
-		payloadHash: createStaticLayoutClientReusePayloadHash({
-			artifactCompatibility,
-			layoutId: input.layoutId,
-			rootBoundaryId: output.rootBoundaryId,
-			routeId: output.routeId,
-			variantCacheKey: candidateVariant.variant.cacheKey
-		}),
-		privacy: "public",
-		variantCacheKey: candidateVariant.variant.cacheKey
-	};
-}
-function createClientReuseManifestHeaderFromVisibleAppState(state, options = {}) {
-	const limits = capClientReuseManifestProducerLimits(options.limits ?? DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS);
-	const metadata = AppElementsWire.readMetadata(state.elements);
-	const entries = [];
-	for (const layoutId of metadata.layoutIds) {
-		if (entries.length >= limits.maxEntryCount) break;
-		if (layoutId.length > limits.maxEntryIdLength) continue;
-		if (metadata.layoutFlags[layoutId] !== "s") continue;
-		if (!hasRetainedElement(state.elements, layoutId)) continue;
-		if (AppElementsWire.parseElementKey(layoutId)?.kind !== "layout") continue;
-		const entry = createStaticLayoutEntry({
-			artifactCompatibility: metadata.artifactCompatibility,
-			layoutId
-		});
-		if (entry) entries.push(entry);
-	}
-	if (entries.length === 0) return null;
-	return serializeBoundedClientReuseManifest({
-		entries,
-		limits,
-		visibleCommitVersion: state.visibleCommitVersion
-	});
-}
-//#endregion
-export { createClientReuseManifestHeaderFromVisibleAppState };

package/dist/server/app-layout-param-observation.d.ts

@@ -1,42 +0,0 @@
-import { RenderRequestApiKind } from "./cache-proof.js";
-import { ClientReuseManifestRejectionCode, ClientReuseManifestTraceFields } from "./client-reuse-manifest.js";
-import { ThenableParamsObserver } from "../shims/thenable-params.js";
-import { UnstableCacheObservation } from "../shims/cache-request-state.js";
-//#region src/server/app-layout-param-observation.d.ts
-export type AppLayoutParamAccessObservation = Readonly<{
-  cacheLifeObserved: boolean;
-  cacheTags: readonly string[];
-  cacheableFetchCount: number;
-  completeness: "complete" | "unknown";
-  dynamicFetchCount: number;
-  /**
-   * `markDynamicUsage()` fired during the probe (e.g. `"use cache: private"`,
-   * `connection()`) with no other observable trace. Folded in from the
-   * isolated probe scope so this signal can't diverge from the Layer-3
-   * `dynamicDetected` path it replaced.
-   */
-  dynamicUsageObserved: boolean;
-  finiteRevalidateSeconds: number | null;
-  keys: readonly string[];
-  observed: boolean;
-  paramScopeKeys: readonly string[];
-  requestApis: readonly RenderRequestApiKind[];
-  unstableCaches: readonly UnstableCacheObservation[];
-}>;
-export type AppLayoutParamAccessTracker = Readonly<{
-  createThenableParamsObserver: (layoutId: string) => ThenableParamsObserver;
-  getLayoutObservation: (layoutId: string) => AppLayoutParamAccessObservation;
-  recordLayoutFiniteRevalidate: (layoutId: string, revalidateSeconds: number) => void;
-  recordLayoutParamScope: (layoutId: string, paramScopeKeys: readonly string[]) => void;
-  runLayoutProbe: (layoutId: string, probe: () => unknown) => unknown;
-}>;
-type StaticLayoutObservationSkipCode = Extract<ClientReuseManifestRejectionCode, `SKIP_LAYOUT_${string}`>;
-export type StaticLayoutObservationSkipRejection = Readonly<{
-  code: StaticLayoutObservationSkipCode;
-  fields: ClientReuseManifestTraceFields;
-}>;
-export declare function getStaticLayoutObservationSkipRejection(observation: AppLayoutParamAccessObservation): StaticLayoutObservationSkipRejection | null;
-export declare function isAppLayoutObservationUnsafeForStaticReuse(observation: AppLayoutParamAccessObservation): boolean;
-export declare function createAppLayoutParamAccessTracker(): AppLayoutParamAccessTracker;
-//#endregion
-export {};

package/dist/server/app-layout-param-observation.js

@@ -1,168 +0,0 @@
-import { isInsideUnifiedScope, runWithUnifiedStateMutation } from "../shims/unified-request-context.js";
-import { isPromiseLike } from "../utils/promise.js";
-import { peekDynamicUsage, peekRenderRequestApiUsage } from "../shims/headers.js";
-import { _peekRequestScopedCacheLife, _peekUnstableCacheObservations } from "../shims/cache-request-state.js";
-import { getCollectedFetchTags, peekCacheableFetchObservations, peekDynamicFetchObservations } from "../shims/fetch-cache.js";
-//#region src/server/app-layout-param-observation.ts
-const STATIC_LAYOUT_OBSERVATION_SKIP_RULES = [
-	["SKIP_LAYOUT_PARAMS_OBSERVATION_INCOMPLETE", (observation) => observation.completeness !== "complete"],
-	["SKIP_LAYOUT_PARAMS_PRESENT", (observation) => observation.paramScopeKeys.length > 0],
-	["SKIP_LAYOUT_PARAMS_OBSERVED", (observation) => observation.observed],
-	["SKIP_LAYOUT_DYNAMIC_USAGE_OBSERVED", (observation) => observation.dynamicUsageObserved],
-	["SKIP_LAYOUT_REQUEST_API_OBSERVED", (observation) => observation.requestApis.length > 0],
-	["SKIP_LAYOUT_REVALIDATE_PRESENT", (observation) => observation.finiteRevalidateSeconds !== null],
-	["SKIP_LAYOUT_CACHE_LIFE_OBSERVED", (observation) => observation.cacheLifeObserved],
-	["SKIP_LAYOUT_UNSTABLE_CACHE_OBSERVED", (observation) => observation.unstableCaches.length > 0],
-	["SKIP_LAYOUT_CACHE_TAGS_OBSERVED", (observation) => observation.cacheTags.length > 0],
-	["SKIP_LAYOUT_CACHEABLE_FETCHES_OBSERVED", (observation) => observation.cacheableFetchCount > 0],
-	["SKIP_LAYOUT_DYNAMIC_FETCHES_OBSERVED", (observation) => observation.dynamicFetchCount > 0]
-];
-function createStaticLayoutObservationTraceFields(observation) {
-	return {
-		cacheLifeObserved: observation.cacheLifeObserved,
-		cacheTags: observation.cacheTags,
-		cacheableFetchCount: observation.cacheableFetchCount,
-		dynamicFetchCount: observation.dynamicFetchCount,
-		dynamicUsageObserved: observation.dynamicUsageObserved,
-		finiteRevalidateSeconds: observation.finiteRevalidateSeconds,
-		observedParamKeys: observation.keys,
-		paramScopeKeys: observation.paramScopeKeys,
-		requestApis: observation.requestApis,
-		unstableCacheCount: observation.unstableCaches.length,
-		unstableCacheKeyHashes: observation.unstableCaches.map((cache) => cache.keyHash),
-		unstableCacheRevalidates: observation.unstableCaches.map((cache) => String(cache.revalidate)),
-		unstableCacheTagCounts: observation.unstableCaches.map((cache) => String(cache.tagCount)),
-		unstableCacheTagHashes: observation.unstableCaches.map((cache) => cache.tagHash ?? "none")
-	};
-}
-function getStaticLayoutObservationSkipRejection(observation) {
-	for (const [code, matches] of STATIC_LAYOUT_OBSERVATION_SKIP_RULES) if (matches(observation)) return {
-		code,
-		fields: createStaticLayoutObservationTraceFields(observation)
-	};
-	return null;
-}
-function isAppLayoutObservationUnsafeForStaticReuse(observation) {
-	return getStaticLayoutObservationSkipRejection(observation) !== null;
-}
-function createAppLayoutParamAccessTracker() {
-	const observations = /* @__PURE__ */ new Map();
-	const ensureObservation = (layoutId) => {
-		const existing = observations.get(layoutId);
-		if (existing) return existing;
-		const created = {
-			cacheLifeObserved: false,
-			cacheTags: /* @__PURE__ */ new Set(),
-			cacheableFetches: /* @__PURE__ */ new Set(),
-			dynamicFetches: /* @__PURE__ */ new Set(),
-			dynamicUsageObserved: false,
-			finiteRevalidateSeconds: null,
-			keys: /* @__PURE__ */ new Set(),
-			observed: false,
-			paramScopeKeys: /* @__PURE__ */ new Set(),
-			probeComplete: false,
-			requestApis: /* @__PURE__ */ new Set(),
-			unstableCaches: /* @__PURE__ */ new Map()
-		};
-		observations.set(layoutId, created);
-		return created;
-	};
-	const markObserved = (layoutId, keys) => {
-		const observation = ensureObservation(layoutId);
-		observation.observed = true;
-		for (const key of keys) observation.keys.add(key);
-	};
-	const markProbeComplete = (layoutId) => {
-		ensureObservation(layoutId).probeComplete = true;
-	};
-	const runWithIsolatedProbeDependencies = (probe) => {
-		if (!isInsideUnifiedScope()) return probe();
-		return runWithUnifiedStateMutation((ctx) => {
-			ctx.cacheableFetchUrls = /* @__PURE__ */ new Set();
-			ctx.currentRequestTags = [];
-			ctx.currentFetchSoftTags = [];
-			ctx.dynamicFetchUrls = /* @__PURE__ */ new Set();
-			ctx.dynamicUsageDetected = false;
-			ctx.renderRequestApiUsage = /* @__PURE__ */ new Set();
-			ctx.requestScopedCacheLife = null;
-			ctx.unstableCacheObservations = /* @__PURE__ */ new Map();
-		}, probe);
-	};
-	const recordProbeDependencies = (layoutId) => {
-		const observation = ensureObservation(layoutId);
-		if (peekDynamicUsage()) observation.dynamicUsageObserved = true;
-		if (_peekRequestScopedCacheLife() !== null) observation.cacheLifeObserved = true;
-		for (const tag of getCollectedFetchTags()) observation.cacheTags.add(tag);
-		for (const url of peekCacheableFetchObservations()) observation.cacheableFetches.add(url);
-		for (const url of peekDynamicFetchObservations()) observation.dynamicFetches.add(url);
-		for (const requestApi of peekRenderRequestApiUsage()) observation.requestApis.add(requestApi);
-		for (const unstableCache of _peekUnstableCacheObservations()) observation.unstableCaches.set(unstableCache.keyHash, unstableCache);
-	};
-	return {
-		createThenableParamsObserver(layoutId) {
-			return { observeParamAccess(keys) {
-				markObserved(layoutId, keys);
-			} };
-		},
-		getLayoutObservation(layoutId) {
-			const observation = observations.get(layoutId);
-			if (!observation) return {
-				cacheLifeObserved: false,
-				cacheTags: [],
-				cacheableFetchCount: 0,
-				completeness: "unknown",
-				dynamicFetchCount: 0,
-				dynamicUsageObserved: false,
-				finiteRevalidateSeconds: null,
-				keys: [],
-				observed: false,
-				paramScopeKeys: [],
-				requestApis: [],
-				unstableCaches: []
-			};
-			return {
-				cacheLifeObserved: observation.cacheLifeObserved,
-				cacheTags: [...observation.cacheTags].sort(),
-				cacheableFetchCount: observation.cacheableFetches.size,
-				completeness: observation.probeComplete ? "complete" : "unknown",
-				dynamicFetchCount: observation.dynamicFetches.size,
-				dynamicUsageObserved: observation.dynamicUsageObserved,
-				finiteRevalidateSeconds: observation.finiteRevalidateSeconds,
-				keys: [...observation.keys].sort(),
-				observed: observation.observed,
-				paramScopeKeys: [...observation.paramScopeKeys].sort(),
-				requestApis: [...observation.requestApis].sort(),
-				unstableCaches: [...observation.unstableCaches.values()].sort((a, b) => a.keyHash.localeCompare(b.keyHash))
-			};
-		},
-		recordLayoutFiniteRevalidate(layoutId, revalidateSeconds) {
-			if (!Number.isFinite(revalidateSeconds) || revalidateSeconds <= 0) return;
-			const observation = ensureObservation(layoutId);
-			observation.finiteRevalidateSeconds = observation.finiteRevalidateSeconds === null ? revalidateSeconds : Math.min(observation.finiteRevalidateSeconds, revalidateSeconds);
-		},
-		recordLayoutParamScope(layoutId, paramScopeKeys) {
-			const observation = ensureObservation(layoutId);
-			for (const key of paramScopeKeys) observation.paramScopeKeys.add(key);
-		},
-		runLayoutProbe(layoutId, probe) {
-			return runWithIsolatedProbeDependencies(() => {
-				const result = probe();
-				if (!isPromiseLike(result)) {
-					recordProbeDependencies(layoutId);
-					markProbeComplete(layoutId);
-					return result;
-				}
-				return Promise.resolve(result).then((resolved) => {
-					recordProbeDependencies(layoutId);
-					markProbeComplete(layoutId);
-					return resolved;
-				}, (error) => {
-					recordProbeDependencies(layoutId);
-					throw error;
-				});
-			});
-		}
-	};
-}
-//#endregion
-export { createAppLayoutParamAccessTracker, getStaticLayoutObservationSkipRejection, isAppLayoutObservationUnsafeForStaticReuse };