@generaltranslation/vue-extractor 0.0.0

package/dist/internal/script/replay.js

@@ -0,0 +1,1611 @@
+import { unwrapExpression } from "../utils.js";
+import { appendTemplatePath, recursiveTemplatePathSegment, unknownTemplatePathSegment } from "../templatePath.js";
+//#region src/internal/script/replay.ts
+/**
+* Creates the finite source-ordered identity analyzer used by script analysis.
+* Dependencies are injected so the replay evaluator remains one cohesive SCC
+* without creating a runtime import cycle back to the script orchestrator.
+*/
+function createReplayAnalysis({ ordinaryGlobalValues: ORDINARY_GLOBAL_VALUES, readonlyArrayTransforms: READONLY_ARRAY_TRANSFORMS, bindingReadsUnsafeMutableImport, collectFunctionReturnExpressions, collectPatternBindingNames, composeContainerWritePolicy, knownValueKey, readDefiniteArrayInteger, readResolvedMemberPath, readResolvedMemberProperty, readResolvedPropertyKey, readStaticFromScope, resolveCalledFunction, resolveComputedGetter, resolveKnownExpression }) {
+	const replayUnsafe = { type: "unsafe" };
+	/** Creates one fresh runtime container identity for source-ordered replay. */
+	function createReplayContainer(snapshot) {
+		return {
+			type: "container",
+			identity: {
+				escaped: false,
+				snapshot
+			},
+			writePolicy: "forward"
+		};
+	}
+	/** Returns a reference with the write behavior Vue applies to one wrapper. */
+	function wrapReplayContainer(value, wrapper) {
+		return {
+			type: "container",
+			identity: value.identity,
+			writePolicy: composeContainerWritePolicy(wrapper, value.writePolicy)
+		};
+	}
+	/** Applies a Vue proxy wrapper to a container, ref, or computed reference. */
+	function wrapReplayReference(value, wrapper) {
+		if (value.type === "container") return wrapReplayContainer(value, wrapper);
+		return {
+			...value,
+			writePolicy: composeContainerWritePolicy(wrapper, value.writePolicy)
+		};
+	}
+	/** Marks an escaped identity and every nested identity reachable through it. */
+	function markReplayContainerEscaped(value, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(value.identity)) return;
+		seen.add(value.identity);
+		value.identity.escaped = true;
+		const entries = value.identity.snapshot.kind === "array" ? value.identity.snapshot.entries : value.identity.snapshot.entries.values();
+		for (const entry of entries) {
+			if (entry?.type === "container") markReplayContainerEscaped(entry, seen);
+			if (entry?.type === "ref") markReplayRefEscaped(entry, seen);
+			if (entry?.type === "collection") markReplayCollectionEscaped(entry, seen);
+		}
+		if (value.identity.snapshot.kind === "object") {
+			const prototype = value.identity.snapshot.prototype;
+			if (prototype) markReplayContainerEscaped(prototype, seen);
+		}
+	}
+	/** Marks a ref and every container reachable through its current value unsafe. */
+	function markReplayRefEscaped(value, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(value.identity)) return;
+		seen.add(value.identity);
+		value.identity.escaped = true;
+		const current = value.identity.value;
+		if (current?.type === "container") markReplayContainerEscaped(current, seen);
+		if (current?.type === "ref") markReplayRefEscaped(current, seen);
+		if (current?.type === "collection") markReplayCollectionEscaped(current, seen);
+	}
+	/** Marks a Map or Set abstraction unsafe after an unmodelled escape. */
+	function markReplayCollectionEscaped(value, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(value.identity)) return;
+		seen.add(value.identity);
+		value.identity.escaped = true;
+		for (const entry of value.identity.entries.values()) {
+			if (entry.type === "container") markReplayContainerEscaped(entry, seen);
+			if (entry.type === "ref") markReplayRefEscaped(entry, seen);
+			if (entry.type === "collection") markReplayCollectionEscaped(entry, seen);
+		}
+	}
+	/** Marks any mutable replay value unsafe after an unsupported operation. */
+	function markReplayValueEscaped(value) {
+		if (value?.type === "container") markReplayContainerEscaped(value);
+		if (value?.type === "ref") markReplayRefEscaped(value);
+		if (value?.type === "collection") markReplayCollectionEscaped(value);
+		if (value?.type === "function") {
+			for (const captured of value.substitutions.values()) markReplayValueEscaped(captured);
+			for (const captured of value.boundArguments) markReplayValueEscaped(captured);
+		}
+	}
+	/** Reads a ref value through the proxy policy currently wrapping the ref. */
+	function readReplayRefValue(value) {
+		if (value.identity.escaped) return replayUnsafe;
+		const current = value.identity.value;
+		if (current?.type === "collection" || current?.type === "container" || current?.type === "ref" || current?.type === "computed") {
+			if (value.writePolicy === "readonly-deep") return wrapReplayReference(current, "readonly");
+		}
+		return current?.type === "leaf" ? {
+			...current,
+			exactSelection: true,
+			selectionKind: "ref"
+		} : current;
+	}
+	/** Applies Vue's deep readonly conversion to a value read through a proxy. */
+	function wrapReplayReadValue(value, policy) {
+		if (value && policy === "readonly-deep" && (value.type === "collection" || value.type === "computed" || value.type === "container" || value.type === "ref")) return wrapReplayReference(value, "readonly");
+		return value;
+	}
+	/** Evaluates a supported property getter against the current replay state. */
+	function evaluateReplayGetter(value, receiver, state, context) {
+		if (!context.allowGetterEffects) {
+			const body = value.getter.node.body;
+			if (body.type === "BlockStatement" && (body.body.length !== 1 || body.body[0]?.type !== "ReturnStatement")) return;
+			const returns = collectFunctionReturnExpressions(value.getter.node, value.getter.scope, state);
+			return returns.length === 1 ? evaluateReplayExpression(returns[0].node, returns[0].scope, state, {
+				...context,
+				substitutions: new Map(value.substitutions),
+				thisValue: receiver
+			}) : void 0;
+		}
+		const result = executeReplayFunction(value.getter, [], state, {
+			...context,
+			substitutions: new Map(value.substitutions),
+			thisValue: receiver
+		}, receiver);
+		return result.executed ? result.value : void 0;
+	}
+	/** Reads a child using prototype lookup and Vue proxy conversion rules. */
+	function readReplayContainerEntry(value, property, state, context, seen = /* @__PURE__ */ new Set(), receiver = value) {
+		if (value.identity.escaped || seen.has(value.identity)) return replayUnsafe;
+		const snapshot = value.identity.snapshot;
+		let entry;
+		if (snapshot.kind === "array") entry = /^(0|[1-9]\d*)$/.test(property) ? snapshot.entries[Number(property)] : void 0;
+		else if (snapshot.entries.has(property)) entry = snapshot.entries.get(property);
+		else if (snapshot.prototype) entry = readReplayContainerEntry(snapshot.prototype, property, state, context, new Set(seen).add(value.identity), receiver);
+		let fromGetter = false;
+		if (entry?.type === "getter") {
+			fromGetter = true;
+			entry = evaluateReplayGetter(entry, receiver, state, context);
+		}
+		if (entry?.type === "method") entry = {
+			...entry,
+			receiver
+		};
+		if (entry?.type === "leaf") entry = {
+			...entry,
+			exactSelection: true,
+			selectionKind: fromGetter ? "getter" : "member"
+		};
+		return wrapReplayReadValue(entry, value.writePolicy);
+	}
+	/** Lists the property names visible through a finite object prototype chain. */
+	function readReplayVisibleObjectKeys(value, seen = /* @__PURE__ */ new Set()) {
+		if (value.identity.escaped || value.identity.snapshot.kind !== "object" || seen.has(value.identity)) return;
+		const keys = value.identity.snapshot.prototype ? readReplayVisibleObjectKeys(value.identity.snapshot.prototype, new Set(seen).add(value.identity)) : /* @__PURE__ */ new Set();
+		if (!keys) return void 0;
+		for (const key of value.identity.snapshot.entries.keys()) keys.add(key);
+		return keys;
+	}
+	/** Lists every value a template can select from one finite container. */
+	function readReplayVisibleContainerEntries(value, state, context) {
+		if (value.identity.escaped) return void 0;
+		const snapshot = value.identity.snapshot;
+		if (snapshot.kind === "array") return snapshot.entries.map((entry, index) => [String(index), entry]);
+		const keys = readReplayVisibleObjectKeys(value);
+		if (!keys) return void 0;
+		const entries = [];
+		for (const key of keys) {
+			const entry = readReplayContainerEntry(value, key, state, context);
+			if (!entry) return void 0;
+			entries.push([key, entry]);
+		}
+		return entries;
+	}
+	/** Resolves whether a non-container value is definitely `<T>` at this point. */
+	function createReplayLeaf(node, scope, state) {
+		const expression = unwrapExpression(node) ?? node;
+		const known = resolveKnownExpression(expression, scope, state, /* @__PURE__ */ new Set());
+		const knownValue = known?.type === "component" || known?.type === "string" || known?.type === "vue-builtin" ? known : void 0;
+		if (known) return {
+			type: "leaf",
+			expression: {
+				node: expression,
+				scope
+			},
+			hasGT: known.type === "component" && known.name === "T",
+			knownValue
+		};
+		const primitive = readStaticFromScope(expression, scope, /* @__PURE__ */ new Set(), expression.end ?? Number.POSITIVE_INFINITY, state.analysis);
+		const ordinaryGlobal = expression.type === "Identifier" && !scope.getBinding(expression.name) && ORDINARY_GLOBAL_VALUES.has(expression.name);
+		return {
+			type: "leaf",
+			expression: {
+				node: expression,
+				scope
+			},
+			hasGT: primitive.ok || ordinaryGlobal ? false : void 0,
+			knownValue
+		};
+	}
+	/** Reads a statically named member chain from a replayed container. */
+	function evaluateReplayMember(node, scope, state, context) {
+		const object = evaluateReplayExpression(node.object, scope, state, context);
+		const property = readResolvedMemberProperty(node, scope, state);
+		if (property === void 0) return void 0;
+		if (object?.type === "unsafe") return object;
+		if (object?.type === "container") return readReplayContainerEntry(object, property, state, context);
+		if (property !== "value") return void 0;
+		if (object?.type === "ref") return readReplayRefValue(object);
+		if (object?.type === "computed") return evaluateReplayComputed(object, state, context);
+	}
+	/** Shallow-copies the enumerable own entries of one container reference. */
+	function copyReplayContainerEntries(value, state, context) {
+		if (value.identity.escaped) return void 0;
+		const snapshot = value.identity.snapshot;
+		if (snapshot.kind === "array") return {
+			kind: "array",
+			entries: snapshot.entries.map((_entry, index) => readReplayContainerEntry(value, String(index), state, context))
+		};
+		return {
+			kind: "object",
+			entries: new Map([...snapshot.entries.keys()].flatMap((key) => {
+				const entry = readReplayContainerEntry(value, key, state, context);
+				return entry ? [[key, entry]] : [];
+			}))
+		};
+	}
+	/** Evaluates one finite array literal without losing nested object identity. */
+	function evaluateReplayArray(node, scope, state, context) {
+		const entries = [];
+		for (const element of node.elements) {
+			if (!element) {
+				entries.push(void 0);
+				continue;
+			}
+			if (element.type === "SpreadElement") {
+				const spread = evaluateReplayExpression(element.argument, scope, state, context);
+				if (spread?.type === "unsafe") return spread;
+				if (spread?.type === "container" && spread.identity.escaped) return replayUnsafe;
+				if (spread?.type !== "container" || spread.identity.snapshot.kind !== "array") return;
+				const copied = copyReplayContainerEntries(spread, state, context);
+				if (!copied || copied.kind !== "array") return void 0;
+				entries.push(...copied.entries);
+				continue;
+			}
+			entries.push(evaluateReplayExpression(element, scope, state, context));
+		}
+		return createReplayContainer({
+			kind: "array",
+			entries
+		});
+	}
+	/** Evaluates one finite object literal with JavaScript shallow-spread semantics. */
+	function evaluateReplayObject(node, scope, state, context) {
+		const entries = /* @__PURE__ */ new Map();
+		const setters = /* @__PURE__ */ new Map();
+		for (const property of node.properties) {
+			if (property.type === "SpreadElement") {
+				const spread = evaluateReplayExpression(property.argument, scope, state, context);
+				if (spread?.type === "unsafe") return spread;
+				if (spread?.type === "container" && spread.identity.escaped) return replayUnsafe;
+				if (spread?.type !== "container" || spread.identity.snapshot.kind !== "object") return;
+				const copied = copyReplayContainerEntries(spread, state, context);
+				if (!copied || copied.kind !== "object") return void 0;
+				for (const [key, value] of copied.entries) entries.set(key, value);
+				continue;
+			}
+			if (property.type === "ObjectMethod" && property.kind === "get") {
+				const key = readResolvedPropertyKey(property, scope, state);
+				if (key === void 0) return void 0;
+				entries.set(key, {
+					type: "getter",
+					getter: {
+						node: property,
+						scope: state.scopes.get(property) ?? scope
+					},
+					substitutions: new Map(context.substitutions)
+				});
+				continue;
+			}
+			if (property.type === "ObjectMethod" && property.kind === "method") {
+				const key = readResolvedPropertyKey(property, scope, state);
+				if (key === void 0) return void 0;
+				entries.set(key, {
+					type: "method",
+					callable: {
+						node: property,
+						scope: state.scopes.get(property) ?? scope
+					},
+					substitutions: new Map(context.substitutions)
+				});
+				continue;
+			}
+			if (property.type === "ObjectMethod" && property.kind === "set") {
+				const key = readResolvedPropertyKey(property, scope, state);
+				if (key === void 0) return void 0;
+				setters.set(key, {
+					type: "method",
+					callable: {
+						node: property,
+						scope: state.scopes.get(property) ?? scope
+					},
+					substitutions: new Map(context.substitutions)
+				});
+				continue;
+			}
+			if (property.type !== "ObjectProperty") return void 0;
+			const key = readResolvedPropertyKey(property, scope, state);
+			if (key === void 0) return void 0;
+			const value = evaluateReplayExpression(property.value, scope, state, context);
+			if (!value) return void 0;
+			entries.set(key, value);
+		}
+		return createReplayContainer({
+			kind: "object",
+			entries,
+			setters
+		});
+	}
+	/** Evaluates a computed getter against the current, not captured, bindings. */
+	function evaluateReplayComputed(value, state, context) {
+		const returns = collectFunctionReturnExpressions(value.getter.node, value.getter.scope, state);
+		if (returns.length !== 1) return void 0;
+		const result = evaluateReplayExpression(returns[0].node, returns[0].scope, state, context);
+		return result && (result.type === "collection" || result.type === "container" || result.type === "ref" || result.type === "computed") ? wrapReplayReference(result, value.writePolicy === "readonly-deep" ? "readonly" : value.writePolicy === "readonly-shallow" ? "shallow-readonly" : "unref") : result;
+	}
+	/** Evaluates an expression while applying its supported direct side effects. */
+	function executeReplayExpression(node, scope, state, context) {
+		const expression = unwrapExpression(node);
+		if (expression?.type === "UnaryExpression" && expression.operator === "delete" && (expression.argument.type === "MemberExpression" || expression.argument.type === "OptionalMemberExpression")) return applyReplayMemberDelete(expression.argument, scope, state, context) ? createReplayLeaf(expression, scope, state) : void 0;
+		if (expression?.type !== "AssignmentExpression") return evaluateReplayExpression(node, scope, state, context);
+		if (expression.operator !== "=") return void 0;
+		const replacement = evaluateReplayExpression(expression.right, scope, state, context);
+		if (expression.left.type === "Identifier") {
+			const binding = scope.getBinding(expression.left.name);
+			if (binding) {
+				if (replacement?.type === "unsafe") context.unsafeBindings.add(binding);
+				else context.unsafeBindings.delete(binding);
+				context.values.set(binding, replacement);
+			}
+			return replacement;
+		}
+		if (expression.left.type === "MemberExpression" || expression.left.type === "OptionalMemberExpression") return applyReplayMemberAssignment(expression.left, expression.right, scope, state, context) ? replacement : void 0;
+	}
+	/** Executes one finite local function body with captured identities intact. */
+	function executeReplayFunction(callable, arguments_, state, context, thisValue = context.thisValue) {
+		if (state.activeReplayFunctions.has(callable.node)) return {
+			executed: false,
+			value: void 0
+		};
+		const functionScope = state.scopes.get(callable.node) ?? callable.scope;
+		const substitutions = new Map(context.substitutions);
+		for (const [index, parameter] of callable.node.params.entries()) {
+			const name = parameter.type === "Identifier" ? parameter.name : parameter.type === "RestElement" && parameter.argument.type === "Identifier" ? parameter.argument.name : void 0;
+			if (!name) return {
+				executed: false,
+				value: void 0
+			};
+			const binding = functionScope.getBinding(name);
+			if (!binding) return {
+				executed: false,
+				value: void 0
+			};
+			if (parameter.type === "RestElement") {
+				substitutions.set(binding, createReplayContainer({
+					kind: "array",
+					entries: arguments_.slice(index)
+				}));
+				break;
+			}
+			const argument = arguments_[index];
+			if (!argument) return {
+				executed: false,
+				value: void 0
+			};
+			substitutions.set(binding, argument);
+		}
+		const localContext = {
+			...context,
+			substitutions,
+			thisValue
+		};
+		state.activeReplayFunctions.add(callable.node);
+		try {
+			if (callable.node.body.type !== "BlockStatement") return {
+				executed: true,
+				value: executeReplayExpression(callable.node.body, functionScope, state, localContext)
+			};
+			const bodyPath = state.paths.get(callable.node.body);
+			const statements = bodyPath?.isBlockStatement() ? bodyPath.get("body") : void 0;
+			if (!statements || !Array.isArray(statements)) return {
+				executed: false,
+				value: void 0
+			};
+			for (const statement of statements) {
+				if (statement.isReturnStatement()) return {
+					executed: true,
+					value: statement.node.argument ? executeReplayExpression(statement.node.argument, statement.scope, state, localContext) : void 0
+				};
+				if (!statement.isVariableDeclaration() && !statement.isExpressionStatement()) return {
+					executed: false,
+					value: void 0
+				};
+				replayContainerStatement(statement, state, localContext);
+			}
+			return {
+				executed: true,
+				value: void 0
+			};
+		} finally {
+			state.activeReplayFunctions.delete(callable.node);
+		}
+	}
+	/** Reads one exact callback return for array transform replay. */
+	function evaluateReplayCallback(callback, argument, source, state, context) {
+		const result = executeReplayFunction(callback, [argument], state, context);
+		if (!result.executed) {
+			invalidateReplayFunctionCaptures(callback.node, state, context);
+			markReplayContainerEscaped(source);
+			return;
+		}
+		return result.value;
+	}
+	/** Detects writes hidden inside an expression-bodied callback. */
+	function replayExpressionHasWrites(node, state) {
+		const path = state.paths.get(node);
+		if (!path) return true;
+		let writes = false;
+		const mark = (candidate) => {
+			writes = true;
+			candidate.stop();
+		};
+		path.traverse({
+			AssignmentExpression: mark,
+			UpdateExpression: mark,
+			UnaryExpression(candidate) {
+				if (candidate.node.operator === "delete") mark(candidate);
+			}
+		});
+		return writes;
+	}
+	/** Applies a finite array copy transform at the exact call position. */
+	function evaluateReplayArrayTransform(value, method, call, scope, state, context) {
+		if (value.identity.escaped) return replayUnsafe;
+		if (value.identity.snapshot.kind !== "array") return void 0;
+		if (call.arguments.some((argument) => argument.type === "ArgumentPlaceholder" || argument.type === "SpreadElement")) return;
+		const copied = copyReplayContainerEntries(value, state, context);
+		if (!copied || copied.kind !== "array") return void 0;
+		const entries = copied.entries;
+		const argumentNode = (index) => {
+			const argument = call.arguments[index];
+			return argument && argument.type !== "ArgumentPlaceholder" ? argument : void 0;
+		};
+		if (method === "slice") {
+			const start = readDefiniteArrayInteger(argumentNode(0), 0, scope, state);
+			const end = readDefiniteArrayInteger(argumentNode(1), entries.length, scope, state);
+			return start === void 0 || end === void 0 ? void 0 : createReplayContainer({
+				kind: "array",
+				entries: entries.slice(start, end)
+			});
+		}
+		if (method === "concat") {
+			for (const argument of call.arguments) {
+				const item = evaluateReplayExpression(argument, scope, state, context);
+				if (!item) return void 0;
+				if (item.type === "container" && item.identity.snapshot.kind === "array") {
+					const flattened = copyReplayContainerEntries(item, state, context);
+					if (!flattened || flattened.kind !== "array") return void 0;
+					entries.push(...flattened.entries);
+				} else entries.push(item);
+			}
+			return createReplayContainer({
+				kind: "array",
+				entries
+			});
+		}
+		if (method === "map") {
+			const callbackNode = argumentNode(0);
+			const callback = callbackNode ? resolveCalledFunction(callbackNode, scope, state, /* @__PURE__ */ new Set()) : void 0;
+			if (!callback) return void 0;
+			const mapped = [];
+			for (const entry of entries) {
+				if (!entry) {
+					mapped.push(void 0);
+					continue;
+				}
+				const result = evaluateReplayCallback(callback, entry, value, state, context);
+				if (!result) return void 0;
+				mapped.push(result);
+			}
+			return createReplayContainer({
+				kind: "array",
+				entries: mapped
+			});
+		}
+		if (method === "toSpliced") {
+			const start = readDefiniteArrayInteger(argumentNode(0), 0, scope, state);
+			const deleteCount = readDefiniteArrayInteger(argumentNode(1), call.arguments.length === 0 ? 0 : call.arguments.length === 1 ? entries.length : 0, scope, state);
+			if (start === void 0 || deleteCount === void 0) return void 0;
+			const inserted = [];
+			for (const argument of call.arguments.slice(2)) {
+				const item = evaluateReplayExpression(argument, scope, state, context);
+				if (!item) return void 0;
+				inserted.push(item);
+			}
+			entries.splice(start, Math.max(0, deleteCount), ...inserted);
+			return createReplayContainer({
+				kind: "array",
+				entries
+			});
+		}
+		if (method === "toReversed") return createReplayContainer({
+			kind: "array",
+			entries: entries.reverse()
+		});
+		if (method === "toSorted") return entries.length <= 1 ? createReplayContainer({
+			kind: "array",
+			entries
+		}) : void 0;
+		if (method === "with") {
+			const index = readDefiniteArrayInteger(argumentNode(0), 0, scope, state);
+			const replacement = argumentNode(1);
+			if (index === void 0 || !replacement) return void 0;
+			const normalized = index < 0 ? entries.length + index : index;
+			if (normalized < 0 || normalized >= entries.length) return void 0;
+			const item = evaluateReplayExpression(replacement, scope, state, context);
+			if (!item) return void 0;
+			entries[normalized] = item;
+			return createReplayContainer({
+				kind: "array",
+				entries
+			});
+		}
+	}
+	/** Mutates one replayed array when the built-in operation is deterministic. */
+	function applyReplayArrayMutation(value, method, call, scope, state, context) {
+		if (value.identity.snapshot.kind !== "array") return false;
+		if (value.writePolicy !== "forward") return true;
+		if (call.arguments.some((argument) => argument.type === "ArgumentPlaceholder" || argument.type === "SpreadElement")) {
+			markReplayContainerEscaped(value);
+			return false;
+		}
+		const entries = value.identity.snapshot.entries;
+		const evaluated = call.arguments.map((argument) => evaluateReplayExpression(argument, scope, state, context));
+		if (evaluated.some((entry) => !entry)) {
+			markReplayContainerEscaped(value);
+			return false;
+		}
+		const items = evaluated;
+		if (method === "pop") entries.pop();
+		else if (method === "shift") entries.shift();
+		else if (method === "push") entries.push(...items);
+		else if (method === "unshift") entries.unshift(...items);
+		else if (method === "splice") {
+			const first = call.arguments[0];
+			const second = call.arguments[1];
+			const start = readDefiniteArrayInteger(first, 0, scope, state);
+			const deleteCount = readDefiniteArrayInteger(second, call.arguments.length === 0 ? 0 : call.arguments.length === 1 ? entries.length : 0, scope, state);
+			if (start === void 0 || deleteCount === void 0) {
+				markReplayContainerEscaped(value);
+				return false;
+			}
+			entries.splice(start, Math.max(0, deleteCount), ...items.slice(2));
+		} else return false;
+		return true;
+	}
+	/** Evaluates known wrappers, transforms, and mutators in source order. */
+	function evaluateReplayCall(node, scope, state, context) {
+		const wrapper = resolveKnownExpression(node.callee, scope, state, /* @__PURE__ */ new Set());
+		const first = node.arguments[0];
+		if (wrapper?.type === "container-wrapper" && first && first.type !== "ArgumentPlaceholder" && first.type !== "SpreadElement") {
+			const value = evaluateReplayExpression(first, scope, state, context);
+			if (value?.type === "unsafe") return value;
+			if (wrapper.kind === "unref") {
+				if (value?.type === "ref") return readReplayRefValue(value);
+				if (value?.type === "computed") return evaluateReplayComputed(value, state, context);
+				return value;
+			}
+			return value && (value.type === "container" || value.type === "collection" || value.type === "ref" || value.type === "computed") ? wrapReplayReference(value, wrapper.kind) : void 0;
+		}
+		if (wrapper?.type === "identity" && first && first.type !== "ArgumentPlaceholder" && first.type !== "SpreadElement") return evaluateReplayExpression(first, scope, state, context);
+		if (wrapper?.type === "vue-wrapper" && wrapper.kind === "ref") return {
+			type: "ref",
+			identity: {
+				escaped: false,
+				value: first && first.type !== "ArgumentPlaceholder" && first.type !== "SpreadElement" ? evaluateReplayExpression(first, scope, state, context) : createReplayLeaf(node, scope, state)
+			},
+			writePolicy: "forward"
+		};
+		if (wrapper?.type === "vue-wrapper" && wrapper.kind === "computed") {
+			const getter = first && first.type !== "ArgumentPlaceholder" && first.type !== "SpreadElement" ? resolveComputedGetter(first, scope, state) : void 0;
+			return getter ? {
+				type: "computed",
+				getter,
+				writePolicy: "forward"
+			} : void 0;
+		}
+		if (wrapper?.type === "hook") return createReplayLeaf(node, scope, state);
+		const calleePath = readResolvedMemberPath(node.callee, scope, state);
+		if (calleePath === "Array.from" && !scope.getBinding("Array")) {
+			if (node.arguments.length > 1 || !first || first.type === "ArgumentPlaceholder" || first.type === "SpreadElement") return;
+			const source = evaluateReplayExpression(first, scope, state, context);
+			if (source?.type === "unsafe") return source;
+			if (source?.type === "collection") {
+				if (source.identity.escaped) return replayUnsafe;
+				if (source.identity.kind === "map" && source.iteration === "entries") return;
+				return createReplayContainer({
+					kind: "array",
+					entries: [...source.identity.entries.values()]
+				});
+			}
+			if (source?.type !== "container" || source.identity.snapshot.kind !== "array") return;
+			if (source.identity.escaped) return replayUnsafe;
+			const copied = copyReplayContainerEntries(source, state, context);
+			return copied?.kind === "array" ? createReplayContainer(copied) : void 0;
+		}
+		if (calleePath === "Object.assign" && !scope.getBinding("Object")) {
+			if (!first || first.type === "ArgumentPlaceholder" || first.type === "SpreadElement") return;
+			const target = evaluateReplayExpression(first, scope, state, context);
+			if (target?.type !== "container" || target.identity.snapshot.kind !== "object") return;
+			if (target.writePolicy !== "forward") return target;
+			for (const argument of node.arguments.slice(1)) {
+				if (argument.type === "ArgumentPlaceholder" || argument.type === "SpreadElement") {
+					markReplayContainerEscaped(target);
+					return;
+				}
+				const source = evaluateReplayExpression(argument, scope, state, context);
+				if (source?.type === "unsafe") {
+					markReplayContainerEscaped(target);
+					return target;
+				}
+				if (source?.type !== "container" || source.identity.snapshot.kind !== "object") {
+					markReplayContainerEscaped(target);
+					return;
+				}
+				if (source.identity.escaped) {
+					markReplayContainerEscaped(target);
+					return target;
+				}
+				const copied = copyReplayContainerEntries(source, state, context);
+				if (!copied || copied.kind !== "object") return void 0;
+				for (const [key, value] of copied.entries) target.identity.snapshot.entries.set(key, value);
+			}
+			return target;
+		}
+		if (calleePath === "Object.create" && !scope.getBinding("Object")) {
+			if (!first || first.type === "ArgumentPlaceholder" || first.type === "SpreadElement") return;
+			const prototype = evaluateReplayExpression(first, scope, state, context);
+			if (prototype?.type !== "container" || prototype.identity.snapshot.kind !== "object") return;
+			return createReplayContainer({
+				kind: "object",
+				entries: /* @__PURE__ */ new Map(),
+				prototype
+			});
+		}
+		if (calleePath === "Object.setPrototypeOf" && !scope.getBinding("Object")) {
+			const prototypeNode = node.arguments[1];
+			if (!first || first.type === "ArgumentPlaceholder" || first.type === "SpreadElement" || !prototypeNode || prototypeNode.type === "ArgumentPlaceholder" || prototypeNode.type === "SpreadElement") return;
+			const target = evaluateReplayExpression(first, scope, state, context);
+			const prototype = evaluateReplayExpression(prototypeNode, scope, state, context);
+			if (target?.type !== "container" || target.identity.snapshot.kind !== "object" || target.writePolicy !== "forward" || prototype?.type !== "container" || prototype.identity.snapshot.kind !== "object") return;
+			target.identity.snapshot.prototype = prototype;
+			return target;
+		}
+		const replayCallee = evaluateReplayExpression(node.callee, scope, state, context);
+		if (replayCallee?.type === "leaf" && (replayCallee.knownValue?.type === "string" || replayCallee.expression.node.type === "Identifier" && !replayCallee.expression.scope.getBinding(replayCallee.expression.node.name) && ORDINARY_GLOBAL_VALUES.has(replayCallee.expression.node.name))) return {
+			type: "leaf",
+			expression: {
+				node,
+				scope
+			},
+			hasGT: false
+		};
+		if (replayCallee?.type === "function") {
+			const arguments_ = [];
+			for (const argument of node.arguments) {
+				if (argument.type === "ArgumentPlaceholder" || argument.type === "SpreadElement") {
+					markReplayValueEscaped(replayCallee);
+					return;
+				}
+				const value = evaluateReplayExpression(argument, scope, state, context);
+				if (!value) {
+					markReplayValueEscaped(replayCallee);
+					return;
+				}
+				arguments_.push(value);
+			}
+			const result = executeReplayFunction(replayCallee.callable, [...replayCallee.boundArguments, ...arguments_], state, {
+				...context,
+				substitutions: new Map(replayCallee.substitutions)
+			}, replayCallee.thisValue);
+			if (!result.executed) {
+				markReplayValueEscaped(replayCallee);
+				for (const argument of arguments_) markReplayValueEscaped(argument);
+				return;
+			}
+			return result.value ?? createReplayLeaf(node, scope, state);
+		}
+		if (replayCallee?.type === "method" && replayCallee.receiver) {
+			const arguments_ = [];
+			for (const argument of node.arguments) {
+				if (argument.type === "ArgumentPlaceholder" || argument.type === "SpreadElement") {
+					markReplayContainerEscaped(replayCallee.receiver);
+					return;
+				}
+				const value = evaluateReplayExpression(argument, scope, state, context);
+				if (!value) {
+					markReplayContainerEscaped(replayCallee.receiver);
+					return;
+				}
+				arguments_.push(value);
+			}
+			const result = executeReplayFunction(replayCallee.callable, arguments_, state, {
+				...context,
+				substitutions: new Map(replayCallee.substitutions)
+			}, replayCallee.receiver);
+			if (!result.executed) {
+				markReplayContainerEscaped(replayCallee.receiver);
+				return;
+			}
+			return result.value ?? createReplayLeaf(node, scope, state);
+		}
+		const localFunction = resolveCalledFunction(node.callee, scope, state, /* @__PURE__ */ new Set());
+		if (localFunction) {
+			const arguments_ = [];
+			for (const argument of node.arguments) {
+				if (argument.type === "ArgumentPlaceholder" || argument.type === "SpreadElement") {
+					invalidateReplayFunctionCaptures(localFunction.node, state, context);
+					return;
+				}
+				const value = evaluateReplayExpression(argument, scope, state, context);
+				if (!value) {
+					invalidateReplayFunctionCaptures(localFunction.node, state, context);
+					return;
+				}
+				arguments_.push(value);
+			}
+			const result = executeReplayFunction(localFunction, arguments_, state, context);
+			if (result.executed) return result.value ?? createReplayLeaf(node, scope, state);
+			for (const argument of arguments_) markReplayValueEscaped(argument);
+			invalidateReplayFunctionCaptures(localFunction.node, state, context);
+			return;
+		}
+		const callee = unwrapExpression(node.callee);
+		if (callee?.type === "MemberExpression" || callee?.type === "OptionalMemberExpression") {
+			const value = evaluateReplayExpression(callee.object, scope, state, context);
+			const method = readResolvedMemberProperty(callee, scope, state);
+			if (value?.type === "collection" && method) {
+				if (value.identity.escaped) return replayUnsafe;
+				if (method === "values") return {
+					...value,
+					iteration: "values"
+				};
+				const firstArgument = node.arguments[0];
+				const keyValue = firstArgument && firstArgument.type !== "ArgumentPlaceholder" && firstArgument.type !== "SpreadElement" ? evaluateReplayExpression(firstArgument, scope, state, context) : void 0;
+				const key = keyValue ? replayCollectionKey(keyValue, state) : void 0;
+				if (method === "get" && value.identity.kind === "map") {
+					const entry = key === void 0 ? void 0 : value.identity.entries.get(key);
+					return entry?.type === "leaf" ? {
+						...entry,
+						exactSelection: true,
+						selectionKind: "collection"
+					} : entry;
+				}
+				if (method === "set" && value.identity.kind === "map") {
+					if (value.writePolicy !== "forward") return value;
+					const next = node.arguments[1];
+					const entry = next && next.type !== "ArgumentPlaceholder" && next.type !== "SpreadElement" ? evaluateReplayExpression(next, scope, state, context) : void 0;
+					if (key === void 0 || !entry) {
+						markReplayCollectionEscaped(value);
+						return;
+					}
+					value.identity.entries.set(key, entry);
+					const templateKey = keyValue ? replayCollectionTemplateKey(keyValue, context, state) : void 0;
+					if (templateKey !== void 0) value.identity.templateKeys.set(key, templateKey);
+					return value;
+				}
+				if (method === "add" && value.identity.kind === "set" && keyValue) {
+					if (value.writePolicy !== "forward") return value;
+					value.identity.entries.set(key ?? `entry:${value.identity.entries.size}`, keyValue);
+					return value;
+				}
+				if (method === "delete" && key !== void 0) {
+					if (value.writePolicy !== "forward") return createReplayLeaf(node, scope, state);
+					value.identity.entries.delete(key);
+					value.identity.templateKeys.delete(key);
+					return createReplayLeaf(node, scope, state);
+				}
+				markReplayCollectionEscaped(value);
+				return;
+			}
+			if (value?.type === "container" && method) {
+				const transformed = evaluateReplayArrayTransform(value, method, node, scope, state, context);
+				if (transformed) return transformed;
+				const callbackNode = node.arguments[0];
+				const callback = callbackNode && callbackNode.type !== "ArgumentPlaceholder" && callbackNode.type !== "SpreadElement" ? resolveCalledFunction(callbackNode, scope, state, /* @__PURE__ */ new Set()) : void 0;
+				if (callback && method === "forEach" && value.identity.snapshot.kind === "array") {
+					for (const entry of value.identity.snapshot.entries) {
+						if (!entry) continue;
+						if (!executeReplayFunction(callback, [entry], state, context).executed) {
+							invalidateReplayFunctionCaptures(callback.node, state, context);
+							markReplayContainerEscaped(value);
+							return;
+						}
+					}
+					return createReplayLeaf(node, scope, state);
+				}
+				if (callback && [
+					"every",
+					"filter",
+					"find",
+					"findIndex",
+					"findLast",
+					"findLastIndex",
+					"flatMap",
+					"forEach",
+					"reduce",
+					"reduceRight",
+					"some"
+				].includes(method)) {
+					invalidateReplayFunctionCaptures(callback.node, state, context);
+					const body = callback.node.body;
+					if (body.type !== "BlockStatement" && replayExpressionHasWrites(body, state) || body.type === "BlockStatement" && body.body.some((statement) => statement.type !== "ReturnStatement")) markReplayContainerEscaped(value);
+				}
+				if ([
+					"pop",
+					"push",
+					"shift",
+					"splice",
+					"unshift"
+				].includes(method) && applyReplayArrayMutation(value, method, node, scope, state, context)) return createReplayLeaf(node, scope, state);
+				if (!READONLY_ARRAY_TRANSFORMS.has(method)) markReplayContainerEscaped(value);
+				return;
+			}
+		}
+		for (const argument of node.arguments) {
+			if (argument.type === "ArgumentPlaceholder" || argument.type === "SpreadElement") continue;
+			const value = evaluateReplayExpression(argument, scope, state, context);
+			if (value?.type === "container") markReplayContainerEscaped(value);
+			if (value?.type === "ref") markReplayRefEscaped(value);
+			if (value?.type === "collection") markReplayCollectionEscaped(value);
+		}
+	}
+	/** Produces a stable key for the finite Map/Set values the replay supports. */
+	function replayCollectionKey(value, state) {
+		if (value.type === "leaf") {
+			if (value.knownValue) return knownValueKey(value.knownValue);
+			const primitive = readStaticFromScope(value.expression.node, value.expression.scope, /* @__PURE__ */ new Set(), value.expression.node.end ?? Number.POSITIVE_INFINITY, state.analysis);
+			return primitive.ok ? `${typeof primitive.value}:${String(primitive.value)}` : void 0;
+		}
+		if (value.type !== "container" && value.type !== "ref" && value.type !== "collection") return;
+		const identity = value.identity;
+		const existing = state.replayIdentityKeys.get(identity);
+		if (existing) return existing;
+		const key = `identity:${state.nextReplayIdentityKey++}`;
+		state.replayIdentityKeys.set(identity, key);
+		return key;
+	}
+	/** Names a collection key when the template can reference the same binding. */
+	function replayCollectionTemplateKey(value, context, state) {
+		if (value.type === "leaf") {
+			const primitive = readStaticFromScope(value.expression.node, value.expression.scope, /* @__PURE__ */ new Set(), value.expression.node.end ?? Number.POSITIVE_INFINITY, state.analysis);
+			if (primitive.ok && (typeof primitive.value === "string" || typeof primitive.value === "number")) return String(primitive.value);
+			return readResolvedMemberPath(value.expression.node, value.expression.scope, state);
+		}
+		if (!("identity" in value)) return void 0;
+		for (const [binding, candidate] of context.values) if (candidate && candidate.type === value.type && "identity" in candidate && candidate.identity === value.identity) return binding.identifier.name;
+	}
+	/** Evaluates finite Map, Set, and transparent Proxy constructors. */
+	function evaluateReplayNewExpression(node, scope, state, context) {
+		const callee = unwrapExpression(node.callee);
+		if (callee?.type !== "Identifier") return;
+		const localBinding = scope.getBinding(callee.name);
+		if (localBinding) {
+			const declaration = localBinding.path.node;
+			const classNode = declaration.type === "ClassDeclaration" || declaration.type === "ClassExpression" ? declaration : declaration.type === "VariableDeclarator" && declaration.init?.type === "ClassExpression" ? declaration.init : void 0;
+			if (!classNode || classNode.superClass || classNode.decorators?.length) return;
+			const prototypeEntries = /* @__PURE__ */ new Map();
+			const prototypeSetters = /* @__PURE__ */ new Map();
+			const instanceEntries = /* @__PURE__ */ new Map();
+			const instance = createReplayContainer({
+				kind: "object",
+				entries: instanceEntries,
+				prototype: createReplayContainer({
+					kind: "object",
+					entries: prototypeEntries,
+					setters: prototypeSetters
+				})
+			});
+			const instanceContext = {
+				...context,
+				thisValue: instance
+			};
+			let constructor;
+			for (const member of classNode.body.body) {
+				if ("decorators" in member && member.decorators?.length) return void 0;
+				if (member.type === "ClassProperty" && !member.static) {
+					if (!member.value) continue;
+					const key = readResolvedPropertyKey(member, scope, state);
+					if (key === void 0) return void 0;
+					const value = evaluateReplayExpression(member.value, state.scopes.get(member.value) ?? scope, state, instanceContext);
+					if (!value) return void 0;
+					instanceEntries.set(key, value);
+					continue;
+				}
+				if (member.type !== "ClassMethod" || member.static) continue;
+				if (member.kind === "constructor") {
+					constructor = {
+						node: member,
+						scope: state.scopes.get(member) ?? scope
+					};
+					continue;
+				}
+				const key = readResolvedPropertyKey(member, scope, state);
+				if (key === void 0) return void 0;
+				if (member.kind === "get") prototypeEntries.set(key, {
+					type: "getter",
+					getter: {
+						node: member,
+						scope: state.scopes.get(member) ?? scope
+					},
+					substitutions: new Map(context.substitutions)
+				});
+				else if (member.kind === "method") prototypeEntries.set(key, {
+					type: "method",
+					callable: {
+						node: member,
+						scope: state.scopes.get(member) ?? scope
+					},
+					substitutions: new Map(context.substitutions)
+				});
+				else if (member.kind === "set") prototypeSetters.set(key, {
+					type: "method",
+					callable: {
+						node: member,
+						scope: state.scopes.get(member) ?? scope
+					},
+					substitutions: new Map(context.substitutions)
+				});
+			}
+			if (!constructor) return instance;
+			const arguments_ = [];
+			for (const argument of node.arguments) {
+				if (argument.type === "ArgumentPlaceholder" || argument.type === "SpreadElement") return;
+				const value = evaluateReplayExpression(argument, scope, state, context);
+				if (!value) return void 0;
+				arguments_.push(value);
+			}
+			const result = executeReplayFunction(constructor, arguments_, state, instanceContext, instance);
+			if (!result.executed) {
+				markReplayContainerEscaped(instance);
+				return;
+			}
+			return result.value?.type === "container" ? result.value : instance;
+		}
+		const first = node.arguments[0];
+		if (callee.name === "Map" || callee.name === "Set") {
+			const entries = /* @__PURE__ */ new Map();
+			const templateKeys = /* @__PURE__ */ new Map();
+			if (first && first.type !== "ArgumentPlaceholder" && first.type !== "SpreadElement") {
+				const source = evaluateReplayExpression(first, scope, state, context);
+				if (source?.type !== "container" || source.identity.snapshot.kind !== "array") return;
+				const copied = copyReplayContainerEntries(source, state, context);
+				if (!copied || copied.kind !== "array") return void 0;
+				for (const [index, item] of copied.entries.entries()) {
+					if (!item) continue;
+					if (callee.name === "Set") {
+						const key = replayCollectionKey(item, state) ?? `index:${index}`;
+						entries.set(key, item);
+						const templateKey = replayCollectionTemplateKey(item, context, state);
+						if (templateKey !== void 0) templateKeys.set(key, templateKey);
+						continue;
+					}
+					if (item.type !== "container" || item.identity.snapshot.kind !== "array") return;
+					const keyValue = readReplayContainerEntry(item, "0", state, context);
+					const mapValue = readReplayContainerEntry(item, "1", state, context);
+					if (!keyValue || !mapValue) return void 0;
+					const key = replayCollectionKey(keyValue, state);
+					if (key === void 0) return void 0;
+					entries.set(key, mapValue);
+					const templateKey = replayCollectionTemplateKey(keyValue, context, state);
+					if (templateKey !== void 0) templateKeys.set(key, templateKey);
+				}
+			}
+			return {
+				type: "collection",
+				identity: {
+					entries,
+					escaped: false,
+					kind: callee.name === "Map" ? "map" : "set",
+					templateKeys
+				},
+				iteration: callee.name === "Map" ? "entries" : "values",
+				writePolicy: "forward"
+			};
+		}
+		if (callee.name !== "Proxy" || !first || first.type === "ArgumentPlaceholder" || first.type === "SpreadElement") return;
+		const target = evaluateReplayExpression(first, scope, state, context);
+		const handlerNode = node.arguments[1];
+		if (!handlerNode || handlerNode.type === "ArgumentPlaceholder" || handlerNode.type === "SpreadElement") return;
+		const handler = unwrapExpression(handlerNode);
+		if (handler?.type !== "ObjectExpression") return void 0;
+		if (handler.properties.length === 0) return target;
+		const getProperty = handler.properties.find((property) => property.type === "ObjectMethod" && readResolvedPropertyKey(property, scope, state) === "get");
+		if (getProperty?.type !== "ObjectMethod") return void 0;
+		const returns = collectFunctionReturnExpressions(getProperty, scope, state);
+		if (returns.length !== 1) return void 0;
+		const returned = evaluateReplayExpression(returns[0].node, returns[0].scope, state, context);
+		return returned ? createReplayContainer({
+			kind: "object",
+			entries: new Map([[unknownTemplatePathSegment, returned]])
+		}) : void 0;
+	}
+	/** Evaluates the container identity or captured leaf produced by an expression. */
+	function evaluateReplayExpression(node, scope, state, context) {
+		const expression = unwrapExpression(node);
+		if (!expression) return void 0;
+		if (expression.type === "ThisExpression") return context.thisValue;
+		if (expression.type === "Identifier") {
+			const binding = scope.getBinding(expression.name);
+			if (binding) {
+				const substituted = context.substitutions.get(binding);
+				if (substituted) return substituted;
+				if (context.values.has(binding)) return context.values.get(binding);
+			}
+			return createReplayLeaf(expression, scope, state);
+		}
+		if (expression.type === "ArrowFunctionExpression" || expression.type === "FunctionExpression") return {
+			type: "function",
+			boundArguments: [],
+			callable: {
+				node: expression,
+				scope: state.scopes.get(expression) ?? scope
+			},
+			substitutions: new Map(context.substitutions)
+		};
+		if (expression.type === "ArrayExpression") return evaluateReplayArray(expression, scope, state, context);
+		if (expression.type === "ObjectExpression") return evaluateReplayObject(expression, scope, state, context);
+		if (expression.type === "NewExpression") return evaluateReplayNewExpression(expression, scope, state, context);
+		if (expression.type === "MemberExpression" || expression.type === "OptionalMemberExpression") return evaluateReplayMember(expression, scope, state, context) ?? createReplayLeaf(expression, scope, state);
+		if (expression.type === "CallExpression" || expression.type === "OptionalCallExpression") return evaluateReplayCall(expression, scope, state, context);
+		if (expression.type === "SequenceExpression") {
+			const last = expression.expressions.at(-1);
+			return last ? evaluateReplayExpression(last, scope, state, context) : void 0;
+		}
+		if (expression.type === "AssignmentExpression") return evaluateReplayExpression(expression.right, scope, state, context);
+		return createReplayLeaf(expression, scope, state);
+	}
+	/** Splits a static member target into its base expression and property path. */
+	function readReplayMemberTarget(node, scope, state) {
+		const properties = [];
+		let current = node;
+		while (current.type === "MemberExpression" || current.type === "OptionalMemberExpression") {
+			const property = readResolvedMemberProperty(current, scope, state);
+			if (property === void 0) return void 0;
+			properties.unshift(property);
+			current = current.object;
+		}
+		return {
+			base: current,
+			properties
+		};
+	}
+	/** Finds the accessor setter JavaScript would invoke for one property write. */
+	function readReplayContainerSetter(value, property, receiver = value, seen = /* @__PURE__ */ new Set()) {
+		if (value.identity.escaped || value.identity.snapshot.kind !== "object" || seen.has(value.identity)) return;
+		const snapshot = value.identity.snapshot;
+		const setter = snapshot.setters?.get(property);
+		if (setter) return {
+			...setter,
+			receiver
+		};
+		if (snapshot.entries.has(property)) return snapshot.entries.get(property)?.type === "getter" ? void 0 : null;
+		return snapshot.prototype ? readReplayContainerSetter(snapshot.prototype, property, receiver, new Set(seen).add(value.identity)) : null;
+	}
+	/** Applies one direct or nested member assignment to a replayed identity. */
+	function applyReplayMemberAssignment(left, right, scope, state, context) {
+		const target = readReplayMemberTarget(left, scope, state);
+		if (!target || target.properties.length === 0) return false;
+		let value = evaluateReplayExpression(target.base, scope, state, context);
+		for (const property of target.properties.slice(0, -1)) {
+			const child = value?.type === "container" ? readReplayContainerEntry(value, property, state, context) : value?.type === "ref" && property === "value" ? readReplayRefValue(value) : value?.type === "computed" && property === "value" ? evaluateReplayComputed(value, state, context) : void 0;
+			if (!child) {
+				if (value?.type === "container") markReplayContainerEscaped(value);
+				if (value?.type === "ref") markReplayRefEscaped(value);
+				return false;
+			}
+			value = child;
+		}
+		const property = target.properties.at(-1);
+		if (value?.type === "ref") {
+			if (property !== "value") {
+				markReplayRefEscaped(value);
+				return false;
+			}
+			if (value.writePolicy !== "forward") return true;
+			value.identity.value = evaluateReplayExpression(right, scope, state, context);
+			return value.identity.value !== void 0;
+		}
+		if (value?.type !== "container") return false;
+		if (value.writePolicy !== "forward") return true;
+		const snapshot = value.identity.snapshot;
+		if (snapshot.kind === "array" && property === "length") {
+			const length = readStaticFromScope(right, scope, /* @__PURE__ */ new Set(), right.end ?? Number.POSITIVE_INFINITY, state.analysis, true);
+			if (!length.ok || typeof length.value !== "number" || !Number.isInteger(length.value) || length.value < 0) {
+				markReplayContainerEscaped(value);
+				return false;
+			}
+			snapshot.entries.length = length.value;
+			return true;
+		}
+		const replacement = evaluateReplayExpression(right, scope, state, context);
+		if (!replacement) {
+			markReplayContainerEscaped(value);
+			return false;
+		}
+		if (snapshot.kind === "object") {
+			const setter = readReplayContainerSetter(value, property);
+			if (setter === void 0) {
+				markReplayContainerEscaped(value);
+				return false;
+			}
+			if (setter) {
+				if (!executeReplayFunction(setter.callable, [replacement], state, {
+					...context,
+					substitutions: new Map(setter.substitutions)
+				}, setter.receiver).executed) {
+					markReplayContainerEscaped(value);
+					return false;
+				}
+				return true;
+			}
+		}
+		if (snapshot.kind === "array") {
+			if (!/^(0|[1-9]\d*)$/.test(property)) {
+				markReplayContainerEscaped(value);
+				return false;
+			}
+			snapshot.entries[Number(property)] = replacement;
+		} else snapshot.entries.set(property, replacement);
+		return true;
+	}
+	/** Applies JavaScript delete semantics to one replayed own property. */
+	function applyReplayMemberDelete(argument, scope, state, context) {
+		const target = readReplayMemberTarget(argument, scope, state);
+		if (!target || target.properties.length === 0) return false;
+		let value = evaluateReplayExpression(target.base, scope, state, context);
+		for (const property of target.properties.slice(0, -1)) {
+			value = value?.type === "container" ? readReplayContainerEntry(value, property, state, context) : value?.type === "ref" && property === "value" ? readReplayRefValue(value) : value?.type === "computed" && property === "value" ? evaluateReplayComputed(value, state, context) : void 0;
+			if (!value) return false;
+		}
+		if (value?.type !== "container") return false;
+		if (value.writePolicy !== "forward") return true;
+		const property = target.properties.at(-1);
+		const snapshot = value.identity.snapshot;
+		if (snapshot.kind === "array") {
+			if (!/^(0|[1-9]\d*)$/.test(property)) return false;
+			snapshot.entries[Number(property)] = void 0;
+		} else snapshot.entries.delete(property);
+		return true;
+	}
+	/** Invalidates one replay binding and every identity reachable through it. */
+	function invalidateReplayBinding(binding, context) {
+		if (!binding || !context.values.has(binding)) return;
+		const value = context.values.get(binding);
+		if (value?.type === "container") markReplayContainerEscaped(value);
+		if (value?.type === "ref") markReplayRefEscaped(value);
+		if (value?.type === "collection") markReplayCollectionEscaped(value);
+		context.unsafeBindings.add(binding);
+		context.values.set(binding, void 0);
+	}
+	/** Invalidates identities captured by a local callback we cannot execute. */
+	function invalidateReplayFunctionCaptures(fn, state, context) {
+		const path = state.paths.get(fn);
+		if (!path) return;
+		path.traverse({ Identifier(identifierPath) {
+			invalidateReplayBinding(identifierPath.scope.getBinding(identifierPath.node.name), context);
+		} });
+	}
+	/** Invalidates only identities referenced by unsupported control flow. */
+	function invalidateReplayStatement(path, state, context) {
+		if (path.isIdentifier()) invalidateReplayBinding(path.scope.getBinding(path.node.name), context);
+		path.traverse({
+			CallExpression(callPath) {
+				const callable = resolveCalledFunction(callPath.node.callee, callPath.scope, state, /* @__PURE__ */ new Set());
+				if (callable) invalidateReplayFunctionCaptures(callable.node, state, context);
+				for (const argument of callPath.node.arguments) {
+					if (argument.type === "ArgumentPlaceholder" || argument.type === "SpreadElement") continue;
+					markReplayValueEscaped(evaluateReplayExpression(argument, callPath.scope, state, context));
+				}
+			},
+			OptionalCallExpression(callPath) {
+				const callable = resolveCalledFunction(callPath.node.callee, callPath.scope, state, /* @__PURE__ */ new Set());
+				if (callable) invalidateReplayFunctionCaptures(callable.node, state, context);
+				for (const argument of callPath.node.arguments) {
+					if (argument.type === "ArgumentPlaceholder" || argument.type === "SpreadElement") continue;
+					markReplayValueEscaped(evaluateReplayExpression(argument, callPath.scope, state, context));
+				}
+			},
+			Identifier(identifierPath) {
+				invalidateReplayBinding(identifierPath.scope.getBinding(identifierPath.node.name), context);
+			}
+		});
+	}
+	/** Executes one direct sibling statement in the finite identity subset. */
+	function replayContainerStatement(path, state, context) {
+		if (path.isImportDeclaration() || path.isFunctionDeclaration()) return;
+		if (path.isVariableDeclaration()) {
+			for (const declarator of path.get("declarations")) {
+				if (!declarator.isVariableDeclarator()) continue;
+				if (declarator.node.id.type !== "Identifier") {
+					const source = declarator.node.init ? evaluateReplayExpression(declarator.node.init, declarator.scope, state, context) : void 0;
+					if (source?.type === "unsafe" || source?.type === "container" && source.identity.escaped || source?.type === "collection" && source.identity.escaped || source?.type === "ref" && source.identity.escaped) {
+						for (const name of collectPatternBindingNames(declarator.node.id)) {
+							const binding = declarator.scope.getBinding(name);
+							if (!binding) continue;
+							context.unsafeBindings.add(binding);
+							context.values.set(binding, replayUnsafe);
+						}
+						continue;
+					}
+					invalidateReplayStatement(declarator, state, context);
+					continue;
+				}
+				const binding = declarator.scope.getBinding(declarator.node.id.name);
+				if (!binding) continue;
+				const value = declarator.node.init ? evaluateReplayExpression(declarator.node.init, declarator.scope, state, context) : void 0;
+				if (value?.type === "unsafe") context.unsafeBindings.add(binding);
+				else context.unsafeBindings.delete(binding);
+				context.values.set(binding, value);
+			}
+			return;
+		}
+		if (!path.isExpressionStatement()) {
+			invalidateReplayStatement(path, state, context);
+			return;
+		}
+		const expression = unwrapExpression(path.node.expression);
+		if (expression?.type === "UnaryExpression" && expression.operator === "delete" && (expression.argument.type === "MemberExpression" || expression.argument.type === "OptionalMemberExpression")) {
+			if (!applyReplayMemberDelete(expression.argument, path.scope, state, context)) invalidateReplayStatement(path, state, context);
+			return;
+		}
+		if (expression?.type === "AssignmentExpression") {
+			if (expression.operator !== "=") {
+				invalidateReplayStatement(path, state, context);
+				return;
+			}
+			if (expression.left.type === "Identifier") {
+				const binding = path.scope.getBinding(expression.left.name);
+				if (!binding) return;
+				const value = evaluateReplayExpression(expression.right, path.scope, state, context);
+				if (value?.type === "unsafe") context.unsafeBindings.add(binding);
+				else context.unsafeBindings.delete(binding);
+				context.values.set(binding, value);
+				return;
+			}
+			if (expression.left.type === "MemberExpression" || expression.left.type === "OptionalMemberExpression") {
+				if (!applyReplayMemberAssignment(expression.left, expression.right, path.scope, state, context)) invalidateReplayStatement(path, state, context);
+				return;
+			}
+			invalidateReplayStatement(path, state, context);
+			return;
+		}
+		if (expression?.type === "CallExpression" || expression?.type === "OptionalCallExpression") {
+			evaluateReplayCall(expression, path.scope, state, context);
+			return;
+		}
+		invalidateReplayStatement(path, state, context);
+	}
+	/** Replays one lexical statement list once and caches it for every binding. */
+	function readContainerIdentityReplay(binding, state) {
+		const statement = binding.path.getStatementParent();
+		const bodyPath = statement?.parentPath;
+		if (!statement || !bodyPath || !bodyPath.isProgram() && !bodyPath.isBlockStatement()) return;
+		const cached = state.containerIdentityReplays.get(bodyPath.node);
+		if (cached) return cached;
+		const context = {
+			allowGetterEffects: true,
+			substitutions: /* @__PURE__ */ new Map(),
+			unsafeBindings: /* @__PURE__ */ new Set(),
+			values: /* @__PURE__ */ new Map()
+		};
+		const body = bodyPath.get("body");
+		if (!Array.isArray(body)) return void 0;
+		for (const child of body) replayContainerStatement(child, state, context);
+		const replay = {
+			unsafeBindings: context.unsafeBindings,
+			values: context.values
+		};
+		state.containerIdentityReplays.set(bodyPath.node, replay);
+		return replay;
+	}
+	/** Replays earlier sibling statements and reads one call target in-place. */
+	function evaluateReplayAtPosition(node, scope, atPosition, state) {
+		const expression = unwrapExpression(node) ?? node;
+		const statement = (state.paths.get(expression) ?? state.paths.get(node))?.getStatementParent();
+		const bodyPath = statement?.parentPath;
+		if (!statement || !bodyPath || !bodyPath.isProgram() && !bodyPath.isBlockStatement()) return;
+		const body = bodyPath.get("body");
+		if (!Array.isArray(body)) return void 0;
+		const context = {
+			allowGetterEffects: true,
+			substitutions: /* @__PURE__ */ new Map(),
+			unsafeBindings: /* @__PURE__ */ new Set(),
+			values: /* @__PURE__ */ new Map()
+		};
+		for (const child of body) {
+			if (child.node === statement.node || (child.node.start ?? Number.POSITIVE_INFINITY) >= atPosition) break;
+			replayContainerStatement(child, state, context);
+		}
+		return evaluateReplayExpression(expression, scope, state, context);
+	}
+	/** Applies Vue template top-level ref/computed unwrapping to replayed bindings. */
+	function readReplayTemplateValue(value, state, replay) {
+		const context = {
+			substitutions: /* @__PURE__ */ new Map(),
+			unsafeBindings: replay.unsafeBindings,
+			values: replay.values
+		};
+		const seen = /* @__PURE__ */ new Set();
+		let current = value;
+		while (current && !seen.has(current) && (current.type === "ref" || current.type === "computed")) {
+			seen.add(current);
+			current = current.type === "ref" ? readReplayRefValue(current) : evaluateReplayComputed(current, state, context);
+		}
+		return current;
+	}
+	/** Reads a final scalar component identity without reviving stale sources. */
+	function readReplayLeafState(binding, state) {
+		const replay = readContainerIdentityReplay(binding, state);
+		if (!replay || !replay.values.has(binding)) return void 0;
+		const value = readReplayTemplateValue(replay.values.get(binding), state, replay);
+		if (value?.type === "unsafe") return { status: "unsafe" };
+		return value?.type === "leaf" && value.exactSelection && value.hasGT !== void 0 ? {
+			status: "leaf",
+			value
+		} : void 0;
+	}
+	/** Keeps exact replay from bypassing deliberate opaque-resolution boundaries. */
+	function readSafeReplayLeafOverride(binding, replayLeaf, state) {
+		if (replayLeaf?.status !== "leaf") return void 0;
+		const { value } = replayLeaf;
+		if (bindingReadsUnsafeMutableImport(binding, state)) return void 0;
+		if (value.knownValue?.type === "vue-builtin") return void 0;
+		if (value.selectionKind === "ref" && value.knownValue?.type === "component") return;
+		return isReplayGetterStringLeaf(value) ? void 0 : replayLeaf;
+	}
+	/** String translators selected through a getter remain intentionally opaque. */
+	function isReplayGetterStringLeaf(value) {
+		return value.selectionKind === "getter" && value.knownValue?.type === "string";
+	}
+	/** Detects unresolved mutable identities retained by one final replay value. */
+	function replayBindingRetainsUnsafeIdentity(binding, state) {
+		const replay = readContainerIdentityReplay(binding, state);
+		if (!replay || replay.unsafeBindings.has(binding)) return Boolean(replay);
+		const seen = /* @__PURE__ */ new Set();
+		const visit = (value) => {
+			if (!value) return false;
+			if (value.type === "unsafe") return true;
+			if (value.type === "container") {
+				if (value.identity.escaped || seen.has(value.identity)) return value.identity.escaped;
+				seen.add(value.identity);
+				const snapshot = value.identity.snapshot;
+				const entries = snapshot.kind === "array" ? snapshot.entries : snapshot.entries.values();
+				for (const entry of entries) if (visit(entry)) return true;
+				return snapshot.kind === "object" && snapshot.prototype ? visit(snapshot.prototype) : false;
+			}
+			if (value.type === "ref") {
+				if (value.identity.escaped || seen.has(value.identity)) return value.identity.escaped;
+				seen.add(value.identity);
+				return visit(value.identity.value);
+			}
+			if (value.type === "collection") {
+				if (value.identity.escaped || seen.has(value.identity)) return value.identity.escaped;
+				seen.add(value.identity);
+				return [...value.identity.entries.values()].some(visit);
+			}
+			if (value.type === "function") return value.boundArguments.some(visit) || [...value.substitutions.values()].some(visit);
+			if (value.type === "getter" || value.type === "method") return [...value.substitutions.values()].some(visit);
+			return false;
+		};
+		return visit(replay.values.get(binding));
+	}
+	/** Collects exact tainted-container paths from one final runtime identity. */
+	function replayContainerIdentityHasGT(value, seen, state, context) {
+		if (value.identity.escaped) return void 0;
+		if (seen.has(value.identity)) return false;
+		const nextSeen = new Set(seen).add(value.identity);
+		const visible = readReplayVisibleContainerEntries(value, state, context);
+		if (!visible) return void 0;
+		let unknown = false;
+		for (const [, entry] of visible) {
+			if (!entry) continue;
+			if (entry.type === "leaf") {
+				if (entry.hasGT) return true;
+				if (entry.hasGT === void 0) unknown = true;
+				continue;
+			}
+			if (entry.type !== "container") {
+				unknown = true;
+				continue;
+			}
+			const nested = replayContainerIdentityHasGT(entry, nextSeen, state, context);
+			if (nested) return true;
+			if (nested === void 0) unknown = true;
+		}
+		return unknown ? void 0 : false;
+	}
+	/** Collects exact tainted-container paths from one final runtime identity. */
+	function collectReplayGTContainerPaths(value, basePath, seen, state, context) {
+		if (value.identity.escaped) return new Set([basePath]);
+		if (seen.has(value.identity)) {
+			const hasGT = replayContainerIdentityHasGT(value, /* @__PURE__ */ new Set(), state, context);
+			return hasGT === void 0 ? void 0 : hasGT ? new Set([appendTemplatePath(basePath, recursiveTemplatePathSegment)]) : /* @__PURE__ */ new Set();
+		}
+		const nextSeen = new Set(seen).add(value.identity);
+		const result = /* @__PURE__ */ new Set();
+		const entries = readReplayVisibleContainerEntries(value, state, context);
+		if (!entries) return void 0;
+		for (const [key, entry] of entries) {
+			if (!entry) continue;
+			if (entry.type === "leaf") {
+				if (entry.hasGT === void 0) return void 0;
+				if (entry.hasGT) result.add(basePath);
+				continue;
+			}
+			if (entry.type !== "container") return void 0;
+			const nested = collectReplayGTContainerPaths(entry, appendTemplatePath(basePath, key), nextSeen, state, context);
+			if (!nested) return void 0;
+			for (const path of nested) result.add(path);
+		}
+		return result;
+	}
+	/** Conservatively taints a finite Map/Set when any selected value can be T. */
+	function collectReplayCollectionGTContainerPaths(value, basePath, state, context) {
+		if (value.identity.escaped) return new Set([basePath]);
+		let nestedGT = false;
+		for (const entry of value.identity.entries.values()) {
+			if (entry.type === "leaf") {
+				if (entry.hasGT === void 0) return void 0;
+				continue;
+			}
+			if (entry.type === "container") {
+				const nested = collectReplayGTContainerPaths(entry, basePath, /* @__PURE__ */ new Set(), state, context);
+				if (!nested) return void 0;
+				nestedGT ||= nested.size > 0;
+				continue;
+			}
+			return;
+		}
+		return nestedGT ? new Set([basePath]) : /* @__PURE__ */ new Set();
+	}
+	/** Reads exact final T-container paths when identity replay stayed finite. */
+	function readDefiniteReplayGTContainerPaths(binding, state) {
+		const replay = readContainerIdentityReplay(binding, state);
+		if (!replay || !replay.values.has(binding)) return void 0;
+		const context = {
+			substitutions: /* @__PURE__ */ new Map(),
+			unsafeBindings: replay.unsafeBindings,
+			values: replay.values
+		};
+		const value = replay ? readReplayTemplateValue(replay.values.get(binding), state, replay) : void 0;
+		if (value?.type === "container") return collectReplayGTContainerPaths(value, binding.identifier.name, /* @__PURE__ */ new Set(), state, context) ?? null;
+		if (value?.type === "collection") return collectReplayCollectionGTContainerPaths(value, binding.identifier.name, state, context) ?? null;
+		if (value?.type === "unsafe") return null;
+		return value === void 0 && replay.unsafeBindings.has(binding) ? null : void 0;
+	}
+	/** Reads exact final array/object shape from the same identity replay. */
+	function readReplayContainerMetadata(binding, basePath, state) {
+		const replay = readContainerIdentityReplay(binding, state);
+		if (!replay) return void 0;
+		const context = {
+			substitutions: /* @__PURE__ */ new Map(),
+			unsafeBindings: replay.unsafeBindings,
+			values: replay.values
+		};
+		const root = replay ? readReplayTemplateValue(replay.values.get(binding), state, replay) : void 0;
+		if (root?.type === "collection") return root.identity.escaped ? void 0 : {
+			arrayLengths: /* @__PURE__ */ new Map(),
+			kinds: new Map([[basePath, "object"]])
+		};
+		if (root?.type !== "container") return void 0;
+		const arrayLengths = /* @__PURE__ */ new Map();
+		const kinds = /* @__PURE__ */ new Map();
+		const visit = (value, path, seen) => {
+			if (value.identity.escaped) return false;
+			if (seen.has(value.identity)) return true;
+			const nextSeen = new Set(seen).add(value.identity);
+			const snapshot = value.identity.snapshot;
+			kinds.set(path, snapshot.kind);
+			if (snapshot.kind === "array") arrayLengths.set(path, snapshot.entries.length);
+			const entries = readReplayVisibleContainerEntries(value, state, context);
+			if (!entries) return false;
+			for (const [key, entry] of entries) if (entry?.type === "container" && !visit(entry, appendTemplatePath(path, key), nextSeen)) return false;
+			return true;
+		};
+		return visit(root, basePath, /* @__PURE__ */ new Set()) ? {
+			arrayLengths,
+			kinds
+		} : void 0;
+	}
+	/** Exposes exact component leaves from a replayed final container. */
+	function readReplayComponentCandidates(binding, basePath, state) {
+		const replay = readContainerIdentityReplay(binding, state);
+		if (!replay) return void 0;
+		const context = {
+			substitutions: /* @__PURE__ */ new Map(),
+			unsafeBindings: replay.unsafeBindings,
+			values: replay.values
+		};
+		const root = replay ? readReplayTemplateValue(replay.values.get(binding), state, replay) : void 0;
+		if (root?.type === "collection") {
+			if (root.identity.escaped) return void 0;
+			const result = [];
+			for (const [key, entry] of root.identity.entries) {
+				if (entry.type !== "leaf" || entry.hasGT === void 0) return void 0;
+				if (!entry.knownValue) continue;
+				const name = appendTemplatePath(basePath, root.identity.templateKeys.get(key) ?? "%GT_UNKNOWN%");
+				result.push({
+					certain: !isReplayGetterStringLeaf(entry),
+					name,
+					value: entry.knownValue
+				});
+			}
+			return result;
+		}
+		if (root?.type !== "container") return void 0;
+		const result = [];
+		const visit = (value, path, seen) => {
+			if (value.identity.escaped) return false;
+			if (seen.has(value.identity)) return true;
+			const nextSeen = new Set(seen).add(value.identity);
+			const entries = readReplayVisibleContainerEntries(value, state, context);
+			if (!entries) return false;
+			for (const [key, entry] of entries) {
+				if (!entry) continue;
+				const childPath = appendTemplatePath(path, key);
+				if (entry.type === "container") {
+					if (!visit(entry, childPath, nextSeen)) return false;
+				} else if (entry.type === "leaf") {
+					if (entry.hasGT === void 0) return false;
+					if (entry.knownValue) result.push({
+						certain: !isReplayGetterStringLeaf(entry),
+						name: childPath,
+						value: entry.knownValue
+					});
+				} else return false;
+			}
+			return true;
+		};
+		return visit(root, basePath, /* @__PURE__ */ new Set()) ? result : void 0;
+	}
+	/** Exposes pure receiver methods whose final return is a known component. */
+	function readReplayComponentFactoryCandidates(binding, basePath, state) {
+		const replay = readContainerIdentityReplay(binding, state);
+		if (!replay) return void 0;
+		const context = {
+			substitutions: /* @__PURE__ */ new Map(),
+			unsafeBindings: replay.unsafeBindings,
+			values: replay.values
+		};
+		const root = readReplayTemplateValue(replay.values.get(binding), state, replay);
+		if (root?.type !== "container") return void 0;
+		const result = [];
+		const visit = (value, path, seen) => {
+			if (value.identity.escaped) return false;
+			if (seen.has(value.identity)) return true;
+			const entries = readReplayVisibleContainerEntries(value, state, context);
+			if (!entries) return false;
+			const nextSeen = new Set(seen).add(value.identity);
+			for (const [key, entry] of entries) {
+				if (!entry) continue;
+				const childPath = appendTemplatePath(path, key);
+				if (entry.type === "container") {
+					if (!visit(entry, childPath, nextSeen)) return false;
+					continue;
+				}
+				if (entry.type === "leaf") {
+					if (entry.hasGT === void 0) return false;
+					continue;
+				}
+				if (entry.type !== "method" || !entry.receiver) return false;
+				const body = entry.callable.node.body;
+				if (body.type === "BlockStatement" && (body.body.length !== 1 || body.body[0]?.type !== "ReturnStatement")) return false;
+				const returns = collectFunctionReturnExpressions(entry.callable.node, entry.callable.scope, state);
+				if (returns.length !== 1) return false;
+				const returned = evaluateReplayExpression(returns[0].node, returns[0].scope, state, {
+					...context,
+					substitutions: new Map(entry.substitutions),
+					thisValue: entry.receiver
+				});
+				if (returned?.type !== "leaf" || returned.hasGT === void 0) return false;
+				if (returned.knownValue?.type === "component" || returned.knownValue?.type === "vue-builtin") result.push({
+					gt: returned.knownValue.type === "component" && returned.knownValue.name === "T",
+					name: childPath
+				});
+			}
+			return true;
+		};
+		return visit(root, basePath, /* @__PURE__ */ new Set()) ? result : void 0;
+	}
+	return {
+		evaluateReplayAtPosition,
+		isReplayGetterStringLeaf,
+		readDefiniteReplayGTContainerPaths,
+		readReplayComponentCandidates,
+		readReplayComponentFactoryCandidates,
+		readReplayContainerMetadata,
+		readReplayLeafState,
+		readSafeReplayLeafOverride,
+		replayBindingRetainsUnsafeIdentity
+	};
+}
+//#endregion
+export { createReplayAnalysis };
+
+//# sourceMappingURL=replay.js.map