@tailor-platform/sdk-codemod 0.3.0-next.0 → 0.3.0-next.2

package/dist/codemods/v2/principal-unify/scripts/transform.js

@@ -3,14 +3,28 @@ import { Lang, parse } from "@ast-grep/napi";
 const TYPE_RENAME_MAP = {
 	TailorUser: "TailorPrincipal",
 	TailorActor: "TailorPrincipal",
+	TailorActorType: "TailorPrincipal",
 	TailorInvoker: "TailorPrincipal"
 };
 const UNAUTHENTICATED = "unauthenticatedTailorUser";
 const QUICK_FILTER_NEEDLES = [
 	...Object.keys(TYPE_RENAME_MAP),
 	UNAUTHENTICATED,
-	"createResolver"
+	"userId",
+	"userType",
+	"createResolver",
+	".hooks",
+	".validate",
+	".parse"
 ];
+const ACTOR_PROPERTY_RENAME_MAP = {
+	userId: "id",
+	userType: "type"
+};
+const ACTOR_TYPE_LITERAL_RENAME_MAP = {
+	USER_TYPE_USER: "user",
+	USER_TYPE_MACHINE_USER: "machine_user"
+};
 function quickFilter(source) {
 	if (!source.includes("@tailor-platform/sdk")) return false;
 	return QUICK_FILTER_NEEDLES.some((needle) => source.includes(needle));
@@ -23,14 +37,284 @@ function isInsideImportStatement(node) {
 	}
 	return false;
 }
-function isMemberExpressionObject(node) {
+function memberObjectParent(node) {
 	const parent = node.parent();
-	if (!parent || parent.kind() !== "member_expression") return false;
+	if (!parent || parent.kind() !== "member_expression" && parent.kind() !== "subscript_expression") return null;
 	const obj = parent.field("object");
-	if (!obj) return false;
+	if (!obj) return null;
 	const r = node.range();
 	const or = obj.range();
-	return r.start.index === or.start.index && r.end.index === or.end.index;
+	if (r.start.index !== or.start.index || r.end.index !== or.end.index) return null;
+	return parent;
+}
+function isMemberExpressionObject(node) {
+	return memberObjectParent(node) !== null;
+}
+function optionalPrincipalReadKind(node) {
+	const parent = memberObjectParent(node);
+	if (!parent) return null;
+	if (parent.text().startsWith(`${node.text()}?.`)) return null;
+	if (isAssignmentTargetReference(node)) return null;
+	if (parent.kind() === "subscript_expression") return "computed";
+	return parent.field("property")?.kind() === "property_identifier" ? "property" : null;
+}
+function isOptionalizableMemberObject(node) {
+	return optionalPrincipalReadKind(node) !== null;
+}
+function principalIdentifierReplacement(node, name) {
+	const readKind = optionalPrincipalReadKind(node);
+	if (readKind === "computed") return `${name}?.`;
+	if (readKind === "property") return `${name}?`;
+	return name;
+}
+function principalPropertyReplacement(node, name) {
+	const parent = node.parent();
+	return parent ? principalIdentifierReplacement(parent, name) : name;
+}
+function isObjectDestructureInitializer(node) {
+	const parent = node.parent();
+	if (!parent || parent.kind() !== "variable_declarator") return false;
+	const value = parent.field("value");
+	if (!value) return false;
+	const valueRange = value.range();
+	const nodeRange = node.range();
+	if (valueRange.start.index !== nodeRange.start.index || valueRange.end.index !== nodeRange.end.index) return false;
+	return parent.field("name")?.kind() === "object_pattern";
+}
+function principalReadReplacement(node, name) {
+	return isObjectDestructureInitializer(node) ? `${name} ?? {}` : principalIdentifierReplacement(node, name);
+}
+function nodeRangeContains(outer, inner) {
+	const outerRange = outer.range();
+	const innerRange = inner.range();
+	return innerRange.start.index >= outerRange.start.index && innerRange.end.index <= outerRange.end.index;
+}
+function isAssignmentTargetReference(node) {
+	let current = node;
+	let parent = current.parent();
+	while (parent && (parent.kind() === "member_expression" || parent.kind() === "subscript_expression")) {
+		const object = parent.field("object");
+		if (!object || !nodeRangeContains(object, current)) break;
+		current = parent;
+		parent = current.parent();
+	}
+	if (!parent) return false;
+	if (parent.kind() === "update_expression") return true;
+	if (parent.kind() !== "assignment_expression" && parent.kind() !== "augmented_assignment_expression") return false;
+	const left = parent.field("left");
+	return !!left && nodeRangeContains(left, current);
+}
+function parseArgumentCall(node) {
+	if (node.kind() !== "shorthand_property_identifier") return null;
+	const object = node.parent();
+	if (!object || object.kind() !== "object") return null;
+	const args = object.parent();
+	if (!args || args.kind() !== "arguments") return null;
+	const call = args.parent();
+	return call && call.kind() === "call_expression" && findMemberCallName(call) === "parse" ? call : null;
+}
+function isSdkFieldParseArgumentShorthand(node, parseContext) {
+	const call = parseArgumentCall(node);
+	return call ? isSdkFieldMemberCall(call, parseContext.sdkFieldRootNames, parseContext.sdkFieldLocalBindings, parseContext.root) : false;
+}
+function addActorPropertyReplacement(property, edits, transformedActorPropertyStarts) {
+	const newName = ACTOR_PROPERTY_RENAME_MAP[property.text()];
+	if (!newName) return;
+	const start = property.range().start.index;
+	if (transformedActorPropertyStarts.has(start)) return;
+	transformedActorPropertyStarts.add(start);
+	edits.push(property.replace(newName));
+}
+function actorTypeLiteralReplacement(literal) {
+	const match = literal.text().match(/^(['"])(USER_TYPE_USER|USER_TYPE_MACHINE_USER|USER_TYPE_UNSPECIFIED)\1$/);
+	if (!match) return null;
+	const [, quote, value] = match;
+	if (value === "USER_TYPE_UNSPECIFIED") return "undefined";
+	return `${quote}${ACTOR_TYPE_LITERAL_RENAME_MAP[value]}${quote}`;
+}
+function addActorTypeLiteralReplacement(literal, edits, transformedLiteralStarts) {
+	if (literal.kind() !== "string") return;
+	const replacement = actorTypeLiteralReplacement(literal);
+	if (!replacement) return;
+	const start = literal.range().start.index;
+	if (transformedLiteralStarts.has(start)) return;
+	transformedLiteralStarts.add(start);
+	edits.push(literal.replace(replacement));
+}
+function transformActorTypeLiteralsInNode(node, edits, transformedLiteralStarts) {
+	if (node.kind() === "string") addActorTypeLiteralReplacement(node, edits, transformedLiteralStarts);
+	const literals = node.findAll({ rule: { kind: "string" } });
+	for (const literal of literals) addActorTypeLiteralReplacement(literal, edits, transformedLiteralStarts);
+}
+function isTransformedActorTypeMember(node, transformedActorPropertyStarts) {
+	if (node.kind() !== "member_expression") return false;
+	const property = node.field("property");
+	return property?.text() === "userType" && transformedActorPropertyStarts.has(property.range().start.index);
+}
+function nodeContainsTransformedActorTypeMember(node, transformedActorPropertyStarts) {
+	if (isTransformedActorTypeMember(node, transformedActorPropertyStarts)) return true;
+	return node.findAll({ rule: { kind: "member_expression" } }).some((member) => isTransformedActorTypeMember(member, transformedActorPropertyStarts));
+}
+function switchDiscriminant(node) {
+	return node.children().find((child) => child.kind() === "parenthesized_expression") ?? null;
+}
+function switchBody(node) {
+	return node.children().find((child) => child.kind() === "switch_body") ?? null;
+}
+function transformActorTypeComparisonLiterals(root, edits, transformedActorPropertyStarts) {
+	if (transformedActorPropertyStarts.size === 0) return;
+	const transformedLiteralStarts = /* @__PURE__ */ new Set();
+	const binaries = root.findAll({ rule: { kind: "binary_expression" } });
+	for (const binary of binaries) {
+		if (!binary.children().some((child) => isTransformedActorTypeMember(child, transformedActorPropertyStarts))) continue;
+		for (const child of binary.children()) addActorTypeLiteralReplacement(child, edits, transformedLiteralStarts);
+	}
+	const switches = root.findAll({ rule: { kind: "switch_statement" } });
+	for (const switchNode of switches) {
+		const discriminant = switchDiscriminant(switchNode);
+		if (!discriminant || !nodeContainsTransformedActorTypeMember(discriminant, transformedActorPropertyStarts)) continue;
+		const body = switchBody(switchNode);
+		if (!body) continue;
+		const cases = body.findAll({ rule: { kind: "switch_case" } });
+		for (const caseNode of cases) for (const child of caseNode.children()) addActorTypeLiteralReplacement(child, edits, transformedLiteralStarts);
+	}
+}
+function transformTailorActorTypeInitializerLiterals(root, actorTypeLocalNames, sdkNamespaceNames, edits) {
+	if (actorTypeLocalNames.size === 0 && sdkNamespaceNames.size === 0) return;
+	const transformedLiteralStarts = /* @__PURE__ */ new Set();
+	const declarators = root.findAll({ rule: { kind: "variable_declarator" } });
+	for (const decl of declarators) {
+		if (!isSdkTypeReference(decl, actorTypeLocalNames, "TailorActorType", sdkNamespaceNames, root)) continue;
+		const value = decl.field("value");
+		if (!value) continue;
+		transformActorTypeLiteralsInNode(value, edits, transformedLiteralStarts);
+	}
+}
+function transformActorTypeBindingComparisons(root, binding, edits) {
+	const refs = root.findAll({ rule: {
+		kind: "identifier",
+		regex: `^${escapeRegex(binding.name)}$`
+	} });
+	const transformedLiteralStarts = /* @__PURE__ */ new Set();
+	for (const ref of refs) {
+		const binary = ref.parent();
+		if (!binary || binary.kind() !== "binary_expression") continue;
+		if (isShadowedLocalReference(root, binding.name, ref.range().start.index, binding.bindingStart)) continue;
+		for (const child of binary.children()) addActorTypeLiteralReplacement(child, edits, transformedLiteralStarts);
+	}
+	const switches = root.findAll({ rule: { kind: "switch_statement" } });
+	for (const switchNode of switches) {
+		const discriminant = switchDiscriminant(switchNode);
+		if (!discriminant) continue;
+		if (!discriminant.findAll({ rule: {
+			kind: "identifier",
+			regex: `^${escapeRegex(binding.name)}$`
+		} }).some((ref) => !isShadowedLocalReference(root, binding.name, ref.range().start.index, binding.bindingStart))) continue;
+		const body = switchBody(switchNode);
+		if (!body) continue;
+		const cases = body.findAll({ rule: { kind: "switch_case" } });
+		for (const caseNode of cases) for (const child of caseNode.children()) addActorTypeLiteralReplacement(child, edits, transformedLiteralStarts);
+	}
+}
+function transformTailorActorTypeBindingComparisons(root, actorTypeLocalNames, sdkNamespaceNames, edits) {
+	if (actorTypeLocalNames.size === 0 && sdkNamespaceNames.size === 0) return;
+	for (const kind of NESTED_FN_KINDS) {
+		const fns = root.findAll({ rule: { kind } });
+		for (const fn of fns) {
+			const param = getFirstFunctionParam(fn);
+			if (!param || !isSdkTypeReference(param, actorTypeLocalNames, "TailorActorType", sdkNamespaceNames, root)) continue;
+			const pattern = getFunctionParamPattern(param);
+			const body = fn.field("body");
+			if (!pattern || pattern.kind() !== "identifier" || !body) continue;
+			transformActorTypeBindingComparisons(body, {
+				name: pattern.text(),
+				bindingStart: pattern.range().start.index
+			}, edits);
+		}
+	}
+	const declarators = root.findAll({ rule: { kind: "variable_declarator" } });
+	for (const decl of declarators) {
+		if (!isSdkTypeReference(decl, actorTypeLocalNames, "TailorActorType", sdkNamespaceNames, root)) continue;
+		const name = decl.field("name");
+		if (!name || name.kind() !== "identifier") continue;
+		transformActorTypeBindingComparisons(root, {
+			name: name.text(),
+			bindingStart: name.range().start.index
+		}, edits);
+	}
+}
+function transformActorBindingMemberAccesses(root, binding, edits, transformedActorPropertyStarts) {
+	const refs = root.findAll({ rule: {
+		kind: "identifier",
+		regex: `^${escapeRegex(binding.name)}$`
+	} });
+	for (const ref of refs) {
+		const parent = ref.parent();
+		if (!parent || parent.kind() !== "member_expression") continue;
+		const object = parent.field("object");
+		if (!object || object.range().start.index !== ref.range().start.index) continue;
+		const property = parent.field("property");
+		if (!property || property.kind() !== "property_identifier") continue;
+		if (!ACTOR_PROPERTY_RENAME_MAP[property.text()]) continue;
+		const pos = ref.range().start.index;
+		if (isShadowedLocalReference(root, binding.name, pos, binding.bindingStart)) continue;
+		addActorPropertyReplacement(property, edits, transformedActorPropertyStarts);
+	}
+}
+function isSdkTypeReference(node, localNames, sdkTypeName, sdkNamespaceNames, root) {
+	const typeAnnotation = node.field("type");
+	if (!typeAnnotation) return false;
+	return typeAnnotation.findAll({ rule: { kind: "type_identifier" } }).some((id) => localNames.has(id.text()) || id.text() === sdkTypeName && isSdkNamespaceQualifiedTypeIdentifier(id, sdkNamespaceNames, root));
+}
+function transformTailorActorTypedMemberAccesses(root, actorTypeLocalNames, sdkNamespaceNames, edits, transformedActorPropertyStarts) {
+	if (actorTypeLocalNames.size === 0 && sdkNamespaceNames.size === 0) return;
+	for (const kind of NESTED_FN_KINDS) {
+		const fns = root.findAll({ rule: { kind } });
+		for (const fn of fns) {
+			const param = getFirstFunctionParam(fn);
+			if (!param || !isSdkTypeReference(param, actorTypeLocalNames, "TailorActor", sdkNamespaceNames, root)) continue;
+			const pattern = getFunctionParamPattern(param);
+			const body = fn.field("body");
+			if (!pattern || pattern.kind() !== "identifier" || !body) continue;
+			transformActorBindingMemberAccesses(body, {
+				name: pattern.text(),
+				bindingStart: pattern.range().start.index
+			}, edits, transformedActorPropertyStarts);
+		}
+	}
+	const declarators = root.findAll({ rule: { kind: "variable_declarator" } });
+	for (const decl of declarators) {
+		if (!isSdkTypeReference(decl, actorTypeLocalNames, "TailorActor", sdkNamespaceNames, root)) continue;
+		const name = decl.field("name");
+		if (!name || name.kind() !== "identifier") continue;
+		transformActorBindingMemberAccesses(root, {
+			name: name.text(),
+			bindingStart: name.range().start.index
+		}, edits, transformedActorPropertyStarts);
+	}
+}
+function transformExecutorCtxActorAccesses(body, ctxName, ctxShadowRanges, edits, transformedActorPropertyStarts) {
+	const properties = body.findAll({ rule: {
+		kind: "property_identifier",
+		regex: "^(userId|userType)$"
+	} });
+	for (const property of properties) {
+		const parent = property.parent();
+		if (!parent || parent.kind() !== "member_expression") continue;
+		const object = parent.field("object");
+		if (!object || object.kind() !== "member_expression") continue;
+		if (object.field("property")?.text() !== "actor") continue;
+		const ctxObject = object.field("object");
+		if (!ctxObject || ctxObject.kind() !== "identifier" || ctxObject.text() !== ctxName) continue;
+		const pos = ctxObject.range().start.index;
+		if (isInsideAnyRange(pos, ctxShadowRanges)) continue;
+		addActorPropertyReplacement(property, edits, transformedActorPropertyStarts);
+	}
+}
+function renamedTypeIdentifierText(name) {
+	if (name === "TailorInvoker") return "(TailorPrincipal | null)";
+	if (name === "TailorActorType") return "(TailorPrincipal[\"type\"] | undefined)";
+	return TYPE_RENAME_MAP[name] ?? null;
 }
 function extractModuleSource(importText) {
 	return importText.match(/from\s+(["'])([^"']+)\1/)?.[2] ?? "@tailor-platform/sdk";
@@ -59,7 +343,7 @@ function* iterateImportSpecs(importStmt) {
 		};
 	}
 }
-function rebuildImportStatement(importStmt, globalEmittedRenamed, unauthenticatedLocalNames) {
+function rebuildImportStatement(importStmt, globalEmittedRenamed, unauthenticatedLocalNames, nullableInvokerAliasLocalNames, actorTypeAliasLocalNames) {
 	const importText = importStmt.text();
 	const isImportType = /^\s*import\s+type\b/.test(importText);
 	const trailingSemi = importText.trimEnd().endsWith(";") ? ";" : "";
@@ -73,12 +357,17 @@ function rebuildImportStatement(importStmt, globalEmittedRenamed, unauthenticate
 		const renamed = TYPE_RENAME_MAP[importedName];
 		if (renamed) {
 			touched = true;
-			const finalLocal = aliasNode?.text() ?? renamed;
+			const dropsAliasForNullableInvoker = importedName === "TailorInvoker" && !!aliasNode;
+			const dropsAliasForActorType = importedName === "TailorActorType" && !!aliasNode;
+			const dropsAliasForExpandedType = dropsAliasForNullableInvoker || dropsAliasForActorType;
+			if (dropsAliasForNullableInvoker) nullableInvokerAliasLocalNames.add(localName);
+			if (dropsAliasForActorType) actorTypeAliasLocalNames.add(localName);
+			const finalLocal = dropsAliasForExpandedType ? renamed : aliasNode?.text() ?? renamed;
 			if (seenLocal.has(finalLocal)) continue;
-			if (!aliasNode && globalEmittedRenamed.has(renamed)) continue;
+			if ((!aliasNode || dropsAliasForExpandedType) && globalEmittedRenamed.has(renamed)) continue;
 			seenLocal.add(finalLocal);
-			if (!aliasNode) globalEmittedRenamed.add(renamed);
-			const asPart = aliasNode ? ` as ${aliasNode.text()}` : "";
+			if (!aliasNode || dropsAliasForExpandedType) globalEmittedRenamed.add(renamed);
+			const asPart = aliasNode && !dropsAliasForExpandedType ? ` as ${aliasNode.text()}` : "";
 			newSpecTexts.push(`${isTypeOnly ? "type " : ""}${renamed}${asPart}`);
 		} else if (importedName === UNAUTHENTICATED) {
 			touched = true;
@@ -160,6 +449,15 @@ function patternBindsName(pat, name) {
 	}
 	return false;
 }
+function hasNestedPropertyPattern(pat, name) {
+	if (pat.kind() !== "object_pattern") return false;
+	for (const child of pat.children()) {
+		if (child.kind() !== "pair_pattern") continue;
+		if (child.field("key")?.text() !== name) continue;
+		if (child.field("value")?.kind() !== "identifier") return true;
+	}
+	return false;
+}
 function functionRebindsName(fn, name) {
 	const single = fn.field("parameter");
 	if (single && patternBindsName(single, name)) return true;
@@ -235,6 +533,62 @@ function collectAllShadowRanges(root, name) {
 	}
 	return ranges;
 }
+function hasUnshadowedIdentifierReference(root, name) {
+	const shadowRanges = collectAllShadowRanges(root, name);
+	const refs = root.findAll({ rule: {
+		kind: "identifier",
+		regex: `^${escapeRegex(name)}$`
+	} });
+	for (const ref of refs) if (!isInsideAnyRange(ref.range().start.index, shadowRanges)) return true;
+	return false;
+}
+function hasPrincipalAssignmentTarget(root, name) {
+	const shadowRanges = collectAllShadowRanges(root, name);
+	const refs = root.findAll({ rule: {
+		kind: "identifier",
+		regex: `^${escapeRegex(name)}$`
+	} });
+	for (const ref of refs) {
+		const pos = ref.range().start.index;
+		if (isInsideAnyRange(pos, shadowRanges)) continue;
+		if (isAssignmentTargetReference(ref)) return true;
+	}
+	return false;
+}
+function rewriteParseArgumentShorthands(root, localName, propertyName, parseContext, edits) {
+	const shadowRanges = collectAllShadowRanges(root, localName);
+	const shortRefs = root.findAll({ rule: {
+		kind: "shorthand_property_identifier",
+		regex: `^${escapeRegex(localName)}$`
+	} });
+	for (const ref of shortRefs) {
+		const pos = ref.range().start.index;
+		if (isInsideAnyRange(pos, shadowRanges)) continue;
+		if (!isSdkFieldParseArgumentShorthand(ref, parseContext)) continue;
+		edits.push(ref.replace(`${propertyName}: ${localName}`));
+	}
+}
+function guardPrincipalMemberAccesses(root, binding, edits) {
+	const refs = root.findAll({ rule: {
+		kind: "identifier",
+		regex: `^${escapeRegex(binding.name)}$`
+	} });
+	for (const ref of refs) {
+		if (!isOptionalizableMemberObject(ref)) continue;
+		const pos = ref.range().start.index;
+		if (isShadowedLocalReference(root, binding.name, pos, binding.bindingStart)) continue;
+		edits.push(ref.replace(`${binding.name}?`));
+	}
+	const declarators = root.findAll({ rule: { kind: "variable_declarator" } });
+	for (const decl of declarators) {
+		const value = decl.field("value");
+		if (!value || value.kind() !== "identifier" || value.text() !== binding.name) continue;
+		if (!isObjectDestructureInitializer(value)) continue;
+		const pos = value.range().start.index;
+		if (isShadowedLocalReference(root, binding.name, pos, binding.bindingStart)) continue;
+		edits.push(value.replace(`${binding.name} ?? {}`));
+	}
+}
 function findResolverBodyArrow(call) {
 	const args = call.field("arguments");
 	if (!args) return null;
@@ -249,6 +603,45 @@ function findResolverBodyArrow(call) {
 	}
 	return null;
 }
+function* iterateNamespaceImportLocalNames(importStmt) {
+	const namespaceImports = importStmt.findAll({ rule: { kind: "namespace_import" } });
+	for (const namespaceImport of namespaceImports) {
+		const localName = namespaceImport.children().find((c) => c.kind() === "identifier");
+		if (localName) yield localName.text();
+	}
+}
+function isUnshadowedNamespaceObject(node, namespaceNames, root) {
+	if (node.kind() !== "identifier" || !namespaceNames.has(node.text())) return false;
+	return !isInsideAnyRange(node.range().start.index, collectAllShadowRanges(root, node.text()));
+}
+function isSdkNamespaceQualifiedTypeIdentifier(typeId, namespaceNames, root) {
+	if (typeId.kind() !== "type_identifier") return false;
+	const parent = typeId.parent();
+	if (!parent || parent.kind() !== "nested_type_identifier") return false;
+	const namespaceObject = parent.children().find((c) => c.kind() === "identifier");
+	return !!namespaceObject && isUnshadowedNamespaceObject(namespaceObject, namespaceNames, root);
+}
+function namespaceQualifiedTypeReplacement(typeId, namespaceNames, root) {
+	if (typeId.kind() !== "type_identifier") return null;
+	const parent = typeId.parent();
+	if (!parent || parent.kind() !== "nested_type_identifier") return null;
+	const namespaceObject = parent.children().find((c) => c.kind() === "identifier");
+	if (!namespaceObject || !isUnshadowedNamespaceObject(namespaceObject, namespaceNames, root)) return null;
+	const namespace = namespaceObject.text();
+	if (typeId.text() === "TailorInvoker") return {
+		target: parent,
+		text: `(${namespace}.TailorPrincipal | null)`
+	};
+	if (typeId.text() === "TailorActorType") return {
+		target: parent,
+		text: `(${namespace}.TailorPrincipal["type"] | undefined)`
+	};
+	const renamed = TYPE_RENAME_MAP[typeId.text()];
+	return renamed ? {
+		target: typeId,
+		text: renamed
+	} : null;
+}
 /**
 * Look for any binding named `caller` in the resolver body or pattern. When
 * one exists, renaming `user` → `caller` would either shadow it, collide with
@@ -270,23 +663,20 @@ function hasCallerBindingConflict(pattern, body) {
 			if (inner && inner.text() === "caller") return true;
 		}
 	}
-	if (body.findAll({ rule: {
-		kind: "identifier",
-		regex: "^caller$",
-		inside: { kind: "variable_declarator" }
-	} }).length > 0) return true;
-	if (body.findAll({ rule: {
-		kind: "shorthand_property_identifier_pattern",
-		regex: "^caller$",
-		inside: { kind: "variable_declarator" }
-	} }).length > 0) return true;
+	const decls = body.findAll({ rule: { kind: "variable_declarator" } });
+	for (const decl of decls) {
+		const nameNode = decl.field("name");
+		if (nameNode && patternBindsName(nameNode, "caller")) return true;
+	}
+	const functionDecls = body.findAll({ rule: { kind: "function_declaration" } });
+	for (const fn of functionDecls) if (fn.field("name")?.text() === "caller") return true;
 	for (const k of NESTED_FN_KINDS) {
 		const fns = body.findAll({ rule: { kind: k } });
 		for (const fn of fns) if (functionRebindsName(fn, "caller")) return true;
 	}
 	return false;
 }
-function transformResolverBody(arrowNode, edits) {
+function transformResolverBody(arrowNode, edits, parseContext) {
 	const params = arrowNode.field("parameters") ?? arrowNode.field("parameter") ?? arrowNode.children().find((c) => c.kind() === "formal_parameters");
 	const body = arrowNode.field("body");
 	if (!params || !body) return;
@@ -300,24 +690,52 @@ function transformResolverBody(arrowNode, edits) {
 	}
 	if (!pattern) return;
 	if (pattern.kind() === "object_pattern") {
+		if (hasNestedPropertyPattern(pattern, "user")) return;
+		if (hasPrincipalAssignmentTarget(body, "user")) return;
 		if (hasCallerBindingConflict(pattern, body)) return;
+		const aliasRenamedUser = hasUnshadowedIdentifierReference(body, "caller");
+		let aliasedShorthandUser = false;
 		let renamedShorthandUser = false;
+		const principalAliasBindings = [];
 		for (const child of pattern.children()) {
 			const kind = child.kind();
-			if (kind === "shorthand_property_identifier_pattern" && child.text() === "user") {
+			if (kind === "shorthand_property_identifier_pattern" && child.text() === "user") if (aliasRenamedUser) {
+				edits.push(child.replace("caller: user"));
+				aliasedShorthandUser = true;
+				principalAliasBindings.push({
+					name: "user",
+					bindingStart: child.range().start.index
+				});
+			} else {
 				edits.push(child.replace("caller"));
 				renamedShorthandUser = true;
-			} else if (kind === "pair_pattern") {
+			}
+			else if (kind === "pair_pattern") {
 				const key = child.field("key");
-				if (key && key.text() === "user") edits.push(key.replace("caller"));
+				if (key && key.text() === "user") {
+					edits.push(key.replace("caller"));
+					const value = child.field("value");
+					if (value?.kind() === "identifier") principalAliasBindings.push({
+						name: value.text(),
+						bindingStart: value.range().start.index
+					});
+				}
 			} else if (kind === "object_assignment_pattern") {
 				const inner = child.children().find((c) => c.kind() === "shorthand_property_identifier_pattern");
-				if (inner && inner.text() === "user") {
+				if (inner && inner.text() === "user") if (aliasRenamedUser) {
+					edits.push(inner.replace("caller: user"));
+					aliasedShorthandUser = true;
+					principalAliasBindings.push({
+						name: "user",
+						bindingStart: inner.range().start.index
+					});
+				} else {
 					edits.push(inner.replace("caller"));
 					renamedShorthandUser = true;
 				}
 			}
 		}
+		if (aliasedShorthandUser) rewriteParseArgumentShorthands(body, "user", "invoker", parseContext, edits);
 		if (renamedShorthandUser) {
 			const shadowRanges = collectAllShadowRanges(body, "user");
 			const refs = body.findAll({ rule: {
@@ -327,7 +745,7 @@ function transformResolverBody(arrowNode, edits) {
 			for (const ref of refs) {
 				const pos = ref.range().start.index;
 				if (isInsideAnyRange(pos, shadowRanges)) continue;
-				edits.push(ref.replace("caller"));
+				edits.push(ref.replace(principalIdentifierReplacement(ref, "caller")));
 			}
 			const shortRefs = body.findAll({ rule: {
 				kind: "shorthand_property_identifier",
@@ -336,9 +754,10 @@ function transformResolverBody(arrowNode, edits) {
 			for (const ref of shortRefs) {
 				const pos = ref.range().start.index;
 				if (isInsideAnyRange(pos, shadowRanges)) continue;
-				edits.push(ref.replace("user: caller"));
+				edits.push(ref.replace(isSdkFieldParseArgumentShorthand(ref, parseContext) ? "invoker: caller" : "user: caller"));
 			}
 		}
+		for (const binding of principalAliasBindings) guardPrincipalMemberAccesses(body, binding, edits);
 		return;
 	}
 	const ctxName = pattern.text();
@@ -354,7 +773,7 @@ function transformResolverBody(arrowNode, edits) {
 		if (!(obj && obj.kind() === "identifier" && obj.text() === ctxName)) continue;
 		const pos = obj.range().start.index;
 		if (isInsideAnyRange(pos, ctxShadowRanges)) continue;
-		edits.push(propId.replace("caller"));
+		edits.push(propId.replace(principalPropertyReplacement(propId, "caller")));
 	}
 	const ctxDestructures = body.findAll({ rule: {
 		kind: "variable_declarator",
@@ -364,6 +783,7 @@ function transformResolverBody(arrowNode, edits) {
 			regex: `^${escapeRegex(ctxName)}$`
 		}
 	} });
+	const principalAliasBindings = [];
 	for (const decl of ctxDestructures) {
 		const pos = decl.range().start.index;
 		if (isInsideAnyRange(pos, ctxShadowRanges)) continue;
@@ -371,13 +791,556 @@ function transformResolverBody(arrowNode, edits) {
 		if (!pat || pat.kind() !== "object_pattern") continue;
 		for (const child of pat.children()) {
 			const k = child.kind();
-			if (k === "shorthand_property_identifier_pattern" && child.text() === "user") edits.push(child.replace("caller: user"));
-			else if (k === "pair_pattern") {
+			if (k === "shorthand_property_identifier_pattern" && child.text() === "user") {
+				edits.push(child.replace("caller: user"));
+				principalAliasBindings.push({
+					name: "user",
+					bindingStart: child.range().start.index
+				});
+			} else if (k === "pair_pattern") {
 				const key = child.field("key");
-				if (key && key.text() === "user") edits.push(key.replace("caller"));
+				const value = child.field("value");
+				if (key && key.text() === "user" && value?.kind() === "identifier") {
+					edits.push(key.replace("caller"));
+					principalAliasBindings.push({
+						name: value.text(),
+						bindingStart: value.range().start.index
+					});
+				}
+			}
+		}
+	}
+	for (const binding of principalAliasBindings) guardPrincipalMemberAccesses(body, binding, edits);
+}
+function findMemberCallName(call) {
+	const fn = call.field("function");
+	if (!fn || fn.kind() !== "member_expression") return null;
+	return fn.field("property")?.text() ?? null;
+}
+function findMemberCallObject(call) {
+	const fn = call.field("function");
+	if (!fn || fn.kind() !== "member_expression") return null;
+	return fn.field("object");
+}
+function isFunctionNode(node) {
+	return node.kind() === "arrow_function" || node.kind() === "function_declaration" || node.kind() === "function_expression" || node.kind() === "method_definition";
+}
+function propertyName(node) {
+	return node.field("key")?.text() ?? node.field("name")?.text() ?? null;
+}
+function getFirstFunctionParam(fn) {
+	const params = fn.field("parameters") ?? fn.field("parameter") ?? fn.children().find((c) => c.kind() === "formal_parameters");
+	if (!params) return null;
+	if (params.kind() === "object_pattern" || params.kind() === "identifier") return params;
+	return params.children().find((c) => c.kind() === "required_parameter" || c.kind() === "optional_parameter" || c.kind() === "identifier" || c.kind() === "object_pattern") ?? null;
+}
+function getFunctionParamPattern(param) {
+	if (param.kind() === "object_pattern" || param.kind() === "identifier") return param;
+	return param.field("pattern");
+}
+function findExecutorBodyFunctions(call) {
+	const objArg = call.field("arguments")?.children().find((c) => c.kind() === "object");
+	if (!objArg) return [];
+	const functions = [];
+	const visitObject = (object) => {
+		for (const child of object.children()) {
+			if (child.kind() === "method_definition") {
+				if (propertyName(child) === "body") functions.push(child);
+				continue;
+			}
+			if (child.kind() !== "pair") continue;
+			const value = child.field("value");
+			if (!value) continue;
+			if (child.field("key")?.text() === "body" && isFunctionNode(value)) functions.push(value);
+			else if (value.kind() === "object") visitObject(value);
+		}
+	};
+	visitObject(objArg);
+	return functions;
+}
+function transformExecutorBodyActorAccesses(fn, edits, transformedActorPropertyStarts) {
+	const param = getFirstFunctionParam(fn);
+	const pattern = param ? getFunctionParamPattern(param) : null;
+	const body = fn.field("body");
+	if (!pattern || !body) return;
+	if (pattern.kind() === "identifier") {
+		const ctxName = pattern.text();
+		transformExecutorCtxActorAccesses(body, ctxName, collectCtxShadowRanges(body, ctxName, fn), edits, transformedActorPropertyStarts);
+		return;
+	}
+	if (pattern.kind() !== "object_pattern") return;
+	for (const child of pattern.children()) {
+		const kind = child.kind();
+		if (kind === "shorthand_property_identifier_pattern" && child.text() === "actor") transformActorBindingMemberAccesses(body, {
+			name: "actor",
+			bindingStart: child.range().start.index
+		}, edits, transformedActorPropertyStarts);
+		else if (kind === "pair_pattern") {
+			const key = child.field("key");
+			const value = child.field("value");
+			if (key?.text() === "actor" && value?.kind() === "identifier") transformActorBindingMemberAccesses(body, {
+				name: value.text(),
+				bindingStart: value.range().start.index
+			}, edits, transformedActorPropertyStarts);
+		}
+	}
+}
+function nullableTailorUserTypeReplacement(typeId, typeContext) {
+	if (typeContext.tailorUserTypeLocalNames.has(typeId.text())) return typeId.text() === "TailorUser" ? "TailorPrincipal | null" : `${typeId.text()} | null`;
+	return isSdkNamespaceQualifiedTypeIdentifier(typeId, typeContext.sdkNamespaceNames, typeContext.root) ? "TailorPrincipal | null" : null;
+}
+function transformObjectTypeUserProperty(objectType, edits, typeContext) {
+	for (const child of objectType.children()) {
+		if (child.kind() !== "property_signature") continue;
+		const name = child.field("name");
+		if (name?.text() !== "user") continue;
+		edits.push(name.replace("invoker"));
+		const typeAnnotation = child.field("type");
+		if (!typeAnnotation || /\bnull\b/.test(typeAnnotation.text())) continue;
+		const typeIds = typeAnnotation.findAll({ rule: { kind: "type_identifier" } });
+		for (const typeId of typeIds) {
+			const replacement = nullableTailorUserTypeReplacement(typeId, typeContext);
+			if (!replacement) continue;
+			typeContext.transformedPrincipalTypeStarts.add(typeId.range().start.index);
+			edits.push(typeId.replace(replacement));
+		}
+	}
+}
+function localCallbackTypeObject(declaration) {
+	return declaration.children().find((c) => c.kind() === "object_type" || c.kind() === "interface_body") ?? null;
+}
+function collectLocalCallbackTypeBindings(root) {
+	const rootScope = localBindingRootScope(root);
+	const bindings = [];
+	for (const kind of ["type_alias_declaration", "interface_declaration"]) {
+		const declarations = root.findAll({ rule: { kind } });
+		for (const declaration of declarations) {
+			if (!localCallbackTypeObject(declaration)) continue;
+			const name = declaration.field("name");
+			if (!name || name.kind() !== "type_identifier" && name.kind() !== "identifier") continue;
+			bindings.push({
+				name: name.text(),
+				declaration,
+				bindingStart: name.range().start.index,
+				scope: enclosingScopeRange(declaration) ?? rootScope
+			});
+		}
+	}
+	return bindings;
+}
+function isShadowedLocalTypeReference(root, name, pos, bindingStart) {
+	for (const kind of ["type_alias_declaration", "interface_declaration"]) {
+		const declarations = root.findAll({ rule: { kind } });
+		for (const declaration of declarations) {
+			const nameNode = declaration.field("name");
+			if (!nameNode || nameNode.text() !== name) continue;
+			if (nameNode.range().start.index === bindingStart) continue;
+			const scope = enclosingScopeRange(declaration);
+			if (scope && rangeContains(scope, pos)) return true;
+		}
+	}
+	return false;
+}
+function resolveLocalCallbackTypeBinding(node, context) {
+	const pos = node.range().start.index;
+	return context.bindings.find((binding) => binding.name === node.text() && rangeContains(binding.scope, pos) && !isShadowedLocalTypeReference(context.root, binding.name, pos, binding.bindingStart)) ?? null;
+}
+function transformNamedPrincipalCallbackType(typeName, edits, context) {
+	const binding = resolveLocalCallbackTypeBinding(typeName, context);
+	if (!binding) return;
+	const start = binding.declaration.range().start.index;
+	if (context.transformedTypeStarts.has(start)) return;
+	const objectType = localCallbackTypeObject(binding.declaration);
+	if (!objectType) return;
+	context.transformedTypeStarts.add(start);
+	transformObjectTypeUserProperty(objectType, edits, context);
+}
+function transformPrincipalCallbackParamType(param, edits, typeContext) {
+	const typeAnnotation = param.field("type");
+	const objectType = typeAnnotation?.children().find((c) => c.kind() === "object_type");
+	if (objectType) {
+		if (typeContext) transformObjectTypeUserProperty(objectType, edits, typeContext);
+		return;
+	}
+	const typeName = typeAnnotation?.children().find((c) => c.kind() === "type_identifier");
+	if (typeName && typeContext) transformNamedPrincipalCallbackType(typeName, edits, typeContext);
+}
+function transformPrincipalCallbackParam(fn, edits, typeContext) {
+	const param = getFirstFunctionParam(fn);
+	if (!param) return;
+	const pattern = getFunctionParamPattern(param);
+	const body = fn.field("body");
+	if (!pattern || !body) return;
+	if (pattern.kind() === "identifier") {
+		const ctxName = pattern.text();
+		const ctxShadowRanges = collectCtxShadowRanges(body, ctxName, fn);
+		const propertyAccesses = body.findAll({ rule: {
+			kind: "property_identifier",
+			regex: "^user$"
+		} });
+		for (const propId of propertyAccesses) {
+			const parent = propId.parent();
+			if (!parent || parent.kind() !== "member_expression") continue;
+			const obj = parent.field("object");
+			if (!(obj && obj.kind() === "identifier" && obj.text() === ctxName)) continue;
+			const pos = obj.range().start.index;
+			if (isInsideAnyRange(pos, ctxShadowRanges)) continue;
+			edits.push(propId.replace(principalPropertyReplacement(propId, "invoker")));
+		}
+		const ctxDestructures = body.findAll({ rule: {
+			kind: "variable_declarator",
+			has: {
+				field: "value",
+				kind: "identifier",
+				regex: `^${escapeRegex(ctxName)}$`
+			}
+		} });
+		const principalAliasBindings = [];
+		for (const decl of ctxDestructures) {
+			const pos = decl.range().start.index;
+			if (isInsideAnyRange(pos, ctxShadowRanges)) continue;
+			const pat = decl.field("name");
+			if (!pat || pat.kind() !== "object_pattern") continue;
+			for (const child of pat.children()) {
+				const kind = child.kind();
+				if (kind === "shorthand_property_identifier_pattern" && child.text() === "user") {
+					edits.push(child.replace("invoker: user"));
+					principalAliasBindings.push({
+						name: "user",
+						bindingStart: child.range().start.index
+					});
+				} else if (kind === "pair_pattern") {
+					const key = child.field("key");
+					const value = child.field("value");
+					if (key?.text() === "user" && value?.kind() === "identifier") {
+						edits.push(key.replace("invoker"));
+						principalAliasBindings.push({
+							name: value.text(),
+							bindingStart: value.range().start.index
+						});
+					}
+				}
+			}
+		}
+		for (const binding of principalAliasBindings) guardPrincipalMemberAccesses(body, binding, edits);
+		transformPrincipalCallbackParamType(param, edits, typeContext);
+		return;
+	}
+	if (pattern.kind() !== "object_pattern") return;
+	if (hasNestedPropertyPattern(pattern, "user")) return;
+	let hasUserParamProperty = false;
+	let renamesBinding = false;
+	const principalAliasBindings = [];
+	for (const child of pattern.children()) {
+		const kind = child.kind();
+		if (kind === "shorthand_property_identifier_pattern" && child.text() === "user") {
+			hasUserParamProperty = true;
+			renamesBinding = true;
+		} else if (kind === "pair_pattern") {
+			if (child.field("key")?.text() === "user") {
+				hasUserParamProperty = true;
+				const value = child.field("value");
+				if (value?.kind() === "identifier") principalAliasBindings.push({
+					name: value.text(),
+					bindingStart: value.range().start.index
+				});
+			}
+		} else if (kind === "object_assignment_pattern") {
+			if (child.children().find((c) => c.kind() === "shorthand_property_identifier_pattern")?.text() === "user") {
+				hasUserParamProperty = true;
+				renamesBinding = true;
+			}
+		}
+	}
+	if (!hasUserParamProperty) return;
+	if (renamesBinding && hasPrincipalAssignmentTarget(body, "user")) return;
+	if (renamesBinding && patternBindsName(pattern, "invoker")) return;
+	transformPrincipalCallbackParamType(param, edits, typeContext);
+	const aliasRenamedUser = renamesBinding && (collectAllShadowRanges(body, "invoker").length > 0 || hasUnshadowedIdentifierReference(body, "invoker"));
+	let aliasedShorthandUser = false;
+	let renamedShorthandUser = false;
+	for (const child of pattern.children()) {
+		const kind = child.kind();
+		if (kind === "shorthand_property_identifier_pattern" && child.text() === "user") if (aliasRenamedUser) {
+			edits.push(child.replace("invoker: user"));
+			aliasedShorthandUser = true;
+			principalAliasBindings.push({
+				name: "user",
+				bindingStart: child.range().start.index
+			});
+		} else {
+			edits.push(child.replace("invoker"));
+			renamedShorthandUser = true;
+		}
+		else if (kind === "pair_pattern") {
+			const key = child.field("key");
+			if (key?.text() === "user") edits.push(key.replace("invoker"));
+		} else if (kind === "object_assignment_pattern") {
+			const inner = child.children().find((c) => c.kind() === "shorthand_property_identifier_pattern");
+			if (inner?.text() === "user") if (aliasRenamedUser) {
+				edits.push(inner.replace("invoker: user"));
+				aliasedShorthandUser = true;
+				principalAliasBindings.push({
+					name: "user",
+					bindingStart: inner.range().start.index
+				});
+			} else {
+				edits.push(inner.replace("invoker"));
+				renamedShorthandUser = true;
 			}
 		}
 	}
+	if (!renamedShorthandUser) {
+		if (aliasedShorthandUser) rewriteParseArgumentShorthands(body, "user", "invoker", typeContext, edits);
+		for (const binding of principalAliasBindings) guardPrincipalMemberAccesses(body, binding, edits);
+		return;
+	}
+	const shadowRanges = collectAllShadowRanges(body, "user");
+	const refs = body.findAll({ rule: {
+		kind: "identifier",
+		regex: "^user$"
+	} });
+	for (const ref of refs) {
+		const pos = ref.range().start.index;
+		if (isInsideAnyRange(pos, shadowRanges)) continue;
+		edits.push(ref.replace(principalReadReplacement(ref, "invoker")));
+	}
+	const shortRefs = body.findAll({ rule: {
+		kind: "shorthand_property_identifier",
+		regex: "^user$"
+	} });
+	for (const ref of shortRefs) {
+		const pos = ref.range().start.index;
+		if (isInsideAnyRange(pos, shadowRanges)) continue;
+		edits.push(ref.replace(isSdkFieldParseArgumentShorthand(ref, typeContext) ? "invoker" : "user: invoker"));
+	}
+	for (const binding of principalAliasBindings) guardPrincipalMemberAccesses(body, binding, edits);
+}
+function rangeContains([start, end], pos) {
+	return pos >= start && pos < end;
+}
+function isShadowedLocalReference(root, name, pos, bindingStart) {
+	const declarators = root.findAll({ rule: { kind: "variable_declarator" } });
+	for (const decl of declarators) {
+		const nameNode = decl.field("name");
+		if (!nameNode || !patternBindsName(nameNode, name)) continue;
+		const nameRange = nameNode.range();
+		if (bindingStart >= nameRange.start.index && bindingStart < nameRange.end.index) continue;
+		const scope = enclosingScopeRange(decl);
+		if (scope && rangeContains(scope, pos)) return true;
+	}
+	const functionDecls = root.findAll({ rule: { kind: "function_declaration" } });
+	for (const fn of functionDecls) {
+		const nameNode = fn.field("name");
+		if (!nameNode || nameNode.text() !== name) continue;
+		if (nameNode.range().start.index === bindingStart) continue;
+		const scope = enclosingScopeRange(fn);
+		if (scope && rangeContains(scope, pos)) return true;
+	}
+	for (const kind of NESTED_FN_KINDS) {
+		const fns = root.findAll({ rule: { kind } });
+		for (const fn of fns) {
+			if (!functionRebindsName(fn, name)) continue;
+			const range = fn.range();
+			if (pos >= range.start.index && pos < range.end.index) return true;
+		}
+	}
+	return false;
+}
+function resolvesToSdkFieldLocal(node, bindings, root) {
+	if (node.kind() !== "identifier") return false;
+	const pos = node.range().start.index;
+	return bindings.some((binding) => binding.name === node.text() && rangeContains(binding.scope, pos) && !isShadowedLocalReference(root, binding.name, pos, binding.bindingStart));
+}
+function isSdkFieldExpression(node, sdkFieldRootNames, sdkFieldLocalBindings, root) {
+	if (node.kind() === "identifier") {
+		const pos = node.range().start.index;
+		return sdkFieldRootNames.has(node.text()) && !isInsideAnyRange(pos, collectAllShadowRanges(root, node.text())) || resolvesToSdkFieldLocal(node, sdkFieldLocalBindings, root);
+	}
+	if (node.kind() === "member_expression") {
+		const object = node.field("object");
+		return object ? isSdkFieldExpression(object, sdkFieldRootNames, sdkFieldLocalBindings, root) : false;
+	}
+	if (node.kind() === "call_expression") {
+		const object = findMemberCallObject(node);
+		return object ? isSdkFieldExpression(object, sdkFieldRootNames, sdkFieldLocalBindings, root) : false;
+	}
+	return false;
+}
+function collectSdkFieldLocalBindings(root, sdkFieldRootNames) {
+	const bindings = [];
+	let changed = true;
+	while (changed) {
+		changed = false;
+		const declarators = root.findAll({ rule: { kind: "variable_declarator" } });
+		for (const decl of declarators) {
+			const name = decl.field("name");
+			const value = decl.field("value");
+			if (!name || name.kind() !== "identifier" || !value) continue;
+			const bindingStart = name.range().start.index;
+			if (bindings.some((binding) => binding.bindingStart === bindingStart)) continue;
+			if (!isSdkFieldExpression(value, sdkFieldRootNames, bindings, root)) continue;
+			const rootRange = root.range();
+			const scope = enclosingScopeRange(decl) ?? [rootRange.start.index, rootRange.end.index];
+			bindings.push({
+				name: name.text(),
+				bindingStart,
+				scope
+			});
+			changed = true;
+		}
+	}
+	return bindings;
+}
+function isSdkFieldMemberCall(call, sdkFieldRootNames, sdkFieldLocalBindings, root) {
+	const object = findMemberCallObject(call);
+	return object ? isSdkFieldExpression(object, sdkFieldRootNames, sdkFieldLocalBindings, root) : false;
+}
+function localBindingRootScope(root) {
+	const rootRange = root.range();
+	return [rootRange.start.index, rootRange.end.index];
+}
+function collectLocalCallbackBindings(root) {
+	const rootScope = localBindingRootScope(root);
+	const bindings = [];
+	const declarators = root.findAll({ rule: { kind: "variable_declarator" } });
+	for (const decl of declarators) {
+		const name = decl.field("name");
+		const value = decl.field("value");
+		if (!name || name.kind() !== "identifier" || !value || !isFunctionNode(value)) continue;
+		bindings.push({
+			name: name.text(),
+			fn: value,
+			bindingStart: name.range().start.index,
+			scope: enclosingScopeRange(decl) ?? rootScope
+		});
+	}
+	const functionDecls = root.findAll({ rule: { kind: "function_declaration" } });
+	for (const fn of functionDecls) {
+		const name = fn.field("name");
+		if (!name || name.kind() !== "identifier") continue;
+		bindings.push({
+			name: name.text(),
+			fn,
+			bindingStart: name.range().start.index,
+			scope: enclosingScopeRange(fn) ?? rootScope
+		});
+	}
+	return bindings;
+}
+function collectLocalObjectBindings(root) {
+	const rootScope = localBindingRootScope(root);
+	const bindings = [];
+	const declarators = root.findAll({ rule: { kind: "variable_declarator" } });
+	for (const decl of declarators) {
+		const name = decl.field("name");
+		const value = decl.field("value");
+		if (!name || name.kind() !== "identifier" || value?.kind() !== "object") continue;
+		bindings.push({
+			name: name.text(),
+			object: value,
+			bindingStart: name.range().start.index,
+			scope: enclosingScopeRange(decl) ?? rootScope
+		});
+	}
+	return bindings;
+}
+function resolveLocalCallbackBinding(node, bindings, root) {
+	if (node.kind() !== "identifier") return null;
+	const pos = node.range().start.index;
+	return bindings.find((binding) => binding.name === node.text() && rangeContains(binding.scope, pos) && !isShadowedLocalReference(root, binding.name, pos, binding.bindingStart)) ?? null;
+}
+function resolveLocalObjectBinding(node, bindings, root) {
+	if (node.kind() !== "identifier") return null;
+	const pos = node.range().start.index;
+	return bindings.find((binding) => binding.name === node.text() && rangeContains(binding.scope, pos) && !isShadowedLocalReference(root, binding.name, pos, binding.bindingStart)) ?? null;
+}
+function transformPrincipalCallbackNode(node, edits, callbackBindings, transformedCallbackStarts, typeContext, root) {
+	if (isFunctionNode(node)) {
+		transformPrincipalCallbackParam(node, edits, typeContext);
+		return true;
+	}
+	const binding = resolveLocalCallbackBinding(node, callbackBindings, root);
+	if (!binding) return false;
+	const start = binding.fn.range().start.index;
+	if (!transformedCallbackStarts.has(start)) {
+		transformedCallbackStarts.add(start);
+		transformPrincipalCallbackParam(binding.fn, edits, typeContext);
+	}
+	return true;
+}
+function transformHookCallbackObject(node, edits, callbackBindings, transformedCallbackStarts, typeContext, root) {
+	if (node.kind() !== "object") return;
+	for (const child of node.children()) {
+		if (child.kind() === "method_definition") {
+			const key = propertyName(child);
+			if (key === "create" || key === "update") transformPrincipalCallbackParam(child, edits, typeContext);
+			continue;
+		}
+		if (child.kind() !== "pair") continue;
+		const key = child.field("key")?.text();
+		const value = child.field("value");
+		if (!value) continue;
+		if (key === "create" || key === "update") {
+			if (!transformPrincipalCallbackNode(value, edits, callbackBindings, transformedCallbackStarts, typeContext, root) && value.kind() === "object") transformHookCallbackObject(value, edits, callbackBindings, transformedCallbackStarts, typeContext, root);
+		} else if (value.kind() === "object") transformHookCallbackObject(value, edits, callbackBindings, transformedCallbackStarts, typeContext, root);
+	}
+}
+function transformHookCallbackConfigNode(node, edits, callbackBindings, objectBindings, transformedCallbackStarts, transformedObjectStarts, typeContext, root) {
+	if (node.kind() === "object") {
+		transformHookCallbackObject(node, edits, callbackBindings, transformedCallbackStarts, typeContext, root);
+		return true;
+	}
+	const binding = resolveLocalObjectBinding(node, objectBindings, root);
+	if (!binding) return false;
+	const start = binding.object.range().start.index;
+	if (!transformedObjectStarts.has(start)) {
+		transformedObjectStarts.add(start);
+		transformHookCallbackObject(binding.object, edits, callbackBindings, transformedCallbackStarts, typeContext, root);
+	}
+	return true;
+}
+function transformValidateCallbackNode(node, edits, callbackBindings, transformedCallbackStarts, typeContext, root) {
+	if (transformPrincipalCallbackNode(node, edits, callbackBindings, transformedCallbackStarts, typeContext, root)) return;
+	if (node.kind() === "array") {
+		for (const child of node.children()) transformValidateCallbackNode(child, edits, callbackBindings, transformedCallbackStarts, typeContext, root);
+		return;
+	}
+	if (node.kind() !== "object") return;
+	for (const child of node.children()) {
+		if (child.kind() === "method_definition") {
+			transformPrincipalCallbackParam(child, edits, typeContext);
+			continue;
+		}
+		if (child.kind() !== "pair") continue;
+		const value = child.field("value");
+		if (value) transformValidateCallbackNode(value, edits, callbackBindings, transformedCallbackStarts, typeContext, root);
+	}
+}
+function transformPrincipalCallbacksInCall(call, edits, sdkFieldRootNames, sdkFieldLocalBindings, callbackBindings, objectBindings, transformedCallbackStarts, transformedObjectStarts, typeContext, root) {
+	const memberName = findMemberCallName(call);
+	if (memberName !== "hooks" && memberName !== "validate") return;
+	if (!isSdkFieldMemberCall(call, sdkFieldRootNames, sdkFieldLocalBindings, root)) return;
+	const args = call.field("arguments");
+	if (!args) return;
+	if (memberName === "hooks") {
+		for (const arg of args.children()) if (transformHookCallbackConfigNode(arg, edits, callbackBindings, objectBindings, transformedCallbackStarts, transformedObjectStarts, typeContext, root)) break;
+		return;
+	}
+	for (const arg of args.children()) transformValidateCallbackNode(arg, edits, callbackBindings, transformedCallbackStarts, typeContext, root);
+}
+function transformParseArgsObject(call, edits, sdkFieldRootNames, sdkFieldLocalBindings, root) {
+	if (findMemberCallName(call) !== "parse") return;
+	if (!isSdkFieldMemberCall(call, sdkFieldRootNames, sdkFieldLocalBindings, root)) return;
+	const objArg = call.field("arguments")?.children().find((c) => c.kind() === "object");
+	if (!objArg) return;
+	for (const child of objArg.children()) {
+		const kind = child.kind();
+		if (kind === "pair") {
+			const key = child.field("key");
+			if (key?.text() === "user") edits.push(key.replace("invoker"));
+		} else if (kind === "shorthand_property_identifier" && child.text() === "user") edits.push(child.replace("invoker: user"));
+	}
 }
 /**
 * Migrate user/actor/invoker types and identifiers to the unified TailorPrincipal.
@@ -388,10 +1351,13 @@ function transformResolverBody(arrowNode, edits) {
 * - Replaces standalone references to `unauthenticatedTailorUser` with `null`. Member-access
 *   forms like `unauthenticatedTailorUser.id` are left alone on purpose so the resulting TS
 *   error after the import is removed points the author at the broken access.
+* - Rewrites actor member accesses from `userId` / `userType` to `id` / `type`.
 * - Renames `user` to `caller` for top-level destructured resolver bodies (`{ input, user }`),
 *   handles aliased pairs (`{ user: currentUser }`) by rewriting only the property name, and
 *   rewrites `<ctx>.user` for non-destructured single-param bodies — respecting variable
 *   shadowing in both directions.
+* - Renames TailorDB hook/validator callback `user` parameters to `invoker`, and rewrites
+*   `.parse({ user: ... })` arguments to `.parse({ invoker: ... })`.
 * @param source - TypeScript source text.
 * @returns Transformed source or null when nothing matched.
 */
@@ -407,21 +1373,32 @@ function transform(source) {
 		}
 	} });
 	const sdkRenameSourceNames = /* @__PURE__ */ new Set();
-	for (const importStmt of sdkImports) for (const { importedName, aliasNode } of iterateImportSpecs(importStmt)) if (TYPE_RENAME_MAP[importedName] && !aliasNode) sdkRenameSourceNames.add(importedName);
-	const typeIdents = tree.findAll({ rule: {
-		kind: "type_identifier",
-		not: { inside: { kind: "import_statement" } }
-	} });
-	for (const id of typeIdents) {
-		if (!sdkRenameSourceNames.has(id.text())) continue;
-		const newName = TYPE_RENAME_MAP[id.text()];
-		edits.push(id.replace(newName));
+	const tailorUserTypeLocalNames = /* @__PURE__ */ new Set();
+	const nullableInvokerAliasLocalNames = /* @__PURE__ */ new Set();
+	const actorTypeAliasLocalNames = /* @__PURE__ */ new Set();
+	const actorTypeLocalNames = /* @__PURE__ */ new Set();
+	const actorTypeValueLocalNames = /* @__PURE__ */ new Set();
+	const sdkNamespaceNames = /* @__PURE__ */ new Set();
+	for (const importStmt of sdkImports) {
+		for (const namespaceName of iterateNamespaceImportLocalNames(importStmt)) sdkNamespaceNames.add(namespaceName);
+		for (const { importedName, aliasNode, localName } of iterateImportSpecs(importStmt)) {
+			if (TYPE_RENAME_MAP[importedName] && !aliasNode) sdkRenameSourceNames.add(importedName);
+			if (importedName === "TailorUser") tailorUserTypeLocalNames.add(localName);
+			if (importedName === "TailorActor") actorTypeLocalNames.add(localName);
+			if (importedName === "TailorActorType") actorTypeValueLocalNames.add(localName);
+			if (importedName === "TailorInvoker" && aliasNode) nullableInvokerAliasLocalNames.add(localName);
+			if (importedName === "TailorActorType" && aliasNode) actorTypeAliasLocalNames.add(localName);
+		}
 	}
+	const transformedActorPropertyStarts = /* @__PURE__ */ new Set();
+	transformTailorActorTypedMemberAccesses(tree, actorTypeLocalNames, sdkNamespaceNames, edits, transformedActorPropertyStarts);
+	transformTailorActorTypeInitializerLiterals(tree, actorTypeValueLocalNames, sdkNamespaceNames, edits);
+	transformTailorActorTypeBindingComparisons(tree, actorTypeValueLocalNames, sdkNamespaceNames, edits);
 	let importRemoved = false;
 	const globalEmittedRenamed = /* @__PURE__ */ new Set();
 	const unauthenticatedLocalNames = /* @__PURE__ */ new Set();
 	for (const importStmt of sdkImports) {
-		const { newText, touched } = rebuildImportStatement(importStmt, globalEmittedRenamed, unauthenticatedLocalNames);
+		const { newText, touched } = rebuildImportStatement(importStmt, globalEmittedRenamed, unauthenticatedLocalNames, nullableInvokerAliasLocalNames, actorTypeAliasLocalNames);
 		if (!touched) continue;
 		edits.push(importStmt.replace(newText));
 		if (newText === "") importRemoved = true;
@@ -441,7 +1418,20 @@ function transform(source) {
 		}
 	}
 	const createResolverLocalNames = /* @__PURE__ */ new Set();
-	for (const importStmt of sdkImports) for (const { importedName, localName } of iterateImportSpecs(importStmt)) if (importedName === "createResolver") createResolverLocalNames.add(localName);
+	const createExecutorLocalNames = /* @__PURE__ */ new Set();
+	const sdkFieldRootNames = /* @__PURE__ */ new Set();
+	for (const namespaceName of sdkNamespaceNames) sdkFieldRootNames.add(namespaceName);
+	for (const importStmt of sdkImports) for (const { importedName, localName } of iterateImportSpecs(importStmt)) {
+		if (importedName === "createResolver") createResolverLocalNames.add(localName);
+		if (importedName === "createExecutor") createExecutorLocalNames.add(localName);
+		if (importedName === "t" || importedName === "db") sdkFieldRootNames.add(localName);
+	}
+	const sdkFieldLocalBindings = collectSdkFieldLocalBindings(tree, sdkFieldRootNames);
+	const parseContext = {
+		sdkFieldRootNames,
+		sdkFieldLocalBindings,
+		root: tree
+	};
 	for (const localName of createResolverLocalNames) {
 		const shadowRanges = collectAllShadowRanges(tree, localName);
 		const calls = tree.findAll({ rule: {
@@ -458,8 +1448,106 @@ function transform(source) {
 			const pos = callee.range().start.index;
 			if (isInsideAnyRange(pos, shadowRanges)) continue;
 			const arrow = findResolverBodyArrow(call);
-			if (arrow) transformResolverBody(arrow, edits);
+			if (arrow) transformResolverBody(arrow, edits, parseContext);
+		}
+	}
+	for (const namespaceName of sdkNamespaceNames) {
+		const shadowRanges = collectAllShadowRanges(tree, namespaceName);
+		const calls = tree.findAll({ rule: {
+			kind: "call_expression",
+			has: {
+				field: "function",
+				kind: "member_expression",
+				has: {
+					field: "property",
+					kind: "property_identifier",
+					regex: "^createResolver$"
+				}
+			}
+		} });
+		for (const call of calls) {
+			const object = call.field("function")?.field("object");
+			if (!object || object.kind() !== "identifier" || object.text() !== namespaceName) continue;
+			const pos = object.range().start.index;
+			if (isInsideAnyRange(pos, shadowRanges)) continue;
+			const arrow = findResolverBodyArrow(call);
+			if (arrow) transformResolverBody(arrow, edits, parseContext);
+		}
+	}
+	for (const localName of createExecutorLocalNames) {
+		const shadowRanges = collectAllShadowRanges(tree, localName);
+		const calls = tree.findAll({ rule: {
+			kind: "call_expression",
+			has: {
+				field: "function",
+				kind: "identifier",
+				regex: `^${escapeRegex(localName)}$`
+			}
+		} });
+		for (const call of calls) {
+			const callee = call.field("function");
+			if (!callee) continue;
+			const pos = callee.range().start.index;
+			if (isInsideAnyRange(pos, shadowRanges)) continue;
+			for (const fn of findExecutorBodyFunctions(call)) transformExecutorBodyActorAccesses(fn, edits, transformedActorPropertyStarts);
+		}
+	}
+	for (const namespaceName of sdkNamespaceNames) {
+		const shadowRanges = collectAllShadowRanges(tree, namespaceName);
+		const calls = tree.findAll({ rule: {
+			kind: "call_expression",
+			has: {
+				field: "function",
+				kind: "member_expression",
+				has: {
+					field: "property",
+					kind: "property_identifier",
+					regex: "^createExecutor$"
+				}
+			}
+		} });
+		for (const call of calls) {
+			const object = call.field("function")?.field("object");
+			if (!object || object.kind() !== "identifier" || object.text() !== namespaceName) continue;
+			const pos = object.range().start.index;
+			if (isInsideAnyRange(pos, shadowRanges)) continue;
+			for (const fn of findExecutorBodyFunctions(call)) transformExecutorBodyActorAccesses(fn, edits, transformedActorPropertyStarts);
+		}
+	}
+	transformActorTypeComparisonLiterals(tree, edits, transformedActorPropertyStarts);
+	const callbackBindings = collectLocalCallbackBindings(tree);
+	const objectBindings = collectLocalObjectBindings(tree);
+	const typeContext = {
+		bindings: collectLocalCallbackTypeBindings(tree),
+		transformedTypeStarts: /* @__PURE__ */ new Set(),
+		transformedPrincipalTypeStarts: /* @__PURE__ */ new Set(),
+		tailorUserTypeLocalNames,
+		sdkNamespaceNames,
+		sdkFieldRootNames,
+		sdkFieldLocalBindings,
+		root: tree
+	};
+	const transformedCallbackStarts = /* @__PURE__ */ new Set();
+	const transformedObjectStarts = /* @__PURE__ */ new Set();
+	const memberCalls = tree.findAll({ rule: { kind: "call_expression" } });
+	for (const call of memberCalls) {
+		transformPrincipalCallbacksInCall(call, edits, sdkFieldRootNames, sdkFieldLocalBindings, callbackBindings, objectBindings, transformedCallbackStarts, transformedObjectStarts, typeContext, tree);
+		transformParseArgsObject(call, edits, sdkFieldRootNames, sdkFieldLocalBindings, tree);
+	}
+	const typeIdents = tree.findAll({ rule: {
+		kind: "type_identifier",
+		not: { inside: { kind: "import_statement" } }
+	} });
+	for (const id of typeIdents) {
+		if (typeContext.transformedPrincipalTypeStarts.has(id.range().start.index)) continue;
+		const qualifiedReplacement = namespaceQualifiedTypeReplacement(id, sdkNamespaceNames, tree);
+		if (qualifiedReplacement) {
+			edits.push(qualifiedReplacement.target.replace(qualifiedReplacement.text));
+			continue;
 		}
+		const newName = sdkRenameSourceNames.has(id.text()) ? renamedTypeIdentifierText(id.text()) : nullableInvokerAliasLocalNames.has(id.text()) ? renamedTypeIdentifierText("TailorInvoker") : actorTypeAliasLocalNames.has(id.text()) ? renamedTypeIdentifierText("TailorActorType") : null;
+		if (!newName) continue;
+		edits.push(id.replace(newName));
 	}
 	if (edits.length === 0) return null;
 	let result = tree.commitEdits(edits);