@qzsy/vinext 0.1.7

package/dist/server/app-browser-visible-commit.js

@@ -0,0 +1,241 @@
+import { normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
+import "./app-elements.js";
+import { mergeElements } from "../shims/slot.js";
+import { NavigationTraceReasonCodes, NavigationTraceTransactionCodes, createNavigationTrace, prependNavigationTraceEntry } from "./navigation-trace.js";
+import { preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
+import { createPendingNavigationCommit, resolvePendingNavigationCommitDispositionDecision } from "./app-browser-state.js";
+//#region src/server/app-browser-visible-commit.ts
+const approvedVisibleCommitBrand = Symbol("ApprovedVisibleCommit");
+function applyApprovedVisibleCommit(state, commit) {
+	assertApprovedVisibleCommit(commit);
+	return reduceApprovedVisibleCommitState(state, commit);
+}
+function assertApprovedVisibleCommit(commit) {
+	if (commit[approvedVisibleCommitBrand] !== true) throw new Error("[vinext] Visible router state mutation requires ApprovedVisibleCommit");
+}
+function commitOperationRecord(operation, visibleCommitVersion) {
+	return {
+		id: operation.id,
+		lane: operation.lane,
+		startedVisibleCommitVersion: operation.startedVisibleCommitVersion,
+		state: "committed",
+		visibleCommitVersion
+	};
+}
+function commitVisibleRouterState(state, nextState, operation) {
+	const visibleCommitVersion = state.visibleCommitVersion + 1;
+	return {
+		...nextState,
+		activeOperation: commitOperationRecord(operation, visibleCommitVersion),
+		visibleCommitVersion
+	};
+}
+function mergeSlotBindings(previousBindings, nextBindings, layoutIds, preservePreviousSlotIds) {
+	if (preservePreviousSlotIds.length === 0) return nextBindings;
+	const preservedSlotIds = new Set(preservePreviousSlotIds);
+	const previousBindingsBySlotId = /* @__PURE__ */ new Map();
+	for (const binding of previousBindings) {
+		if (!preservedSlotIds.has(binding.slotId)) continue;
+		previousBindingsBySlotId.set(binding.slotId, binding);
+	}
+	const mergedBindings = [];
+	const seenSlotIds = /* @__PURE__ */ new Set();
+	for (const binding of nextBindings) {
+		const previousBinding = previousBindingsBySlotId.get(binding.slotId);
+		mergedBindings.push(previousBinding ?? binding);
+		seenSlotIds.add(binding.slotId);
+	}
+	for (const slotId of preservePreviousSlotIds) {
+		if (seenSlotIds.has(slotId)) continue;
+		const previousBinding = previousBindingsBySlotId.get(slotId);
+		if (previousBinding) mergedBindings.push(previousBinding);
+	}
+	return normalizeAppElementsSlotBindings(mergedBindings, { layoutIds });
+}
+function reduceApprovedVisibleCommitState(state, commit) {
+	const { action } = commit;
+	switch (action.type) {
+		case "traverse":
+		case "navigate": {
+			const preserveElementIds = action.reuseCurrentBfcacheIds ? commit.decision.preserveElementIds : [];
+			const preservePreviousSlotIds = action.reuseCurrentBfcacheIds ? commit.decision.preservePreviousSlotIds : [];
+			const mergedElements = mergeElements(state.elements, action.elements, {
+				clearAbsentSlots: action.type === "traverse" || !action.reuseCurrentBfcacheIds,
+				preserveAbsentSlots: action.reuseCurrentBfcacheIds && commit.decision.preserveAbsentSlots,
+				preserveElementIds,
+				preservePreviousSlotIds
+			});
+			return commitVisibleRouterState(state, {
+				bfcacheIds: preserveBfcacheIdsForMergedElements({
+					elements: mergedElements,
+					next: action.bfcacheIds,
+					previous: action.reuseCurrentBfcacheIds ? state.bfcacheIds : {}
+				}),
+				elements: mergedElements,
+				interception: action.interception,
+				interceptionContext: action.interceptionContext,
+				layoutFlags: mergeLayoutFlags(state.layoutFlags, action.layoutFlags, preserveElementIds),
+				layoutIds: action.layoutIds,
+				navigationSnapshot: action.navigationSnapshot,
+				previousNextUrl: action.previousNextUrl,
+				renderId: action.renderId,
+				rootLayoutTreePath: action.rootLayoutTreePath,
+				routeId: action.routeId,
+				slotBindings: mergeSlotBindings(state.slotBindings, action.slotBindings, action.layoutIds, preservePreviousSlotIds)
+			}, action.operation);
+		}
+		case "replace": return commitVisibleRouterState(state, {
+			bfcacheIds: action.bfcacheIds,
+			elements: action.elements,
+			interception: action.interception,
+			interceptionContext: action.interceptionContext,
+			layoutFlags: action.layoutFlags,
+			layoutIds: action.layoutIds,
+			navigationSnapshot: action.navigationSnapshot,
+			previousNextUrl: action.previousNextUrl,
+			renderId: action.renderId,
+			rootLayoutTreePath: action.rootLayoutTreePath,
+			routeId: action.routeId,
+			slotBindings: action.slotBindings
+		}, action.operation);
+		default: {
+			const _exhaustive = action.type;
+			throw new Error("[vinext] Unknown router action: " + String(_exhaustive));
+		}
+	}
+}
+function resolvePendingNavigationCommitDecision(options) {
+	const decision = resolvePendingNavigationCommitDispositionDecision(options);
+	switch (decision.disposition) {
+		case "skip": return {
+			disposition: "no-commit",
+			trace: decision.trace
+		};
+		case "hard-navigate": return {
+			disposition: "hard-navigate",
+			trace: decision.trace
+		};
+		case "dispatch": return createVisibleCommitDecision(decision.trace, decision.preserveElementIds, decision.preserveAbsentSlots, decision.preservePreviousSlotIds);
+		default: throw new Error("[vinext] Unknown navigation commit disposition: " + String(decision));
+	}
+}
+function createVisibleCommitDecision(trace = createNavigationTrace(NavigationTraceReasonCodes.commitCurrent), preserveElementIds = [], preserveAbsentSlots = false, preservePreviousSlotIds = []) {
+	return {
+		disposition: "commit",
+		preserveAbsentSlots,
+		preserveElementIds: [...preserveElementIds],
+		preservePreviousSlotIds: [...preservePreviousSlotIds],
+		trace
+	};
+}
+function mergeLayoutFlags(previousFlags, nextFlags, preserveElementIds) {
+	const merged = { ...nextFlags };
+	for (const id of preserveElementIds) {
+		if (Object.hasOwn(merged, id)) continue;
+		const value = previousFlags[id];
+		if (value) merged[id] = value;
+	}
+	return merged;
+}
+function createApprovedVisibleCommit(options) {
+	return {
+		[approvedVisibleCommitBrand]: true,
+		action: options.pending.action,
+		decision: options.decision,
+		interception: options.pending.interception,
+		interceptionContext: options.pending.interceptionContext,
+		previousNextUrl: options.pending.previousNextUrl,
+		rootLayoutTreePath: options.pending.rootLayoutTreePath,
+		routeId: options.pending.routeId
+	};
+}
+function createCommitTransactionFields(pending) {
+	return {
+		operationLane: pending.action.operation.lane,
+		pendingOperationId: pending.action.operation.id,
+		startedVisibleCommitVersion: pending.action.operation.startedVisibleCommitVersion
+	};
+}
+function prependCommitTransactionTrace(trace, code, pending) {
+	return prependNavigationTraceEntry(trace, code, createCommitTransactionFields(pending));
+}
+function addCommitTransactionTrace(decision, pending) {
+	switch (decision.disposition) {
+		case "commit": return {
+			...decision,
+			trace: prependCommitTransactionTrace(decision.trace, NavigationTraceTransactionCodes.visibleCommit, pending)
+		};
+		case "hard-navigate": return {
+			...decision,
+			trace: prependCommitTransactionTrace(decision.trace, NavigationTraceTransactionCodes.hardNavigate, pending)
+		};
+		case "no-commit": return {
+			...decision,
+			trace: prependCommitTransactionTrace(decision.trace, NavigationTraceTransactionCodes.noCommit, pending)
+		};
+		default: throw new Error("[vinext] Unknown commit decision: " + String(decision));
+	}
+}
+function approveHmrVisibleCommit(pending) {
+	if (pending.action.operation.lane !== "hmr") throw new Error("[vinext] HMR visible commit approval requires an HMR pending operation");
+	const decision = addCommitTransactionTrace(createVisibleCommitDecision(), pending);
+	if (decision.disposition !== "commit") throw new Error("[vinext] HMR visible commit approval did not produce a commit decision");
+	return createApprovedVisibleCommit({
+		decision,
+		pending
+	});
+}
+function approvePendingNavigationCommit(options) {
+	const decision = addCommitTransactionTrace(resolvePendingNavigationCommitDecision({
+		activeNavigationId: options.activeNavigationId,
+		currentState: options.currentState,
+		pending: options.pending,
+		routeManifest: options.routeManifest ?? null,
+		startedNavigationId: options.startedNavigationId,
+		targetHref: options.targetHref
+	}), options.pending);
+	switch (decision.disposition) {
+		case "commit": return {
+			approvedCommit: createApprovedVisibleCommit({
+				decision,
+				pending: options.pending
+			}),
+			decision
+		};
+		case "hard-navigate":
+		case "no-commit": return {
+			approvedCommit: null,
+			decision
+		};
+		default: throw new Error("[vinext] Unknown commit decision: " + String(decision));
+	}
+}
+async function resolveAndClassifyNavigationCommit(options) {
+	const pending = await createPendingNavigationCommit({
+		currentState: options.currentState,
+		nextElements: options.nextElements,
+		navigationSnapshot: options.navigationSnapshot,
+		operationLane: options.operationLane,
+		payloadOrigin: options.payloadOrigin,
+		previousNextUrl: options.previousNextUrl,
+		renderId: options.renderId,
+		type: options.type
+	});
+	const approvalState = options.getCurrentStateForApproval?.() ?? options.currentState;
+	const approval = approvePendingNavigationCommit({
+		activeNavigationId: options.getActiveNavigationId?.() ?? options.activeNavigationId,
+		currentState: approvalState,
+		pending,
+		routeManifest: options.routeManifest ?? null,
+		startedNavigationId: options.startedNavigationId,
+		targetHref: options.targetHref
+	});
+	return {
+		approvedCommit: approval.approvedCommit,
+		decision: approval.decision,
+		pending,
+		trace: approval.decision.trace
+	};
+}
+//#endregion
+export { applyApprovedVisibleCommit, approveHmrVisibleCommit, approvePendingNavigationCommit, resolveAndClassifyNavigationCommit };

package/dist/server/app-client-reference-preloader.d.ts

@@ -0,0 +1,14 @@
+//#region src/server/app-client-reference-preloader.d.ts
+type ClientReferenceRequire = (id: string) => Promise<unknown>;
+type ClientReferenceMap = Readonly<Record<string, unknown>>;
+type ClientReferencePreloaderOptions = {
+  getReferences: () => ClientReferenceMap | undefined;
+  getClientRequire: () => ClientReferenceRequire | undefined;
+  onPreloadError?: (id: string, error: unknown) => void;
+};
+type ClientReferencePreloader = {
+  preload: (referenceIds?: Iterable<string>) => Promise<void>;
+};
+declare function createClientReferencePreloader(options: ClientReferencePreloaderOptions): ClientReferencePreloader;
+//#endregion
+export { createClientReferencePreloader };

package/dist/server/app-client-reference-preloader.js

@@ -0,0 +1,44 @@
+//#region src/server/app-client-reference-preloader.ts
+const resolvedPreload = Promise.resolve();
+function createClientReferencePreloader(options) {
+	let allReferencesPreloaded = false;
+	let allReferencesPreloadPromise = null;
+	const preloadedReferences = /* @__PURE__ */ new Set();
+	const referencePreloadPromises = /* @__PURE__ */ new Map();
+	function preloadReference(id, clientRequire) {
+		if (preloadedReferences.has(id)) return resolvedPreload;
+		const existing = referencePreloadPromises.get(id);
+		if (existing) return existing;
+		const preloadPromise = clientRequire(id).catch((error) => {
+			options.onPreloadError?.(id, error);
+		}).then(() => {
+			preloadedReferences.add(id);
+		}).finally(() => {
+			referencePreloadPromises.delete(id);
+		});
+		referencePreloadPromises.set(id, preloadPromise);
+		return preloadPromise;
+	}
+	function preloadReferenceSet(referenceIds, refs, clientRequire) {
+		const pending = [];
+		for (const id of referenceIds) if (Object.hasOwn(refs, id)) pending.push(preloadReference(id, clientRequire));
+		if (pending.length === 0) return resolvedPreload;
+		return Promise.all(pending).then(() => {});
+	}
+	return { preload(referenceIds) {
+		const refs = options.getReferences();
+		const clientRequire = options.getClientRequire();
+		if (!refs || !clientRequire) return resolvedPreload;
+		if (referenceIds) return preloadReferenceSet(referenceIds, refs, clientRequire);
+		if (allReferencesPreloaded) return resolvedPreload;
+		if (allReferencesPreloadPromise) return allReferencesPreloadPromise;
+		allReferencesPreloadPromise = preloadReferenceSet(Object.keys(refs), refs, clientRequire).then(() => {
+			allReferencesPreloaded = true;
+		}).finally(() => {
+			allReferencesPreloadPromise = null;
+		});
+		return allReferencesPreloadPromise;
+	} };
+}
+//#endregion
+export { createClientReferencePreloader };

package/dist/server/app-elements-wire.d.ts

@@ -0,0 +1,192 @@
+import { ArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
+import { CacheEntryReuseProof, RenderObservation } from "./cache-proof.js";
+import { ClientReuseManifestSkipDisposition } from "./client-reuse-manifest.js";
+import { ReactNode } from "react";
+
+//#region src/server/app-elements-wire.d.ts
+declare const APP_ARTIFACT_COMPATIBILITY_KEY = "__artifactCompatibility";
+declare const APP_CACHE_ENTRY_REUSE_PROOF_KEY = "__cacheEntryReuseProof";
+declare const APP_INTERCEPTION_KEY = "__interception";
+declare const APP_INTERCEPTION_CONTEXT_KEY = "__interceptionContext";
+declare const APP_LAYOUT_IDS_KEY = "__layoutIds";
+declare const APP_LAYOUT_FLAGS_KEY = "__layoutFlags";
+declare const APP_RENDER_OBSERVATION_KEY = "__renderObservation";
+declare const APP_ROUTE_KEY = "__route";
+declare const APP_ROOT_LAYOUT_KEY = "__rootLayout";
+declare const APP_SKIPPED_LAYOUT_IDS_KEY = "__skippedLayoutIds";
+declare const APP_SOURCE_PAGE_KEY = "__sourcePage";
+declare const APP_SLOT_BINDINGS_KEY = "__slotBindings";
+/**
+ * Static sibling segment names for the matched route, surfaced so the client
+ * router can determine if a cached prefetch of a dynamic route can be reused
+ * when navigating to a static sibling URL.
+ *
+ * Mirrors Next.js's `staticSiblings` tuple element on the loader-tree dynamic
+ * segments (issue cloudflare/vinext#1525).
+ */
+declare const APP_STATIC_SIBLINGS_KEY = "__staticSiblings";
+declare const APP_UNMATCHED_SLOT_WIRE_VALUE = "__VINEXT_UNMATCHED_SLOT__";
+declare const UNMATCHED_SLOT: unique symbol;
+type AppElementsSlotBindingState = "active" | "default" | "unmatched";
+type AppElementsSlotBinding = Readonly<{
+  activeRouteId?: string | null;
+  ownerLayoutId: string | null;
+  slotId: string;
+  state: AppElementsSlotBindingState;
+}>;
+type AppElementsInterception = Readonly<{
+  sourceMatchedUrl: string;
+  sourceRouteId: string;
+  slotId: string;
+  targetMatchedUrl: string;
+  targetRouteId: string;
+}>;
+declare const compareAppElementsSlotIds: (left: string, right: string) => number;
+declare function normalizeAppElementsSlotBindings(slotBindings: readonly AppElementsSlotBinding[], options?: {
+  layoutIds?: readonly string[];
+}): readonly AppElementsSlotBinding[];
+type AppElementValue = ReactNode | typeof UNMATCHED_SLOT | string | null | LayoutFlags | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | readonly string[] | readonly AppElementsSlotBinding[];
+type AppWireElementValue = ReactNode | string | null | LayoutFlags | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | readonly string[] | readonly AppElementsSlotBinding[];
+type AppElements = Readonly<Record<string, AppElementValue>>;
+type AppWireElements = Readonly<Record<string, AppWireElementValue>>;
+/**
+ * Per-layout static/dynamic flags. `"s"` = static (skippable on next nav);
+ * `"d"` = dynamic (must always render).
+ *
+ * Lifecycle (partial — later PRs extend this):
+ *
+ *   1. PROBE   — probeAppPageLayouts (server/app-page-execution.ts) returns
+ *                LayoutFlags for every layout in the route at render time.
+ *
+ *   2. ATTACH  — AppElementsWire.encodeOutgoingPayload writes `__layoutFlags`
+ *                into the outgoing App Router payload record.
+ *
+ *   3. WIRE    — renderToReadableStream serializes the record as RSC row 0.
+ *
+ *   4. PARSE   — AppElementsWire.readMetadata extracts layoutFlags from the
+ *                wire payload on the client side.
+ */
+type LayoutFlags = Readonly<Record<string, "s" | "d">>;
+type AppElementsMetadata = {
+  artifactCompatibility: ArtifactCompatibilityEnvelope;
+  cacheEntryReuseProof?: CacheEntryReuseProof;
+  interception: AppElementsInterception | null;
+  interceptionContext: string | null;
+  layoutIds: readonly string[];
+  layoutFlags: LayoutFlags;
+  routeId: string;
+  rootLayoutTreePath: string | null;
+  skippedLayoutIds: readonly string[];
+  slotBindings: readonly AppElementsSlotBinding[];
+  sourcePage: string | null;
+};
+type AppElementsWireElementKey = {
+  kind: "layout";
+  treePath: string;
+} | {
+  interceptionContext: string | null;
+  kind: "page";
+  path: string;
+} | {
+  interceptionContext: string | null;
+  kind: "route";
+  path: string;
+} | {
+  kind: "slot";
+  name: string;
+  treePath: string;
+} | {
+  kind: "template";
+  treePath: string;
+};
+type AppElementsWireMetadataInput = {
+  interception?: AppElementsInterception | null;
+  interceptionContext: string | null;
+  layoutIds?: readonly string[];
+  routeId: string;
+  rootLayoutTreePath: string | null;
+  slotBindings?: readonly AppElementsSlotBinding[];
+  sourcePage?: string | null;
+};
+type AppElementsWireMetadataEntries = Readonly<{
+  [APP_ROUTE_KEY]: string;
+  [APP_INTERCEPTION_KEY]?: AppElementsInterception;
+  [APP_INTERCEPTION_CONTEXT_KEY]: string | null;
+  [APP_LAYOUT_IDS_KEY]: readonly string[];
+  [APP_ROOT_LAYOUT_KEY]: string | null;
+  [APP_SOURCE_PAGE_KEY]?: string;
+  [APP_SLOT_BINDINGS_KEY]?: readonly AppElementsSlotBinding[];
+}>;
+/**
+ * The outgoing wire payload shape. Includes ReactNode values for the
+ * rendered tree plus metadata values like LayoutFlags attached under
+ * known keys (e.g. __layoutFlags). Distinct from AppElements / AppWireElements
+ * which only carry render-time values.
+ */
+type AppOutgoingElements = Readonly<Record<string, ReactNode | LayoutFlags | ArtifactCompatibilityEnvelope | CacheEntryReuseProof | AppElementsInterception | RenderObservation | readonly string[] | readonly AppElementsSlotBinding[]>>;
+type AppElementsWireKeys = {
+  readonly artifactCompatibility: typeof APP_ARTIFACT_COMPATIBILITY_KEY;
+  readonly cacheEntryReuseProof: typeof APP_CACHE_ENTRY_REUSE_PROOF_KEY;
+  readonly interception: typeof APP_INTERCEPTION_KEY;
+  readonly interceptionContext: typeof APP_INTERCEPTION_CONTEXT_KEY;
+  readonly layoutIds: typeof APP_LAYOUT_IDS_KEY;
+  readonly layoutFlags: typeof APP_LAYOUT_FLAGS_KEY;
+  readonly renderObservation: typeof APP_RENDER_OBSERVATION_KEY;
+  readonly rootLayout: typeof APP_ROOT_LAYOUT_KEY;
+  readonly route: typeof APP_ROUTE_KEY;
+  readonly skippedLayoutIds: typeof APP_SKIPPED_LAYOUT_IDS_KEY;
+  readonly slotBindings: typeof APP_SLOT_BINDINGS_KEY;
+  readonly sourcePage: typeof APP_SOURCE_PAGE_KEY;
+};
+type AppElementsWireCodec = {
+  readonly keys: AppElementsWireKeys;
+  readonly unmatchedSlotValue: typeof APP_UNMATCHED_SLOT_WIRE_VALUE;
+  createMetadataEntries(input: AppElementsWireMetadataInput): AppElementsWireMetadataEntries;
+  decode(elements: AppWireElements): AppElements;
+  encodeCacheKey(rscUrl: string, interceptionContext: string | null): string;
+  encodeLayoutId(treePath: string): string;
+  encodeOutgoingPayload(input: {
+    element: ReactNode | AppElements;
+    artifactCompatibility?: ArtifactCompatibilityEnvelope;
+    cacheEntryReuseProof?: CacheEntryReuseProof;
+    layoutFlags: LayoutFlags;
+    renderObservation?: RenderObservation;
+    skipDisposition?: ClientReuseManifestSkipDisposition;
+  }): ReactNode | AppOutgoingElements;
+  encodePageId(routePath: string, interceptionContext: string | null): string;
+  encodeRouteId(routePath: string, interceptionContext: string | null): string;
+  encodeSlotId(slotName: string, treePath: string): string;
+  encodeTemplateId(treePath: string): string;
+  isSlotId(key: string): boolean;
+  parseElementKey(key: string): AppElementsWireElementKey | null;
+  readMetadata(elements: Readonly<Record<string, unknown>>): AppElementsMetadata;
+  withLayoutFlags<T extends Record<string, unknown>>(elements: T, layoutFlags: LayoutFlags): T & {
+    [APP_LAYOUT_FLAGS_KEY]: LayoutFlags;
+  };
+};
+declare function normalizeAppElements(elements: AppWireElements): AppElements;
+/**
+ * Type predicate for a plain (non-null, non-array) record of app payload values.
+ * Used to distinguish the App Router payload object from bare React elements at
+ * the render boundary. Narrows to `Readonly<Record<string, unknown>>` because
+ * the outgoing payload carries heterogeneous values (ReactNodes for the rendered
+ * tree, plus metadata like `__layoutFlags` which is a plain object). Delegates
+ * to React's canonical `isValidElement` so we don't depend on React's internal
+ * `$$typeof` marker scheme.
+ */
+declare function isAppElementsRecord(value: unknown): value is Readonly<Record<string, unknown>>;
+declare function withLayoutFlags<T extends Record<string, unknown>>(elements: T, layoutFlags: LayoutFlags): T & {
+  [APP_LAYOUT_FLAGS_KEY]: LayoutFlags;
+};
+declare function buildOutgoingAppPayload(input: {
+  element: ReactNode | AppElements;
+  artifactCompatibility?: ArtifactCompatibilityEnvelope;
+  cacheEntryReuseProof?: CacheEntryReuseProof;
+  layoutFlags: LayoutFlags;
+  renderObservation?: RenderObservation;
+  skipDisposition?: ClientReuseManifestSkipDisposition;
+}): ReactNode | AppOutgoingElements;
+declare function readAppElementsMetadata(elements: Readonly<Record<string, unknown>>): AppElementsMetadata;
+declare const AppElementsWire: AppElementsWireCodec;
+//#endregion
+export { APP_ARTIFACT_COMPATIBILITY_KEY, APP_CACHE_ENTRY_REUSE_PROOF_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_LAYOUT_FLAGS_KEY, APP_LAYOUT_IDS_KEY, APP_RENDER_OBSERVATION_KEY, APP_ROOT_LAYOUT_KEY, APP_ROUTE_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_SLOT_BINDINGS_KEY, APP_SOURCE_PAGE_KEY, APP_STATIC_SIBLINGS_KEY, APP_UNMATCHED_SLOT_WIRE_VALUE, AppElementValue, AppElements, AppElementsInterception, AppElementsSlotBinding, AppElementsWire, AppOutgoingElements, AppWireElements, LayoutFlags, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, withLayoutFlags };