@bgub/fig-reconciler 0.0.1 → 0.1.0-alpha.1

package/dist/refresh.js.map

@@ -1 +1 @@
-{"version":3,"file":"refresh.js","names":[],"sources":["../src/refresh.ts"],"sourcesContent":["import { setRefreshHandlerState } from \"./refresh-state.ts\";\n\ndeclare const __FIG_DEV__: boolean | undefined;\n\nconst __DEV__ = typeof __FIG_DEV__ === \"boolean\" ? __FIG_DEV__ : false;\n\n// A family groups every version of a component across hot edits; `current` is\n// the latest implementation. The handler is module-global (one refresh runtime\n// per app) so module-level reconcile helpers can consult it. In production no\n// handler is ever set, so all of this collapses to identity/equality paths.\nexport interface RefreshFamily {\n  current: unknown;\n}\n\nexport interface RefreshUpdate {\n  staleFamilies: Set<RefreshFamily>;\n  updatedFamilies: Set<RefreshFamily>;\n}\n\nexport function setRefreshHandler(\n  handler: ((type: unknown) => RefreshFamily | undefined) | null,\n): void {\n  if (__DEV__) {\n    setRefreshHandlerState(handler);\n  }\n}\n"],"mappings":";AAmBA,SAAgB,kBACd,SACM,CAIR"}
+{"version":3,"file":"refresh.js","names":[],"sources":["../src/refresh.ts"],"sourcesContent":["import { setRefreshHandlerState } from \"./refresh-internal.ts\";\n\ndeclare const __FIG_DEV__: boolean | undefined;\n\nconst __DEV__ = typeof __FIG_DEV__ === \"boolean\" ? __FIG_DEV__ : false;\n\n// A family groups every version of a component across hot edits; `current` is\n// the latest implementation. The handler is module-global (one refresh runtime\n// per app) so module-level reconcile helpers can consult it. In production no\n// handler is ever set, so all of this collapses to identity/equality paths.\nexport interface RefreshFamily {\n  current: unknown;\n}\n\nexport interface RefreshUpdate {\n  staleFamilies: Set<RefreshFamily>;\n  updatedFamilies: Set<RefreshFamily>;\n}\n\nexport function setRefreshHandler(\n  handler: ((type: unknown) => RefreshFamily | undefined) | null,\n): void {\n  if (__DEV__) {\n    setRefreshHandlerState(handler);\n  }\n}\n"],"mappings":";AAmBA,SAAgB,kBACd,SACM,CAIR"}

package/dist/scheduler-WVeIVb_n.js

@@ -0,0 +1,209 @@
+const priorityTimeouts = {
+	[1]: -1,
+	[2]: 250,
+	[3]: 5e3,
+	[4]: 1e4,
+	[5]: 1073741823
+};
+const frameInterval = 5;
+function compare(a, b) {
+	return a.expirationTime - b.expirationTime || a.id - b.id;
+}
+var MinHeap = class {
+	items = [];
+	push(value) {
+		this.items.push(value);
+		this.siftUp(this.items.length - 1);
+	}
+	peek() {
+		return this.items[0] ?? null;
+	}
+	pop() {
+		const first = this.items[0];
+		const last = this.items.pop();
+		if (first === void 0 || last === void 0) return null;
+		if (first !== last) {
+			this.items[0] = last;
+			this.siftDown(0);
+		}
+		return first;
+	}
+	siftUp(index) {
+		const value = this.items[index];
+		while (index > 0) {
+			const parentIndex = index - 1 >>> 1;
+			const parent = this.items[parentIndex];
+			if (compare(parent, value) <= 0) return;
+			this.items[parentIndex] = value;
+			this.items[index] = parent;
+			index = parentIndex;
+		}
+	}
+	siftDown(index) {
+		const length = this.items.length;
+		const value = this.items[index];
+		while (index < length) {
+			const leftIndex = index * 2 + 1;
+			const rightIndex = leftIndex + 1;
+			let smallest = index;
+			if (leftIndex < length && compare(this.items[leftIndex], this.items[smallest]) < 0) smallest = leftIndex;
+			if (rightIndex < length && compare(this.items[rightIndex], this.items[smallest]) < 0) smallest = rightIndex;
+			if (smallest === index) return;
+			this.items[index] = this.items[smallest];
+			this.items[smallest] = value;
+			index = smallest;
+		}
+	}
+};
+const taskQueue = new MinHeap();
+let taskId = 1;
+let messageLoopRunning = false;
+let needsPaint = false;
+let startTime = -1;
+let actQueue = null;
+let actScopeDepth = 0;
+let flushingActQueue = false;
+const actFlushLimit = 1e3;
+function now() {
+	return globalThis.performance?.now?.() ?? Date.now();
+}
+function shouldYieldToHost() {
+	return needsPaint || now() - startTime >= frameInterval;
+}
+function requestPaint() {
+	needsPaint = true;
+}
+function scheduleCallback(priority, callback) {
+	const task = {
+		id: taskId++,
+		callback,
+		expirationTime: now() + priorityTimeouts[priority]
+	};
+	if (actQueue !== null) actQueue.push(task);
+	else {
+		taskQueue.push(task);
+		requestHostCallback();
+	}
+	return { cancel() {
+		task.callback = null;
+	} };
+}
+async function act(callback) {
+	const previousActQueue = actQueue;
+	const previousActScopeDepth = actScopeDepth;
+	const queue = previousActQueue ?? [];
+	actQueue = queue;
+	actScopeDepth = previousActScopeDepth + 1;
+	try {
+		const result = await callback();
+		actScopeDepth = previousActScopeDepth;
+		if (previousActScopeDepth === 0) await flushActQueueUntilSettled(queue);
+		return result;
+	} finally {
+		actScopeDepth = previousActScopeDepth;
+		actQueue = previousActQueue;
+	}
+}
+async function flushActQueueUntilSettled(queue) {
+	for (let flushes = 0; flushes < actFlushLimit; flushes += 1) {
+		flushActQueue(queue);
+		await Promise.resolve();
+		if (hasActWork(queue)) continue;
+		await waitForActMacrotask();
+		if (!hasActWork(queue)) {
+			queue.length = 0;
+			return;
+		}
+	}
+	throw new Error("act() exceeded the scheduled work flush limit.");
+}
+function flushActQueue(queue) {
+	if (flushingActQueue) return;
+	flushingActQueue = true;
+	try {
+		let task = takeNextActTask(queue);
+		while (task !== null) {
+			const callback = task.callback;
+			if (callback !== null) {
+				task.callback = null;
+				needsPaint = false;
+				startTime = now();
+				const continuation = callback();
+				if (typeof continuation === "function") {
+					task.callback = continuation;
+					queue.push(task);
+				}
+			}
+			task = takeNextActTask(queue);
+		}
+	} finally {
+		flushingActQueue = false;
+	}
+}
+function hasActWork(queue) {
+	return queue.some((task) => task.callback !== null);
+}
+function takeNextActTask(queue) {
+	let nextIndex = -1;
+	for (let index = 0; index < queue.length; index += 1) {
+		const task = queue[index];
+		if (task.callback === null) continue;
+		if (nextIndex === -1 || compare(task, queue[nextIndex]) < 0) nextIndex = index;
+	}
+	if (nextIndex === -1) {
+		queue.length = 0;
+		return null;
+	}
+	const [task] = queue.splice(nextIndex, 1);
+	return task;
+}
+function waitForActMacrotask() {
+	return new Promise((resolve) => {
+		if (typeof setImmediate === "function") setImmediate(resolve);
+		else setTimeout(resolve, 0);
+	});
+}
+function requestHostCallback() {
+	if (messageLoopRunning) return;
+	messageLoopRunning = true;
+	scheduleHostCallback();
+}
+function performWorkUntilDeadline() {
+	needsPaint = false;
+	startTime = now();
+	let hasMoreWork = false;
+	try {
+		hasMoreWork = flushWork(startTime);
+	} finally {
+		if (hasMoreWork) scheduleHostCallback();
+		else messageLoopRunning = false;
+	}
+}
+let channel = null;
+const scheduleHostCallback = typeof setImmediate === "function" ? () => void setImmediate(performWorkUntilDeadline) : typeof MessageChannel === "function" ? () => {
+	if (channel === null) {
+		channel = new MessageChannel();
+		channel.port1.onmessage = () => performWorkUntilDeadline();
+	}
+	channel.port2.postMessage(null);
+} : () => void setTimeout(performWorkUntilDeadline, 0);
+function flushWork(currentTime) {
+	let task = taskQueue.peek();
+	while (task !== null) {
+		if (task.expirationTime > currentTime && shouldYieldToHost()) break;
+		const callback = task.callback;
+		if (callback === null) taskQueue.pop();
+		else {
+			task.callback = null;
+			const continuation = callback();
+			if (typeof continuation === "function") task.callback = continuation;
+			else if (task === taskQueue.peek()) taskQueue.pop();
+		}
+		task = taskQueue.peek();
+	}
+	return task !== null;
+}
+//#endregion
+export { shouldYieldToHost as a, scheduleCallback as i, now as n, requestPaint as r, act as t };
+
+//# sourceMappingURL=scheduler-WVeIVb_n.js.map

package/dist/scheduler-WVeIVb_n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler-WVeIVb_n.js","names":[],"sources":["../src/scheduler.ts"],"sourcesContent":["// Fig's cooperative task scheduler: a macrotask-hopping work loop with five\n// priority tiers (mapped from lanes in lanes.ts) and starvation timeouts.\n// Internal to fig-reconciler — the reconciler is its only consumer, so it is\n// deliberately not a published package.\n\nexport type PriorityLevel = 1 | 2 | 3 | 4 | 5;\nexport type SchedulerCallback = () => SchedulerCallback | undefined;\n\nexport interface ScheduledTask {\n  cancel(): void;\n}\n\nexport const ImmediatePriority = 1;\nexport const UserBlockingPriority = 2;\nexport const NormalPriority = 3;\nexport const LowPriority = 4;\nexport const IdlePriority = 5;\n\n// Starvation timeouts: once a task has waited this long it runs even past\n// frame-budget yields (see flushWork's expiration check).\nconst priorityTimeouts: Record<PriorityLevel, number> = {\n  [ImmediatePriority]: -1,\n  [UserBlockingPriority]: 250,\n  [NormalPriority]: 5_000,\n  [LowPriority]: 10_000,\n  [IdlePriority]: 1_073_741_823,\n};\n\nconst frameInterval = 5;\n\ninterface Task {\n  id: number;\n  callback: SchedulerCallback | null;\n  expirationTime: number;\n}\n\nfunction compare(a: Task, b: Task): number {\n  return a.expirationTime - b.expirationTime || a.id - b.id;\n}\n\nclass MinHeap {\n  readonly items: Task[] = [];\n\n  push(value: Task): void {\n    this.items.push(value);\n    this.siftUp(this.items.length - 1);\n  }\n\n  peek(): Task | null {\n    return this.items[0] ?? null;\n  }\n\n  pop(): Task | null {\n    const first = this.items[0];\n    const last = this.items.pop();\n\n    if (first === undefined || last === undefined) return null;\n\n    if (first !== last) {\n      this.items[0] = last;\n      this.siftDown(0);\n    }\n\n    return first;\n  }\n\n  private siftUp(index: number): void {\n    const value = this.items[index];\n\n    while (index > 0) {\n      const parentIndex = (index - 1) >>> 1;\n      const parent = this.items[parentIndex];\n      if (compare(parent, value) <= 0) return;\n\n      this.items[parentIndex] = value;\n      this.items[index] = parent;\n      index = parentIndex;\n    }\n  }\n\n  private siftDown(index: number): void {\n    const length = this.items.length;\n    const value = this.items[index];\n\n    while (index < length) {\n      const leftIndex = index * 2 + 1;\n      const rightIndex = leftIndex + 1;\n      let smallest = index;\n\n      if (\n        leftIndex < length &&\n        compare(this.items[leftIndex], this.items[smallest]) < 0\n      ) {\n        smallest = leftIndex;\n      }\n\n      if (\n        rightIndex < length &&\n        compare(this.items[rightIndex], this.items[smallest]) < 0\n      ) {\n        smallest = rightIndex;\n      }\n\n      if (smallest === index) return;\n\n      this.items[index] = this.items[smallest];\n      this.items[smallest] = value;\n      index = smallest;\n    }\n  }\n}\n\nconst taskQueue = new MinHeap();\nlet taskId = 1;\nlet messageLoopRunning = false;\nlet needsPaint = false;\nlet startTime = -1;\nlet actQueue: Task[] | null = null;\nlet actScopeDepth = 0;\nlet flushingActQueue = false;\n\nconst actFlushLimit = 1_000;\n\nexport function now(): number {\n  return globalThis.performance?.now?.() ?? Date.now();\n}\n\nexport function shouldYieldToHost(): boolean {\n  return needsPaint || now() - startTime >= frameInterval;\n}\n\n// Renderers call this after committing host mutations: the next\n// shouldYieldToHost() returns true, so the work loop hands the thread back\n// and the host can paint before further scheduled work runs.\nexport function requestPaint(): void {\n  needsPaint = true;\n}\n\nexport function scheduleCallback(\n  priority: PriorityLevel,\n  callback: SchedulerCallback,\n): ScheduledTask {\n  const task: Task = {\n    id: taskId++,\n    callback,\n    expirationTime: now() + priorityTimeouts[priority],\n  };\n\n  if (actQueue !== null) {\n    actQueue.push(task);\n  } else {\n    taskQueue.push(task);\n    requestHostCallback();\n  }\n\n  return {\n    cancel() {\n      task.callback = null;\n    },\n  };\n}\n\nexport async function act<T>(\n  callback: () => T | PromiseLike<T>,\n): Promise<Awaited<T>> {\n  const previousActQueue = actQueue;\n  const previousActScopeDepth = actScopeDepth;\n  const queue = previousActQueue ?? [];\n\n  actQueue = queue;\n  actScopeDepth = previousActScopeDepth + 1;\n\n  try {\n    const result = await callback();\n\n    actScopeDepth = previousActScopeDepth;\n    if (previousActScopeDepth === 0) {\n      await flushActQueueUntilSettled(queue);\n    }\n\n    return result;\n  } finally {\n    actScopeDepth = previousActScopeDepth;\n    actQueue = previousActQueue;\n  }\n}\n\nasync function flushActQueueUntilSettled(queue: Task[]): Promise<void> {\n  for (let flushes = 0; flushes < actFlushLimit; flushes += 1) {\n    flushActQueue(queue);\n    await Promise.resolve();\n\n    if (hasActWork(queue)) continue;\n\n    await waitForActMacrotask();\n    if (!hasActWork(queue)) {\n      queue.length = 0;\n      return;\n    }\n  }\n\n  throw new Error(\"act() exceeded the scheduled work flush limit.\");\n}\n\nfunction flushActQueue(queue: Task[]): void {\n  if (flushingActQueue) return;\n\n  flushingActQueue = true;\n  try {\n    let task = takeNextActTask(queue);\n    while (task !== null) {\n      const callback = task.callback;\n\n      if (callback !== null) {\n        task.callback = null;\n        needsPaint = false;\n        startTime = now();\n        const continuation = callback();\n        if (typeof continuation === \"function\") {\n          task.callback = continuation;\n          queue.push(task);\n        }\n      }\n\n      task = takeNextActTask(queue);\n    }\n  } finally {\n    flushingActQueue = false;\n  }\n}\n\nfunction hasActWork(queue: Task[]): boolean {\n  return queue.some((task) => task.callback !== null);\n}\n\nfunction takeNextActTask(queue: Task[]): Task | null {\n  let nextIndex = -1;\n  for (let index = 0; index < queue.length; index += 1) {\n    const task = queue[index];\n    if (task.callback === null) continue;\n\n    if (nextIndex === -1 || compare(task, queue[nextIndex]) < 0) {\n      nextIndex = index;\n    }\n  }\n\n  if (nextIndex === -1) {\n    queue.length = 0;\n    return null;\n  }\n\n  const [task] = queue.splice(nextIndex, 1);\n  return task;\n}\n\nfunction waitForActMacrotask(): Promise<void> {\n  return new Promise((resolve) => {\n    if (typeof setImmediate === \"function\") {\n      void setImmediate(resolve);\n    } else {\n      setTimeout(resolve, 0);\n    }\n  });\n}\n\nfunction requestHostCallback(): void {\n  if (messageLoopRunning) return;\n  messageLoopRunning = true;\n  scheduleHostCallback();\n}\n\nfunction performWorkUntilDeadline(): void {\n  needsPaint = false;\n  startTime = now();\n\n  let hasMoreWork = false;\n  try {\n    hasMoreWork = flushWork(startTime);\n  } finally {\n    if (hasMoreWork) scheduleHostCallback();\n    else messageLoopRunning = false;\n  }\n}\n\ndeclare const setImmediate: ((callback: () => void) => unknown) | undefined;\n\nlet channel: MessageChannel | null = null;\n\n// Host-callback preference, matching React's scheduler (facebook/react#20756):\n// - setImmediate first (Node, old IE): unlike a MessagePort with a message\n//   handler it never refs an idle event loop — importing the scheduler cannot\n//   keep a Node process alive — and it fires earlier in the loop's turn.\n//   Caveat shared with React: a page-level setImmediate polyfill would win\n//   this check in a browser; real browsers never reach it natively.\n// - MessageChannel in browsers, where setImmediate does not exist: preferred\n//   over setTimeout because nested setTimeout(0) is clamped to 4ms+, wasting\n//   most of a frame per work-loop hop. Created on the first post so module\n//   evaluation allocates nothing.\n// - setTimeout as the last resort for hosts with neither.\nconst scheduleHostCallback: () => void =\n  typeof setImmediate === \"function\"\n    ? () => void setImmediate(performWorkUntilDeadline)\n    : typeof MessageChannel === \"function\"\n      ? () => {\n          if (channel === null) {\n            channel = new MessageChannel();\n            channel.port1.onmessage = () => performWorkUntilDeadline();\n          }\n          channel.port2.postMessage(null);\n        }\n      : () => void setTimeout(performWorkUntilDeadline, 0);\n\nfunction flushWork(currentTime: number): boolean {\n  let task = taskQueue.peek();\n  while (task !== null) {\n    if (task.expirationTime > currentTime && shouldYieldToHost()) break;\n\n    const callback = task.callback;\n    if (callback === null) {\n      taskQueue.pop();\n    } else {\n      task.callback = null;\n      const continuation = callback();\n\n      if (typeof continuation === \"function\") {\n        task.callback = continuation;\n      } else if (task === taskQueue.peek()) {\n        // The callback may have scheduled work that sorts ahead of this task,\n        // so only pop when this task is still at the top of the heap; a stale\n        // entry is skipped via its null callback when it surfaces later.\n        taskQueue.pop();\n      }\n    }\n\n    task = taskQueue.peek();\n  }\n\n  return task !== null;\n}\n"],"mappings":"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"}

package/dist/view-transitions.d.ts

@@ -0,0 +1,31 @@
+import { ReconcilerCommitCoordinator, ReconcilerCommitResult } from "./commit-coordinator.js";
+import { Props, ViewTransitionSurface } from "@bgub/fig";
+//#region src/view-transitions.d.ts
+type ViewTransitionCommitResult = ReconcilerCommitResult;
+interface ViewTransitionSurfaceMeasurement {
+  absolutelyPositioned: boolean;
+  height: number;
+  inViewport: boolean;
+  width: number;
+  x: number;
+  y: number;
+}
+interface ViewTransitionMutationResult {
+  canceledNames: string[];
+  cancelRootSnapshot: boolean;
+}
+interface ViewTransitionSurfaceSnapshots {
+  readonly old: boolean;
+  readonly new: boolean;
+}
+interface ViewTransitionHostConfig<Container, Instance> {
+  commit(this: void, container: Container, types: readonly string[], prepareSnapshot: () => void, mutate: () => ViewTransitionMutationResult, ready: (active: boolean) => void, finished: () => void): ViewTransitionCommitResult;
+  apply(this: void, instance: Instance, name: string, className: string | null): void;
+  restore(this: void, instance: Instance, props: Props): void;
+  measure?(this: void, instance: Instance): ViewTransitionSurfaceMeasurement | null;
+  createSurface?(this: void, instance: Instance, name: string, snapshots: ViewTransitionSurfaceSnapshots): ViewTransitionSurface;
+  suspend?(this: void, container: Container, onFinished: () => void): boolean;
+}
+declare function createViewTransitionCommitCoordinator<Container, Instance>(host: ViewTransitionHostConfig<Container, Instance>): ReconcilerCommitCoordinator<Container, Instance>;
+//#endregion
+export { ViewTransitionCommitResult, ViewTransitionHostConfig, ViewTransitionMutationResult, ViewTransitionSurfaceMeasurement, ViewTransitionSurfaceSnapshots, createViewTransitionCommitCoordinator };

package/dist/view-transitions.js

@@ -0,0 +1,404 @@
+import { A as transitionTypeHooks, a as IdleLane, g as includesSomeLane, i as DeferredLane, r as AllTransitionLanes, s as RetryLanes, t as walkFiberForest, v as laneToIndex } from "./fiber-traversal-BHyIAyG9.js";
+//#region src/transition-types.ts
+const activeTransitions = [];
+const rootTransitionTypes = /* @__PURE__ */ new WeakMap();
+function getCurrentTransitionTypes(lane) {
+	const transition = activeTransitions[laneToIndex(lane)];
+	return transition === void 0 || transition === null || transition.types.size === 0 ? null : transition.types;
+}
+function getRootTransitionTypes(root, renderLanes) {
+	const types = /* @__PURE__ */ new Set();
+	const typesByLane = rootTransitionTypes.get(root);
+	if (typesByLane === void 0) return [];
+	for (const [lane, laneTypes] of typesByLane) {
+		if (!includesSomeLane(renderLanes, lane)) continue;
+		for (const type of laneTypes) types.add(type);
+	}
+	return [...types];
+}
+function retainTransitionTypes(lane, types) {
+	const index = laneToIndex(lane);
+	let transition = activeTransitions[index];
+	if (transition === void 0 || transition === null) {
+		transition = {
+			scopes: 0,
+			types: /* @__PURE__ */ new Set()
+		};
+		activeTransitions[index] = transition;
+	}
+	transition.scopes += 1;
+	if (types !== void 0) for (const type of types) transition.types.add(type);
+	return () => {
+		transition.scopes -= 1;
+		if (transition.scopes === 0) activeTransitions[index] = null;
+	};
+}
+function recordRootTransitionTypes(root, lane) {
+	const types = getCurrentTransitionTypes(lane);
+	if (types === null) return;
+	let typesByLane = rootTransitionTypes.get(root);
+	if (typesByLane === void 0) {
+		typesByLane = /* @__PURE__ */ new Map();
+		rootTransitionTypes.set(root, typesByLane);
+	}
+	let pendingTypes = typesByLane.get(lane);
+	if (pendingTypes === void 0) {
+		pendingTypes = /* @__PURE__ */ new Set();
+		typesByLane.set(lane, pendingTypes);
+	}
+	for (const type of types) pendingTypes.add(type);
+}
+function completeRootTransitionTypes(root, remainingLanes) {
+	const typesByLane = rootTransitionTypes.get(root);
+	if (typesByLane === void 0) return;
+	for (const lane of typesByLane.keys()) if (!includesSomeLane(remainingLanes, lane)) typesByLane.delete(lane);
+	if (typesByLane.size === 0) rootTransitionTypes.delete(root);
+}
+transitionTypeHooks.retain = retainTransitionTypes;
+transitionTypeHooks.record = recordRootTransitionTypes;
+transitionTypeHooks.complete = completeRootTransitionTypes;
+//#endregion
+//#region src/view-transitions.ts
+const ViewTransitionEligibleLanes = AllTransitionLanes | RetryLanes | DeferredLane | IdleLane;
+function createViewTransitionCommitCoordinator(host) {
+	let autoNameCounter = 0;
+	function isEligible(root) {
+		return !root.clearContainerBeforeCommit && root.renderLanes !== 0 && (root.renderLanes & ~ViewTransitionEligibleLanes) === 0;
+	}
+	function preparePlan(root, finishedWork) {
+		if (!isEligible(root)) return null;
+		if ((finishedWork.subtreeFlags & 4096) === 0 && !root.needsCommitDeletions) return null;
+		const plan = {
+			newSurfaces: [],
+			oldSurfaces: [],
+			rootAffected: false,
+			types: getRootTransitionTypes(root, root.renderLanes)
+		};
+		const collection = {
+			changedBoundaries: null,
+			exitsByName: /* @__PURE__ */ new Map(),
+			plan
+		};
+		if (root.needsCommitDeletions) collectDeletedViewTransitions(root, finishedWork, collection);
+		collection.changedBoundaries = attributeQueuedHostUpdates(root, plan);
+		collectFinishedViewTransitions(finishedWork.child, false, false, false, collection);
+		if (plan.oldSurfaces.length === 0 && plan.newSurfaces.length === 0) return null;
+		return plan;
+	}
+	function collectDeletedViewTransitions(root, node, collection) {
+		for (const cursor of root.commitIndex) {
+			if (cursor.deletions === null) continue;
+			for (const deletion of cursor.deletions) collectDeletedViewTransitionFiber(deletion, collection, true);
+		}
+	}
+	function collectDeletedViewTransitionFiber(cursor, collection, collectExit) {
+		if (cursor.tag === 8 || isHiddenBoundary(cursor)) return;
+		if (cursor.tag === 11) {
+			const name = explicitViewTransitionName(cursor);
+			if (name !== null) collection.exitsByName.set(name, cursor);
+			if (collectExit) collectViewTransitionSurfaces(cursor, "exit", collection.plan.oldSurfaces, "committed");
+			for (let child = cursor.child; child !== null; child = child.sibling) collectDeletedViewTransitionFiber(child, collection, false);
+			return;
+		}
+		if ((cursor.subtreeFlags & 4096) === 0) return;
+		for (let child = cursor.child; child !== null; child = child.sibling) collectDeletedViewTransitionFiber(child, collection, collectExit);
+	}
+	function attributeQueuedHostUpdates(root, plan) {
+		let changed = null;
+		for (const entry of root.commitIndex) {
+			if ((entry.flags & 10) === 0) continue;
+			let sawPortal = false;
+			let boundary = null;
+			for (let parent = entry.return; parent !== null; parent = parent.return) {
+				if (parent.tag === 11) {
+					boundary = parent;
+					break;
+				}
+				if (parent.tag === 8) sawPortal = true;
+			}
+			if (boundary === null) plan.rootAffected = true;
+			else if (!sawPortal) (changed ??= /* @__PURE__ */ new Set()).add(boundary);
+		}
+		return changed;
+	}
+	function collectFinishedViewTransitions(node, placed, insideBoundary, ancestorLayoutChanged, collection) {
+		const { changedBoundaries, exitsByName, plan } = collection;
+		let layoutChanged = ancestorLayoutChanged;
+		for (let cursor = node; !layoutChanged && cursor !== null; cursor = cursor.sibling) if ((cursor.flags & 1) !== 0 && (cursor.alternate !== null || (cursor.flags & 16) !== 0)) layoutChanged = true;
+		for (let cursor = node; cursor !== null; cursor = cursor.sibling) {
+			const cursorPlaced = placed || (cursor.flags & 1) !== 0;
+			if (!(cursor.tag === 11 || (cursor.subtreeFlags & 4096) !== 0)) {
+				if (!insideBoundary && ((cursor.flags | cursor.subtreeFlags) & 175) !== 0) plan.rootAffected = true;
+				continue;
+			}
+			if (isStablyHiddenBoundary(cursor)) continue;
+			if (cursor.tag === 11) {
+				if (!cursorPlaced && ((cursor.flags | cursor.subtreeFlags) & 4) !== 0) continue;
+				if (cursorPlaced) {
+					const name = viewTransitionName(cursor);
+					const pairedExit = exitsByName.get(name);
+					if (pairedExit !== void 0) {
+						if (!insideBoundary) plan.rootAffected = true;
+						collectViewTransitionPair(plan, pairedExit, cursor);
+						exitsByName.delete(name);
+					} else if (cursor.alternate !== null) {
+						collectViewTransitionSurfaces(cursor.alternate, "update", plan.oldSurfaces, "committed", false);
+						collectViewTransitionSurfaces(cursor, "update", plan.newSurfaces, "finished", false);
+					} else {
+						if (!insideBoundary) plan.rootAffected = true;
+						collectViewTransitionSurfaces(cursor, "enter", plan.newSurfaces, "finished");
+					}
+					collectAppearingPairViewTransitions(cursor.child, collection);
+					continue;
+				}
+				const current = cursor.alternate ?? cursor;
+				const contentChanged = viewTransitionChangedOutsideNested(cursor, changedBoundaries);
+				if (contentChanged || layoutChanged) {
+					collectViewTransitionSurfaces(current, "update", plan.oldSurfaces, "committed", contentChanged);
+					collectViewTransitionSurfaces(cursor, "update", plan.newSurfaces, "finished", contentChanged);
+				}
+				collectFinishedViewTransitions(cursor.child, cursorPlaced, true, contentChanged || layoutChanged, collection);
+				continue;
+			}
+			if (cursor.tag !== 8) {
+				if (!insideBoundary && (cursor.flags & 175) !== 0) plan.rootAffected = true;
+				collectFinishedViewTransitions(cursor.child, cursorPlaced, insideBoundary, layoutChanged || (cursor.flags & 175) !== 0, collection);
+			}
+		}
+	}
+	function collectAppearingPairViewTransitions(node, collection) {
+		const { exitsByName, plan } = collection;
+		if (exitsByName.size === 0) return;
+		walkFiberForest(node, (cursor) => {
+			if (exitsByName.size === 0) return false;
+			if (cursor.tag === 8 || isStablyHiddenBoundary(cursor)) return false;
+			if (cursor.tag === 11) {
+				const name = explicitViewTransitionName(cursor);
+				if (name !== null) {
+					const pairedExit = exitsByName.get(name);
+					if (pairedExit !== void 0) {
+						collectViewTransitionPair(plan, pairedExit, cursor);
+						exitsByName.delete(name);
+					}
+				}
+			}
+			return true;
+		});
+	}
+	function collectViewTransitionPair(plan, oldBoundary, newBoundary) {
+		removeViewTransitionSurfaces(plan.oldSurfaces, oldBoundary);
+		collectViewTransitionSurfaces(oldBoundary, "share", plan.oldSurfaces, "committed");
+		collectViewTransitionSurfaces(newBoundary, "share", plan.newSurfaces, "finished");
+	}
+	function isHiddenBoundary(node) {
+		return node.tag === 10 && node.props.mode === "hidden";
+	}
+	function isStablyHiddenBoundary(node) {
+		if (!isHiddenBoundary(node)) return false;
+		const current = node.alternate;
+		return current === null || (current.memoizedProps ?? current.props).mode === "hidden";
+	}
+	function viewTransitionChangedOutsideNested(boundary, changedBoundaries) {
+		if ((boundary.flags & 175) !== 0) return true;
+		if (changedBoundaries?.has(boundary) === true) return true;
+		return subtreeChangedOutsideNested(boundary.child);
+	}
+	function subtreeChangedOutsideNested(node) {
+		for (let cursor = node; cursor !== null; cursor = cursor.sibling) {
+			if (cursor.tag === 8 || cursor.tag === 11) continue;
+			if ((cursor.flags & 175) !== 0) return true;
+			if ((cursor.subtreeFlags & 175) === 0) continue;
+			if (subtreeChangedOutsideNested(cursor.child)) return true;
+		}
+		return false;
+	}
+	function removeViewTransitionSurfaces(surfaces, boundary) {
+		for (let index = surfaces.length - 1; index >= 0; index -= 1) if (surfaces[index].boundary === boundary) surfaces.splice(index, 1);
+	}
+	function collectViewTransitionSurfaces(boundary, phase, surfaces, propsSource, mustAnimate = true) {
+		const className = viewTransitionClass(boundary.props, phase);
+		if (className === "none") return;
+		const name = viewTransitionName(boundary);
+		let index = 0;
+		walkFiberForest(boundary.child, (cursor) => {
+			if (cursor.tag === 8 || cursor.tag === 11) return false;
+			if (cursor.tag !== 1) return true;
+			if ((cursor.flags & 8192) === 0) {
+				surfaces.push({
+					boundary,
+					className,
+					instance: cursor.stateNode,
+					measurement: null,
+					mustAnimate,
+					name: index === 0 ? name : `${name}_${index}`,
+					phase,
+					props: viewTransitionSurfaceProps(cursor, propsSource),
+					skipped: false
+				});
+				index += 1;
+			}
+			return false;
+		});
+	}
+	function viewTransitionSurfaceProps(node, source) {
+		if (source === "committed") return node.committedProps ?? node.memoizedProps ?? node.props;
+		return node.memoizedProps ?? node.props;
+	}
+	function viewTransitionName(node) {
+		const props = node.props;
+		if (props.name !== void 0 && props.name !== "auto") return props.name;
+		const state = node.stateNode;
+		state.autoName ??= `fig-vt-${autoNameCounter++}`;
+		return state.autoName;
+	}
+	function explicitViewTransitionName(node) {
+		const name = node.props.name;
+		return name === void 0 || name === "auto" ? null : name;
+	}
+	function viewTransitionClass(props, phase) {
+		const viewTransitionProps = props;
+		const phaseClass = viewTransitionProps[phase];
+		const className = phaseClass === void 0 ? viewTransitionProps.default : phaseClass;
+		return className === void 0 || className === "auto" ? null : className;
+	}
+	function applyOldViewTransitionSurfaces(plan) {
+		const measure = host.measure;
+		for (const surface of plan.oldSurfaces) {
+			surface.measurement = measure?.(surface.instance) ?? null;
+			if (surface.phase === "exit" && surface.measurement !== null && !surface.measurement.inViewport) {
+				surface.skipped = true;
+				continue;
+			}
+			host.apply(surface.instance, surface.name, surface.className);
+		}
+	}
+	function resolveViewTransitionPlan(plan) {
+		const result = {
+			canceledNames: [],
+			cancelRootSnapshot: false
+		};
+		const measure = host.measure;
+		const oldByName = /* @__PURE__ */ new Map();
+		for (const surface of plan.oldSurfaces) if (!surface.skipped) oldByName.set(surface.name, surface);
+		let rootAffected = plan.rootAffected;
+		const newNames = /* @__PURE__ */ new Set();
+		for (const surface of plan.newSurfaces) {
+			newNames.add(surface.name);
+			const measurement = measure?.(surface.instance) ?? null;
+			if (surface.phase === "enter") {
+				if (measurement !== null && !measurement.inViewport) {
+					surface.skipped = true;
+					continue;
+				}
+				host.apply(surface.instance, surface.name, surface.className);
+				continue;
+			}
+			if (surface.phase === "update") {
+				const oldSurface = oldByName.get(surface.name);
+				const before = oldSurface?.measurement ?? null;
+				if (before !== null && measurement !== null) {
+					const moved = before.x !== measurement.x || before.y !== measurement.y || before.width !== measurement.width || before.height !== measurement.height;
+					if (!before.inViewport && !measurement.inViewport || !surface.mustAnimate && !moved) {
+						surface.skipped = true;
+						host.restore(surface.instance, surface.props);
+						if (oldSurface !== void 0) {
+							oldSurface.skipped = true;
+							result.canceledNames.push(surface.name);
+						}
+						continue;
+					}
+					if ((before.width !== measurement.width || before.height !== measurement.height) && !measurement.absolutelyPositioned) rootAffected = true;
+				}
+			}
+			host.apply(surface.instance, surface.name, surface.className);
+		}
+		for (const [name, surface] of oldByName) if (surface.phase === "update" && !newNames.has(name)) rootAffected = true;
+		result.cancelRootSnapshot = !rootAffected;
+		return result;
+	}
+	function restoreViewTransitionSurfaces(plan) {
+		const propsByInstance = /* @__PURE__ */ new Map();
+		for (const surface of plan.oldSurfaces) propsByInstance.set(surface.instance, surface.props);
+		for (const surface of plan.newSurfaces) propsByInstance.set(surface.instance, surface.props);
+		for (const [instance, props] of propsByInstance) host.restore(instance, props);
+	}
+	function participatingSurfaceNames(surfaces) {
+		const names = /* @__PURE__ */ new Set();
+		for (const surface of surfaces) if (!surface.skipped) names.add(surface.name);
+		return names;
+	}
+	function dispatchViewTransitionCallbacks(plan, signal) {
+		const groups = /* @__PURE__ */ new Map();
+		const collect = (surface) => {
+			if (surface.skipped) return;
+			const callback = surface.boundary.props.onTransition;
+			if (callback === void 0) return;
+			const group = groups.get(surface.boundary);
+			if (group === void 0) groups.set(surface.boundary, {
+				callback,
+				surfaces: [surface]
+			});
+			else group.surfaces.push(surface);
+		};
+		for (const surface of plan.newSurfaces) collect(surface);
+		for (const surface of plan.oldSurfaces) if (surface.phase === "exit") collect(surface);
+		if (groups.size === 0) return;
+		const oldNames = participatingSurfaceNames(plan.oldSurfaces);
+		const newNames = participatingSurfaceNames(plan.newSurfaces);
+		for (const { callback, surfaces: group } of groups.values()) {
+			const surfaces = group.map((surface) => {
+				const snapshots = {
+					old: oldNames.has(surface.name),
+					new: newNames.has(surface.name)
+				};
+				return host.createSurface?.(surface.instance, surface.name, snapshots) ?? { name: surface.name };
+			});
+			callback({
+				phase: group[0].phase,
+				surfaces,
+				types: plan.types
+			}, signal);
+		}
+	}
+	return {
+		name: "view-transitions",
+		viewTransitions: true,
+		suspend(rootIdentity, onReady) {
+			const root = rootIdentity;
+			return isEligible(root) && host.suspend?.(root.container, onReady) === true;
+		},
+		commit(context) {
+			const root = context.root;
+			const finishedWork = context.finishedWork;
+			const plan = preparePlan(root, finishedWork);
+			if (plan === null) return false;
+			let didRunMutation = false;
+			let didFinish = false;
+			let controller = null;
+			return host.commit(context.container, plan.types, () => applyOldViewTransitionSurfaces(plan), () => {
+				didRunMutation = true;
+				return context.runMutation(() => resolveViewTransitionPlan(plan)) ?? {
+					canceledNames: [],
+					cancelRootSnapshot: false
+				};
+			}, (active) => {
+				try {
+					restoreViewTransitionSurfaces(plan);
+				} finally {
+					if (didRunMutation) context.captureFinished();
+				}
+				if (active && !didFinish && controller === null) {
+					controller = new AbortController();
+					dispatchViewTransitionCallbacks(plan, controller.signal);
+				}
+			}, () => {
+				didFinish = true;
+				controller?.abort();
+			});
+		}
+	};
+}
+//#endregion
+export { createViewTransitionCommitCoordinator };
+
+//# sourceMappingURL=view-transitions.js.map