vinext 1.3.1 → 1.4.0

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 };

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

@@ -1,103 +0,0 @@
-import { ArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
-//#region src/server/client-reuse-manifest.d.ts
-export declare const CLIENT_REUSE_MANIFEST_SCHEMA_VERSION = 1;
-type ClientReuseManifestSchemaVersion = 1;
-export declare const CLIENT_REUSE_MANIFEST_HASH_ALGORITHM = "fnv1a64";
-type ClientReuseManifestHashAlgorithm = typeof CLIENT_REUSE_MANIFEST_HASH_ALGORITHM;
-type ClientReuseManifestLimits = Readonly<{
-  maxEntryCount: number;
-  maxEntryIdLength: number;
-  maxManifestBytes: number;
-  maxPayloadHashLength: number;
-  maxVariantCacheKeyLength: number;
-}>;
-export declare const DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS: {
-  maxEntryCount: number;
-  maxEntryIdLength: number;
-  maxManifestBytes: number;
-  maxPayloadHashLength: number;
-  maxVariantCacheKeyLength: number;
-};
-export declare const CLIENT_REUSE_MANIFEST_SKIP_VERIFICATION_ENTRY_BUDGET = 8;
-type ClientReuseManifestEntryKind = "layout" | "page" | "route" | "slot" | "template";
-type ClientReuseManifestEntryPrivacy = "private" | "public";
-type ClientReuseManifestReplayWindow = Readonly<{
-  validFromVisibleCommitVersion: number;
-  validUntilVisibleCommitVersion: number;
-}>;
-export type ClientReuseManifestEntry = Readonly<{
-  artifactCompatibility: ArtifactCompatibilityEnvelope;
-  id: string;
-  kind: ClientReuseManifestEntryKind;
-  payloadHash: string;
-  privacy: "public";
-  variantCacheKey: string;
-}>;
-type ClientReuseManifestWireEntry = Readonly<{
-  artifactCompatibility: ArtifactCompatibilityEnvelope;
-  id: string;
-  payloadHash: string;
-  privacy: ClientReuseManifestEntryPrivacy;
-  variantCacheKey: string;
-}>;
-type ClientReuseManifest = Readonly<{
-  entries: readonly ClientReuseManifestEntry[];
-  hashAlgorithm: ClientReuseManifestHashAlgorithm;
-  replayWindow: ClientReuseManifestReplayWindow;
-  schemaVersion: ClientReuseManifestSchemaVersion;
-  visibleCommitVersion: number;
-}>;
-type ClientReuseManifestWire = Readonly<{
-  entries: readonly ClientReuseManifestWireEntry[];
-  hashAlgorithm: ClientReuseManifestHashAlgorithm;
-  replayWindow: ClientReuseManifestReplayWindow;
-  schemaVersion: ClientReuseManifestSchemaVersion;
-  visibleCommitVersion: number;
-}>;
-type CreateClientReuseManifestInput = Readonly<{
-  entries: readonly ClientReuseManifestWireEntry[];
-  replayWindow?: ClientReuseManifestReplayWindow;
-  visibleCommitVersion: number;
-}>;
-export type ClientReuseManifestRejectionCode = "SKIP_CACHE_ARTIFACT_COMPATIBILITY_INCOMPATIBLE" | "SKIP_CACHE_ARTIFACT_COMPATIBILITY_UNKNOWN" | "SKIP_CACHE_ARTIFACT_PROOF_MISMATCH" | "SKIP_CACHE_ENTRY_ID_MISMATCH" | "SKIP_CACHE_INVALIDATED" | "SKIP_CACHE_INVALIDATION_UNKNOWN" | "SKIP_CACHE_PAYLOAD_HASH_MISMATCH" | "SKIP_CACHE_PAYLOAD_HASH_MISSING" | "SKIP_CACHE_PROOF_MISSING" | "SKIP_CACHE_PROOF_REJECTED" | "SKIP_CACHE_REUSE_CLASS_UNSUPPORTED" | "SKIP_CACHE_VARIANT_MISMATCH" | "SKIP_LAYOUT_CACHE_LIFE_OBSERVED" | "SKIP_LAYOUT_CACHE_TAGS_OBSERVED" | "SKIP_LAYOUT_CACHEABLE_FETCHES_OBSERVED" | "SKIP_LAYOUT_DYNAMIC_FETCHES_OBSERVED" | "SKIP_LAYOUT_DYNAMIC_USAGE_OBSERVED" | "SKIP_LAYOUT_PARAMS_OBSERVED" | "SKIP_LAYOUT_PARAMS_OBSERVATION_INCOMPLETE" | "SKIP_LAYOUT_PARAMS_PRESENT" | "SKIP_LAYOUT_REVALIDATE_PRESENT" | "SKIP_LAYOUT_REQUEST_API_OBSERVED" | "SKIP_LAYOUT_UNSTABLE_CACHE_OBSERVED" | "SKIP_ARTIFACT_COMPATIBILITY_INVALID" | "SKIP_ENTRY_COUNT_EXCEEDED" | "SKIP_VERIFICATION_BUDGET_EXCEEDED" | "SKIP_ENTRY_HASH_INVALID" | "SKIP_ENTRY_ID_INVALID" | "SKIP_ENTRY_ID_TOO_LONG" | "SKIP_ENTRY_MALFORMED" | "SKIP_ENTRY_ORDER_NON_CANONICAL" | "SKIP_HASH_ALGORITHM_UNSUPPORTED" | "SKIP_MANIFEST_MALFORMED" | "SKIP_MANIFEST_SCHEMA_UNSUPPORTED" | "SKIP_MANIFEST_TOO_LARGE" | "SKIP_PRIVATE_ENTRY" | "SKIP_REPLAY_WINDOW_INVALID" | "SKIP_UNKNOWN_ENTRY" | "SKIP_VARIANT_CACHE_KEY_INVALID" | "SKIP_VARIANT_CACHE_KEY_TOO_LONG" | "SKIP_VISIBLE_COMMIT_VERSION_INVALID" | "SKIP_VISIBLE_COMMIT_VERSION_MISMATCH";
-type ClientReuseManifestTraceFieldValue = string | number | boolean | null | readonly string[];
-export type ClientReuseManifestTraceFields = Readonly<Record<string, ClientReuseManifestTraceFieldValue>>;
-export type ClientReuseManifestRejection = Readonly<{
-  code: ClientReuseManifestRejectionCode;
-  fields: ClientReuseManifestTraceFields;
-}>;
-export type ClientReuseManifestEntryRejection = ClientReuseManifestRejection & Readonly<{
-  entryId: string | null;
-}>;
-export type ClientReuseManifestSkipDisposition = Readonly<{
-  code: "SKIP_MODEL_DISABLED";
-  enabled: false;
-  mode: "renderAndSend";
-}> | Readonly<{
-  code: "SKIP_STATIC_LAYOUT_VERIFIED";
-  enabled: true;
-  mode: "skipStaticLayout";
-  skippedEntryIds: readonly string[];
-}>;
-export type ClientReuseManifestParseResult = Readonly<{
-  kind: "absent";
-}> | Readonly<{
-  kind: "rejected";
-  rejection: ClientReuseManifestRejection;
-}> | Readonly<{
-  entryRejections: readonly ClientReuseManifestEntryRejection[];
-  kind: "parsed";
-  manifest: ClientReuseManifest;
-  skipDisposition: ClientReuseManifestSkipDisposition;
-}>;
-type ParseClientReuseManifestOptions = Readonly<{
-  currentVisibleCommitVersion?: number;
-  limits?: ClientReuseManifestLimits;
-}>;
-export declare function countUtf8Bytes(input: string): number;
-export declare function createClientReusePayloadHash(input: string): string;
-export declare function createClientReuseManifest(input: CreateClientReuseManifestInput): ClientReuseManifestWire;
-export declare function serializeClientReuseManifest(input: CreateClientReuseManifestInput): string;
-export declare function parseClientReuseManifestHeader(rawHeader: string | null | undefined, options?: ParseClientReuseManifestOptions): ClientReuseManifestParseResult;
-//#endregion
-export {};

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

@@ -1,209 +0,0 @@
-import { isUnknownRecord } from "../utils/record.js";
-import { parseAppElementsWireElementKey } from "./app-elements-wire-key.js";
-import { fnv1a64 } from "../utils/hash.js";
-import { parseArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
-import { isNonNegativeSafeInteger } from "../utils/number.js";
-//#region src/server/client-reuse-manifest.ts
-const CLIENT_REUSE_MANIFEST_SCHEMA_VERSION = 1;
-const CLIENT_REUSE_MANIFEST_HASH_ALGORITHM = "fnv1a64";
-const DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS = {
-	maxEntryCount: 64,
-	maxEntryIdLength: 512,
-	maxManifestBytes: 4096,
-	maxPayloadHashLength: 16,
-	maxVariantCacheKeyLength: 256
-};
-const CLIENT_REUSE_MANIFEST_SKIP_VERIFICATION_ENTRY_BUDGET = 8;
-const HASH_DIGEST_PATTERN = /^[0-9a-z]+$/;
-const textEncoder = new TextEncoder();
-function createRejection(code, fields = {}) {
-	return {
-		code,
-		fields
-	};
-}
-function rejectManifest(code, fields = {}) {
-	return {
-		kind: "rejected",
-		rejection: createRejection(code, fields)
-	};
-}
-function rejectEntry(code, entryId, fields = {}) {
-	return {
-		code,
-		entryId,
-		fields
-	};
-}
-function compareManifestEntries(left, right) {
-	if (left.id < right.id) return -1;
-	if (left.id > right.id) return 1;
-	return 0;
-}
-function createCanonicalWireEntries(entries) {
-	const entriesById = /* @__PURE__ */ new Map();
-	for (const entry of entries) if (!entriesById.has(entry.id)) entriesById.set(entry.id, entry);
-	return Array.from(entriesById.values()).sort(compareManifestEntries);
-}
-function countUtf8Bytes(input) {
-	return textEncoder.encode(input).length;
-}
-function parseReplayWindow(value, visibleCommitVersion) {
-	if (!isUnknownRecord(value)) return {
-		kind: "rejected",
-		rejection: createRejection("SKIP_REPLAY_WINDOW_INVALID", { field: "replayWindow" })
-	};
-	const validFromVisibleCommitVersion = value.validFromVisibleCommitVersion;
-	const validUntilVisibleCommitVersion = value.validUntilVisibleCommitVersion;
-	if (!isNonNegativeSafeInteger(validFromVisibleCommitVersion) || !isNonNegativeSafeInteger(validUntilVisibleCommitVersion) || validFromVisibleCommitVersion > validUntilVisibleCommitVersion || visibleCommitVersion < validFromVisibleCommitVersion || visibleCommitVersion > validUntilVisibleCommitVersion) return {
-		kind: "rejected",
-		rejection: createRejection("SKIP_REPLAY_WINDOW_INVALID", {
-			validFromVisibleCommitVersion: isNonNegativeSafeInteger(validFromVisibleCommitVersion) ? validFromVisibleCommitVersion : null,
-			validUntilVisibleCommitVersion: isNonNegativeSafeInteger(validUntilVisibleCommitVersion) ? validUntilVisibleCommitVersion : null,
-			visibleCommitVersion
-		})
-	};
-	return {
-		kind: "parsed",
-		replayWindow: {
-			validFromVisibleCommitVersion,
-			validUntilVisibleCommitVersion
-		}
-	};
-}
-function currentCommitVersionMatchesReplayWindow(currentVisibleCommitVersion, replayWindow) {
-	if (currentVisibleCommitVersion === void 0) return true;
-	return currentVisibleCommitVersion >= replayWindow.validFromVisibleCommitVersion && currentVisibleCommitVersion <= replayWindow.validUntilVisibleCommitVersion;
-}
-function parseEntryKind(id) {
-	const parsed = parseAppElementsWireElementKey(id);
-	if (parsed === null) return null;
-	return parsed.kind;
-}
-function isValidPayloadHash(value, limits) {
-	return typeof value === "string" && value.length > 0 && value.length <= limits.maxPayloadHashLength && HASH_DIGEST_PATTERN.test(value);
-}
-function parseManifestEntry(value, limits, index) {
-	if (!isUnknownRecord(value)) return rejectEntry("SKIP_ENTRY_MALFORMED", null, { index });
-	const id = value.id;
-	if (typeof id !== "string" || id.length === 0) return rejectEntry("SKIP_ENTRY_ID_INVALID", null, { index });
-	if (id.length > limits.maxEntryIdLength) return rejectEntry("SKIP_ENTRY_ID_TOO_LONG", id, {
-		idHash: createClientReusePayloadHash(id),
-		maxEntryIdLength: limits.maxEntryIdLength
-	});
-	const kind = parseEntryKind(id);
-	if (kind === null) return rejectEntry("SKIP_UNKNOWN_ENTRY", id, { idHash: createClientReusePayloadHash(id) });
-	const privacy = value.privacy;
-	if (privacy === "private") return rejectEntry("SKIP_PRIVATE_ENTRY", id, { privacy });
-	if (privacy !== "public") return rejectEntry("SKIP_ENTRY_MALFORMED", id, { field: "privacy" });
-	const payloadHash = value.payloadHash;
-	if (!isValidPayloadHash(payloadHash, limits)) return rejectEntry("SKIP_ENTRY_HASH_INVALID", id, { maxPayloadHashLength: limits.maxPayloadHashLength });
-	const variantCacheKey = value.variantCacheKey;
-	if (typeof variantCacheKey !== "string" || variantCacheKey.length === 0) return rejectEntry("SKIP_VARIANT_CACHE_KEY_INVALID", id, { field: "variantCacheKey" });
-	if (variantCacheKey.length > limits.maxVariantCacheKeyLength) return rejectEntry("SKIP_VARIANT_CACHE_KEY_TOO_LONG", id, {
-		maxVariantCacheKeyLength: limits.maxVariantCacheKeyLength,
-		variantCacheKeyHash: createClientReusePayloadHash(variantCacheKey)
-	});
-	const artifactCompatibility = parseArtifactCompatibilityEnvelope(value.artifactCompatibility);
-	if (artifactCompatibility === null) return rejectEntry("SKIP_ARTIFACT_COMPATIBILITY_INVALID", id, { field: "artifactCompatibility" });
-	return {
-		artifactCompatibility,
-		id,
-		kind,
-		payloadHash,
-		privacy,
-		variantCacheKey
-	};
-}
-function createClientReusePayloadHash(input) {
-	return fnv1a64(input);
-}
-function createClientReuseManifest(input) {
-	const replayWindow = input.replayWindow ?? {
-		validFromVisibleCommitVersion: input.visibleCommitVersion,
-		validUntilVisibleCommitVersion: input.visibleCommitVersion
-	};
-	return {
-		entries: createCanonicalWireEntries(input.entries),
-		hashAlgorithm: CLIENT_REUSE_MANIFEST_HASH_ALGORITHM,
-		replayWindow,
-		schemaVersion: 1,
-		visibleCommitVersion: input.visibleCommitVersion
-	};
-}
-function serializeClientReuseManifest(input) {
-	return JSON.stringify(createClientReuseManifest(input));
-}
-function parseClientReuseManifestHeader(rawHeader, options = {}) {
-	const header = rawHeader?.trim();
-	if (!header) return { kind: "absent" };
-	const limits = options.limits ?? DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS;
-	const manifestBytes = countUtf8Bytes(header);
-	if (manifestBytes > limits.maxManifestBytes) return rejectManifest("SKIP_MANIFEST_TOO_LARGE", {
-		manifestBytes,
-		maxManifestBytes: limits.maxManifestBytes
-	});
-	let decoded;
-	try {
-		decoded = JSON.parse(header);
-	} catch {
-		return rejectManifest("SKIP_MANIFEST_MALFORMED");
-	}
-	if (!isUnknownRecord(decoded)) return rejectManifest("SKIP_MANIFEST_MALFORMED", { field: "manifest" });
-	if (decoded.schemaVersion !== 1) return rejectManifest("SKIP_MANIFEST_SCHEMA_UNSUPPORTED", { schemaVersion: typeof decoded.schemaVersion === "number" || typeof decoded.schemaVersion === "string" ? decoded.schemaVersion : null });
-	if (decoded.hashAlgorithm !== "fnv1a64") return rejectManifest("SKIP_HASH_ALGORITHM_UNSUPPORTED", { hashAlgorithm: typeof decoded.hashAlgorithm === "string" ? decoded.hashAlgorithm : null });
-	const visibleCommitVersion = decoded.visibleCommitVersion;
-	if (!isNonNegativeSafeInteger(visibleCommitVersion)) return rejectManifest("SKIP_VISIBLE_COMMIT_VERSION_INVALID", { visibleCommitVersion: null });
-	const replayWindowResult = parseReplayWindow(decoded.replayWindow, visibleCommitVersion);
-	if (replayWindowResult.kind === "rejected") return {
-		kind: "rejected",
-		rejection: replayWindowResult.rejection
-	};
-	const { replayWindow } = replayWindowResult;
-	if (!currentCommitVersionMatchesReplayWindow(options.currentVisibleCommitVersion, replayWindow)) return rejectManifest("SKIP_VISIBLE_COMMIT_VERSION_MISMATCH", {
-		currentVisibleCommitVersion: options.currentVisibleCommitVersion ?? null,
-		validFromVisibleCommitVersion: replayWindow.validFromVisibleCommitVersion,
-		validUntilVisibleCommitVersion: replayWindow.validUntilVisibleCommitVersion,
-		visibleCommitVersion
-	});
-	const entriesValue = decoded.entries;
-	if (!Array.isArray(entriesValue)) return rejectManifest("SKIP_MANIFEST_MALFORMED", { field: "entries" });
-	if (entriesValue.length > limits.maxEntryCount) return rejectManifest("SKIP_ENTRY_COUNT_EXCEEDED", {
-		entryCount: entriesValue.length,
-		maxEntryCount: limits.maxEntryCount
-	});
-	const entries = [];
-	const entryRejections = [];
-	let previousEntryId = null;
-	for (let index = 0; index < entriesValue.length; index++) {
-		const value = entriesValue[index];
-		if (isUnknownRecord(value) && typeof value.id === "string") {
-			if (previousEntryId !== null && value.id <= previousEntryId) return rejectManifest("SKIP_ENTRY_ORDER_NON_CANONICAL", {
-				entryIdHash: createClientReusePayloadHash(value.id),
-				previousEntryIdHash: createClientReusePayloadHash(previousEntryId)
-			});
-			previousEntryId = value.id;
-		}
-		const parsedEntry = parseManifestEntry(value, limits, index);
-		if ("code" in parsedEntry) entryRejections.push(parsedEntry);
-		else entries.push(parsedEntry);
-	}
-	return {
-		entryRejections,
-		kind: "parsed",
-		manifest: {
-			entries,
-			hashAlgorithm: CLIENT_REUSE_MANIFEST_HASH_ALGORITHM,
-			replayWindow,
-			schemaVersion: 1,
-			visibleCommitVersion
-		},
-		skipDisposition: {
-			code: "SKIP_MODEL_DISABLED",
-			enabled: false,
-			mode: "renderAndSend"
-		}
-	};
-}
-//#endregion
-export { CLIENT_REUSE_MANIFEST_HASH_ALGORITHM, CLIENT_REUSE_MANIFEST_SCHEMA_VERSION, CLIENT_REUSE_MANIFEST_SKIP_VERIFICATION_ENTRY_BUDGET, DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS, countUtf8Bytes, createClientReuseManifest, createClientReusePayloadHash, parseClientReuseManifestHeader, serializeClientReuseManifest };