@tailor-platform/sdk-codemod 0.3.0-next.3 → 0.3.0-next.4

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @tailor-platform/sdk-codemod
 
+## 0.3.0-next.4
+
+### Patch Changes
+
+- [#1693](https://github.com/tailor-platform/sdk/pull/1693) [`4751214`](https://github.com/tailor-platform/sdk/commit/4751214c0923e094a844f9ce322279a47e871075) Thanks [@dqn](https://github.com/dqn)! - Rename the TailorDB schema builder from `db.type()` to `db.table()`.
+  
+  Update TailorDB definitions:
+  
+  ```diff
+   import { db } from "@tailor-platform/sdk";
+  
+  -export const user = db.type("User", {
+  +export const user = db.table("User", {
+     name: db.string(),
+   });
+  ```
+
+- [#1704](https://github.com/tailor-platform/sdk/pull/1704) [`9c81d9c`](https://github.com/tailor-platform/sdk/commit/9c81d9c18b1d29b3e9307ea17fe54c8ce55f4dda) Thanks [@dqn](https://github.com/dqn)! - Remove flat value and default exports from `@tailor-platform/sdk/runtime/*` subpath modules. Import each subpath through its self-named namespace export instead, for example `import { iconv } from "@tailor-platform/sdk/runtime/iconv"`.
+  
+  The aggregate `@tailor-platform/sdk/runtime` entry remains named-only, and its deprecated `file.deleteFile` alias is removed in favor of `file.delete`. The v2 codemod rewrites straightforward namespace-star subpath imports, flat named value imports, and aggregate `file.deleteFile` calls to the new namespace-object style.
+  
+  `TailorContextAPI` and `TailorWorkflowAPI` now describe the SDK wrapper objects. Code that types the platform-provided `globalThis.tailor.context` or `globalThis.tailor.workflow` objects directly must use `PlatformContextAPI` or `PlatformWorkflowAPI` instead.
+
 ## 0.3.0-next.3
 
 ### Patch Changes

package/dist/codemods/{ast-grep-helpers-Bfn39biW.js → ast-grep-helpers-D3FXAKNz.js}

@@ -168,4 +168,4 @@ function localDeclarationNames(root) {
 	return names;
 }
 //#endregion
-export { importSpecNames as a, importSource as i, findImportStatements as n, isTypeOnlyImport as o, importBindings as r, localDeclarationNames as s, buildAddNamedImportEdit as t };
+export { importSource as a, localDeclarationNames as c, importBindings as i, collectBindingNames as n, importSpecNames as o, findImportStatements as r, isTypeOnlyImport as s, buildAddNamedImportEdit as t };

package/dist/codemods/v2/auth-connection-token-helper/scripts/transform.js

@@ -1,4 +1,4 @@
-import { a as importSpecNames, i as importSource, n as findImportStatements, o as isTypeOnlyImport, r as importBindings, s as localDeclarationNames, t as buildAddNamedImportEdit } from "../../../ast-grep-helpers-Bfn39biW.js";
+import { a as importSource, c as localDeclarationNames, i as importBindings, o as importSpecNames, r as findImportStatements, s as isTypeOnlyImport, t as buildAddNamedImportEdit } from "../../../ast-grep-helpers-D3FXAKNz.js";
 import { Lang, parse } from "@ast-grep/napi";
 //#region codemods/v2/auth-connection-token-helper/scripts/transform.ts
 const RUNTIME_MODULE = "@tailor-platform/sdk/runtime";

package/dist/codemods/v2/db-type-to-table/scripts/transform.js

@@ -0,0 +1,383 @@
+import { a as importSource, i as importBindings, r as findImportStatements } from "../../../ast-grep-helpers-D3FXAKNz.js";
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/db-type-to-table/scripts/transform.ts
+const SDK_MODULE = "@tailor-platform/sdk";
+function sourceLang(filePath, source) {
+	return filePath.endsWith(".tsx") || filePath.endsWith(".jsx") || source.includes("</") ? Lang.Tsx : Lang.TypeScript;
+}
+function namespaceImportNames(importStmt) {
+	return importStmt.findAll({ rule: { kind: "namespace_import" } }).flatMap((node) => node.children().filter((child) => child.kind() === "identifier")).map((node) => node.text());
+}
+function isInsideImportStatement(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "import_statement") return true;
+		current = current.parent();
+	}
+	return false;
+}
+function isBindingLeafKind(kind) {
+	return kind === "identifier" || kind === "shorthand_property_identifier_pattern";
+}
+function isBindingPatternKind(kind) {
+	return isBindingLeafKind(kind) || kind === "object_pattern" || kind === "array_pattern" || kind === "rest_pattern";
+}
+function collectBindingNodes(node, names, result) {
+	if (isBindingLeafKind(node.kind())) {
+		if (names.has(node.text())) result.push(node);
+		return;
+	}
+	for (const child of node.children()) {
+		if (child.kind() === "property_identifier") continue;
+		if (child.kind() === "=") break;
+		collectBindingNodes(child, names, result);
+	}
+}
+function bindingNodes(node, names) {
+	const result = [];
+	collectBindingNodes(node, names, result);
+	return result;
+}
+function directBindingNodes(node, names) {
+	const result = [];
+	for (const child of node.children()) {
+		if (child.kind() === "=") break;
+		if (isBindingPatternKind(child.kind())) collectBindingNodes(child, names, result);
+	}
+	return result;
+}
+function firstDeclaratorChild(node) {
+	return node.children().find((child) => child.kind() !== "=") ?? null;
+}
+function declaratorValue(node) {
+	const children = node.children();
+	const equalsIndex = children.findIndex((child) => child.kind() === "=");
+	if (equalsIndex === -1) return null;
+	return children.slice(equalsIndex + 1).find((child) => child.kind() !== "comment") ?? null;
+}
+function assignmentTarget(node) {
+	const children = node.children();
+	const equalsIndex = children.findIndex((child) => child.kind() === "=");
+	if (equalsIndex === -1) return null;
+	return children.slice(0, equalsIndex).find((child) => child.kind() !== "comment") ?? null;
+}
+function assignmentValue(node) {
+	const children = node.children();
+	const equalsIndex = children.findIndex((child) => child.kind() === "=");
+	if (equalsIndex === -1) return null;
+	return children.slice(equalsIndex + 1).find((child) => child.kind() !== "comment") ?? null;
+}
+function parameterDefaultTarget(node) {
+	const children = node.children();
+	const equalsIndex = children.findIndex((child) => child.kind() === "=");
+	if (equalsIndex === -1) return null;
+	return children.slice(0, equalsIndex).find((child) => isBindingPatternKind(child.kind())) ?? null;
+}
+function parameterDefaultValue(node) {
+	const children = node.children();
+	const equalsIndex = children.findIndex((child) => child.kind() === "=");
+	if (equalsIndex === -1) return null;
+	return children.slice(equalsIndex + 1).find((child) => child.kind() !== "comment") ?? null;
+}
+function addShadowedRange(shadowedRanges, name, scopeNode) {
+	const range = scopeNode.range();
+	if (!shadowedRanges.has(name)) shadowedRanges.set(name, []);
+	shadowedRanges.get(name).push({
+		start: range.start.index,
+		end: range.end.index
+	});
+}
+function nearestScope(node) {
+	let current = node.parent();
+	while (current) {
+		const kind = current.kind();
+		if (kind === "statement_block" || kind === "program" || kind === "switch_body" || kind === "for_statement" || kind === "for_in_statement") return current;
+		current = current.parent();
+	}
+	return node;
+}
+function functionScope(node) {
+	let current = node.parent();
+	while (current) {
+		const kind = current.kind();
+		if (kind === "function_declaration" || kind === "function_expression" || kind === "arrow_function" || kind === "method_definition" || kind === "program") return current;
+		current = current.parent();
+	}
+	return node;
+}
+function variableDeclarationScope(node) {
+	const declaration = node.parent();
+	if (/^var\b/.test(declaration?.text().trimStart() ?? "")) return functionScope(node);
+	return nearestScope(node);
+}
+function parameterScope(node) {
+	let current = node.parent();
+	while (current) {
+		const kind = current.kind();
+		if (kind === "formal_parameters") {
+			current = current.parent();
+			continue;
+		}
+		if (kind === "function_declaration" || kind === "function_expression" || kind === "arrow_function" || kind === "method_definition") return current;
+		break;
+	}
+	return nearestScope(node);
+}
+function buildShadowedRanges(root, names) {
+	const shadowedRanges = /* @__PURE__ */ new Map();
+	for (const decl of root.findAll({ rule: { kind: "variable_declarator" } })) {
+		if (isInsideImportStatement(decl)) continue;
+		const binding = firstDeclaratorChild(decl);
+		if (!binding) continue;
+		for (const name of bindingNodes(binding, names)) addShadowedRange(shadowedRanges, name.text(), variableDeclarationScope(decl));
+	}
+	for (const decl of root.findAll({ rule: { any: [
+		{ kind: "function_declaration" },
+		{ kind: "class_declaration" },
+		{ kind: "enum_declaration" }
+	] } })) {
+		const name = decl.children().find((child) => child.kind() === "identifier" && names.has(child.text()));
+		if (name) addShadowedRange(shadowedRanges, name.text(), nearestScope(decl));
+	}
+	for (const param of root.findAll({ rule: { any: [{ kind: "required_parameter" }, { kind: "optional_parameter" }] } })) for (const name of directBindingNodes(param, names)) addShadowedRange(shadowedRanges, name.text(), parameterScope(param));
+	for (const arrow of root.findAll({ rule: { kind: "arrow_function" } })) {
+		const children = arrow.children();
+		const arrowIndex = children.findIndex((child) => child.kind() === "=>");
+		if (arrowIndex === -1) continue;
+		for (const child of children.slice(0, arrowIndex)) {
+			if (child.kind() === "=") break;
+			if (!isBindingPatternKind(child.kind())) continue;
+			for (const name of bindingNodes(child, names)) addShadowedRange(shadowedRanges, name.text(), arrow);
+		}
+	}
+	for (const catchClause of root.findAll({ rule: { kind: "catch_clause" } })) for (const name of directBindingNodes(catchClause, names)) addShadowedRange(shadowedRanges, name.text(), catchClause);
+	for (const loop of root.findAll({ rule: { kind: "for_in_statement" } })) {
+		const children = loop.children();
+		const keywordIndex = children.findIndex((child) => child.kind() === "in" || child.kind() === "of");
+		if (keywordIndex === -1) continue;
+		for (const child of children.slice(0, keywordIndex)) for (const name of bindingNodes(child, names)) addShadowedRange(shadowedRanges, name.text(), loop);
+	}
+	return shadowedRanges;
+}
+function isShadowed(node, shadowedRanges) {
+	const ranges = shadowedRanges.get(node.text());
+	if (!ranges) return false;
+	const position = node.range().start.index;
+	return ranges.some((range) => position >= range.start && position < range.end);
+}
+function unwrapExpression(node) {
+	let current = node;
+	while (current) {
+		const kind = current.kind();
+		if (kind === "parenthesized_expression") {
+			current = current.children().find((child) => child.kind() !== "(" && child.kind() !== ")") ?? null;
+			continue;
+		}
+		if (kind === "as_expression" || kind === "satisfies_expression" || kind === "non_null_expression") {
+			current = current.children()[0] ?? null;
+			continue;
+		}
+		if (kind === "type_assertion") {
+			current = current.children().find((child) => child.kind() !== "type_arguments") ?? null;
+			continue;
+		}
+		return current;
+	}
+	return null;
+}
+function isSdkDbMember(object, dbNames, namespaceNames, shadowedRanges) {
+	const unwrapped = unwrapExpression(object);
+	if (!unwrapped) return false;
+	if (unwrapped.kind() === "identifier") return dbNames.has(unwrapped.text()) && !isShadowed(unwrapped, shadowedRanges);
+	if (unwrapped.kind() !== "member_expression") return false;
+	const base = unwrapExpression(unwrapped.field("object"));
+	const property = memberProperty(unwrapped);
+	return base?.kind() === "identifier" && namespaceNames.has(base.text()) && !isShadowed(base, shadowedRanges) && property?.text() === "db";
+}
+function memberProperty(member) {
+	const children = member.children();
+	for (let index = children.length - 1; index >= 0; index -= 1) {
+		const child = children[index];
+		if (child.kind() === "property_identifier") return child;
+	}
+	return member.field("property");
+}
+function typeStringLiteral(node) {
+	if (!node) return null;
+	const kind = node.kind();
+	if (kind !== "string" && kind !== "template_string") return null;
+	const fragments = node.children().filter((child) => child.kind() === "string_fragment");
+	return fragments.length === 1 && fragments[0].text() === "type" ? node : null;
+}
+function replaceStringLiteralValue(node, value) {
+	const text = node.text();
+	const quote = text.startsWith("'") ? "'" : text.startsWith("`") ? "`" : "\"";
+	return node.replace(`${quote}${value}${quote}`);
+}
+function hasTypeBuilderUse(root, name, afterIndex) {
+	for (const member of root.findAll({ rule: { kind: "member_expression" } })) {
+		if (member.range().start.index <= afterIndex) continue;
+		if (memberProperty(member)?.text() !== "type") continue;
+		const object = unwrapExpression(member.field("object"));
+		if (object?.kind() === "identifier" && object.text() === name) return true;
+	}
+	for (const subscript of root.findAll({ rule: { kind: "subscript_expression" } })) {
+		if (subscript.range().start.index <= afterIndex) continue;
+		if (!typeStringLiteral(subscript.field("index"))) continue;
+		const object = unwrapExpression(subscript.field("object"));
+		if (object?.kind() === "identifier" && object.text() === name) return true;
+	}
+	return false;
+}
+function transform(source, filePath) {
+	if (!source.includes("type") || !source.includes(SDK_MODULE)) return null;
+	let root;
+	try {
+		root = parse(sourceLang(filePath, source), source).root();
+	} catch {
+		return null;
+	}
+	const imports = findImportStatements(root).filter((importStmt) => importSource(importStmt) === SDK_MODULE);
+	if (imports.length === 0) return null;
+	const dbNames = /* @__PURE__ */ new Set();
+	const namespaceNames = /* @__PURE__ */ new Set();
+	for (const importStmt of imports) {
+		for (const binding of importBindings(importStmt)) if (binding.importedName === "db") dbNames.add(binding.localName);
+		for (const name of namespaceImportNames(importStmt)) namespaceNames.add(name);
+	}
+	if (dbNames.size === 0 && namespaceNames.size === 0) return null;
+	const shadowedRanges = buildShadowedRanges(root, /* @__PURE__ */ new Set([...dbNames, ...namespaceNames]));
+	const edits = [];
+	for (const member of root.findAll({ rule: { kind: "member_expression" } })) {
+		const property = memberProperty(member);
+		if (property?.text() !== "type") continue;
+		if (!isSdkDbMember(member.field("object"), dbNames, namespaceNames, shadowedRanges)) continue;
+		edits.push(property.replace("table"));
+	}
+	for (const subscript of root.findAll({ rule: { kind: "subscript_expression" } })) {
+		const index = typeStringLiteral(subscript.field("index"));
+		if (!index) continue;
+		if (!isSdkDbMember(subscript.field("object"), dbNames, namespaceNames, shadowedRanges)) continue;
+		edits.push(replaceStringLiteralValue(index, "table"));
+	}
+	return edits.length > 0 ? root.commitEdits(edits) : null;
+}
+function lineForIndex(source, index) {
+	return source.slice(0, index).split(/\r\n|\r|\n/).length;
+}
+function excerptAtIndex(source, index) {
+	const lineStart = Math.max(source.lastIndexOf("\n", index - 1) + 1, 0);
+	const lineEnd = source.indexOf("\n", index);
+	return source.slice(lineStart, lineEnd === -1 ? source.length : lineEnd).trim();
+}
+function objectPatternHasTypeProperty(pattern) {
+	return pattern.findAll({ rule: { any: [{
+		kind: "property_identifier",
+		regex: "^type$"
+	}, {
+		kind: "shorthand_property_identifier_pattern",
+		regex: "^type$"
+	}] } }).some((node) => node.text() === "type");
+}
+function namespaceDbAliasBindings(pattern) {
+	const aliases = [];
+	for (const child of pattern.children()) {
+		if (child.kind() === "shorthand_property_identifier_pattern" && child.text() === "db") {
+			aliases.push(child);
+			continue;
+		}
+		if (child.kind() !== "pair_pattern") continue;
+		if (child.field("key")?.text() !== "db") continue;
+		const value = child.field("value");
+		if (value?.kind() === "identifier") aliases.push(value);
+	}
+	return aliases;
+}
+function isSdkNamespaceMember(node, namespaceNames, shadowedRanges) {
+	const unwrapped = unwrapExpression(node);
+	return unwrapped?.kind() === "identifier" && namespaceNames.has(unwrapped.text()) && !isShadowed(unwrapped, shadowedRanges);
+}
+function reviewFindings(source, filePath, relativePath) {
+	if (!source.includes("type") || !source.includes(SDK_MODULE)) return [];
+	let root;
+	try {
+		root = parse(sourceLang(filePath, source), source).root();
+	} catch {
+		return [];
+	}
+	const imports = findImportStatements(root).filter((importStmt) => importSource(importStmt) === SDK_MODULE);
+	if (imports.length === 0) return [];
+	const dbNames = /* @__PURE__ */ new Set();
+	const namespaceNames = /* @__PURE__ */ new Set();
+	for (const importStmt of imports) {
+		for (const binding of importBindings(importStmt)) if (binding.importedName === "db") dbNames.add(binding.localName);
+		for (const name of namespaceImportNames(importStmt)) namespaceNames.add(name);
+	}
+	if (dbNames.size === 0 && namespaceNames.size === 0) return [];
+	const shadowedRanges = buildShadowedRanges(root, /* @__PURE__ */ new Set([...dbNames, ...namespaceNames]));
+	const findings = [];
+	for (const decl of root.findAll({ rule: { kind: "variable_declarator" } })) {
+		const binding = firstDeclaratorChild(decl);
+		if (binding?.kind() !== "object_pattern" || !objectPatternHasTypeProperty(binding)) continue;
+		if (!isSdkDbMember(declaratorValue(decl), dbNames, namespaceNames, shadowedRanges)) continue;
+		findings.push({
+			file: relativePath,
+			line: lineForIndex(source, binding.range().start.index),
+			message: "Review destructured db.type builder usage and migrate it to db.table.",
+			excerpt: excerptAtIndex(source, binding.range().start.index)
+		});
+	}
+	for (const decl of root.findAll({ rule: { kind: "variable_declarator" } })) {
+		const binding = firstDeclaratorChild(decl);
+		if (binding?.kind() !== "object_pattern") continue;
+		if (!isSdkNamespaceMember(declaratorValue(decl), namespaceNames, shadowedRanges)) continue;
+		for (const alias of namespaceDbAliasBindings(binding)) {
+			if (!hasTypeBuilderUse(root, alias.text(), decl.range().end.index)) continue;
+			findings.push({
+				file: relativePath,
+				line: lineForIndex(source, binding.range().start.index),
+				message: "Review SDK db alias usage and migrate db.type builder calls to db.table.",
+				excerpt: excerptAtIndex(source, binding.range().start.index)
+			});
+		}
+	}
+	for (const decl of root.findAll({ rule: { kind: "variable_declarator" } })) {
+		const binding = firstDeclaratorChild(decl);
+		if (binding?.kind() !== "identifier") continue;
+		if (!isSdkDbMember(declaratorValue(decl), dbNames, namespaceNames, shadowedRanges)) continue;
+		if (!hasTypeBuilderUse(root, binding.text(), decl.range().end.index)) continue;
+		findings.push({
+			file: relativePath,
+			line: lineForIndex(source, binding.range().start.index),
+			message: "Review SDK db alias usage and migrate db.type builder calls to db.table.",
+			excerpt: excerptAtIndex(source, binding.range().start.index)
+		});
+	}
+	for (const assignment of root.findAll({ rule: { kind: "assignment_expression" } })) {
+		const target = assignmentTarget(assignment);
+		if (target?.kind() !== "identifier") continue;
+		if (!isSdkDbMember(assignmentValue(assignment), dbNames, namespaceNames, shadowedRanges)) continue;
+		if (!hasTypeBuilderUse(root, target.text(), assignment.range().end.index)) continue;
+		findings.push({
+			file: relativePath,
+			line: lineForIndex(source, assignment.range().start.index),
+			message: "Review SDK db alias usage and migrate db.type builder calls to db.table.",
+			excerpt: excerptAtIndex(source, assignment.range().start.index)
+		});
+	}
+	for (const param of root.findAll({ rule: { any: [{ kind: "required_parameter" }, { kind: "optional_parameter" }] } })) {
+		const target = parameterDefaultTarget(param);
+		if (target?.kind() !== "identifier") continue;
+		if (!isSdkDbMember(parameterDefaultValue(param), dbNames, namespaceNames, shadowedRanges)) continue;
+		if (!hasTypeBuilderUse(root, target.text(), param.range().end.index)) continue;
+		findings.push({
+			file: relativePath,
+			line: lineForIndex(source, param.range().start.index),
+			message: "Review SDK db alias usage and migrate db.type builder calls to db.table.",
+			excerpt: excerptAtIndex(source, param.range().start.index)
+		});
+	}
+	return findings;
+}
+//#endregion
+export { transform as default, reviewFindings };

package/dist/codemods/v2/runtime-globals-opt-in/scripts/transform.js

@@ -1,4 +1,4 @@
-import { n as findImportStatements, r as importBindings, s as localDeclarationNames, t as buildAddNamedImportEdit } from "../../../ast-grep-helpers-Bfn39biW.js";
+import { c as localDeclarationNames, i as importBindings, r as findImportStatements, t as buildAddNamedImportEdit } from "../../../ast-grep-helpers-D3FXAKNz.js";
 import { Lang, parse } from "@ast-grep/napi";
 //#region codemods/v2/runtime-globals-opt-in/scripts/transform.ts
 const RUNTIME_MODULE = "@tailor-platform/sdk/runtime";

package/dist/codemods/v2/runtime-subpath-namespace/scripts/transform.js

@@ -0,0 +1,792 @@
+import { a as importSource, c as localDeclarationNames, i as importBindings, n as collectBindingNames, o as importSpecNames, r as findImportStatements, s as isTypeOnlyImport } from "../../../ast-grep-helpers-D3FXAKNz.js";
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/runtime-subpath-namespace/scripts/transform.ts
+const MODULES_BY_SOURCE = new Map([
+	{
+		namespace: "iconv",
+		source: "@tailor-platform/sdk/runtime/iconv",
+		members: {
+			convert: "convert",
+			convertBuffer: "convertBuffer",
+			decode: "decode",
+			encode: "encode",
+			encodings: "encodings",
+			Iconv: "Iconv"
+		}
+	},
+	{
+		namespace: "secretmanager",
+		source: "@tailor-platform/sdk/runtime/secretmanager",
+		members: {
+			getSecrets: "getSecrets",
+			getSecret: "getSecret"
+		}
+	},
+	{
+		namespace: "authconnection",
+		source: "@tailor-platform/sdk/runtime/authconnection",
+		members: { getConnectionToken: "getConnectionToken" }
+	},
+	{
+		namespace: "idp",
+		source: "@tailor-platform/sdk/runtime/idp",
+		members: { Client: "Client" }
+	},
+	{
+		namespace: "workflow",
+		source: "@tailor-platform/sdk/runtime/workflow",
+		members: {
+			triggerWorkflow: "triggerWorkflow",
+			resumeWorkflow: "resumeWorkflow",
+			triggerJobFunction: "triggerJobFunction",
+			wait: "wait",
+			resolve: "resolve"
+		}
+	},
+	{
+		namespace: "context",
+		source: "@tailor-platform/sdk/runtime/context",
+		members: { getInvoker: "getInvoker" }
+	},
+	{
+		namespace: "file",
+		source: "@tailor-platform/sdk/runtime/file",
+		members: {
+			upload: "upload",
+			download: "download",
+			downloadAsBase64: "downloadAsBase64",
+			delete: "delete",
+			deleteFile: "delete",
+			getMetadata: "getMetadata",
+			downloadStream: "downloadStream",
+			uploadStream: "uploadStream"
+		}
+	},
+	{
+		namespace: "aigateway",
+		source: "@tailor-platform/sdk/runtime/aigateway",
+		members: { get: "get" }
+	}
+].map((mod) => [mod.source, mod]));
+const AGGREGATE_RUNTIME_SOURCE = "@tailor-platform/sdk/runtime";
+const JSX_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".jsx"]);
+const JS_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".js",
+	".mjs",
+	".cjs"
+]);
+function quickFilter(source) {
+	return source.includes(AGGREGATE_RUNTIME_SOURCE);
+}
+function sourceLang(filePath, source) {
+	const lower = filePath.toLowerCase();
+	const extension = lower.slice(lower.lastIndexOf("."));
+	if (JSX_FILE_EXTENSIONS.has(extension)) return Lang.Tsx;
+	if (JS_FILE_EXTENSIONS.has(extension) && /<>|<\/>|<[A-Za-z][\w.$:-]/.test(source)) return Lang.Tsx;
+	return Lang.TypeScript;
+}
+function importClause(importStmt) {
+	return importStmt.children().find((child) => child.kind() === "import_clause") ?? null;
+}
+function hasDefaultImport(importStmt) {
+	return importClause(importStmt)?.children().some((child) => child.kind() === "identifier") ?? false;
+}
+function namespaceImportName(importStmt) {
+	return importClause(importStmt)?.children().find((child) => child.kind() === "namespace_import")?.children().find((child) => child.kind() === "identifier")?.text() ?? null;
+}
+function formatImport(source, namedSpecs, typeOnly = false, attributeText = "") {
+	const importKeyword = typeOnly ? "import type" : "import";
+	const named = namedSpecs.length > 0 ? `{ ${namedSpecs.join(", ")} }` : null;
+	const attributes = attributeText === "" ? "" : ` ${attributeText}`;
+	if (named) return `${importKeyword} ${named} from "${source}"${attributes};`;
+	return "";
+}
+function importAttributeText(importStmt) {
+	return importStmt.children().find((child) => child.kind() === "import_attribute")?.text() ?? "";
+}
+function replaceImportStatement(importStmt, nextText, sourceText) {
+	if (nextText !== "") return importStmt.replace(nextText);
+	const range = importStmt.range();
+	let endPos = range.end.index;
+	if (sourceText[endPos] === "\r" && sourceText[endPos + 1] === "\n") endPos += 2;
+	else if (sourceText[endPos] === "\n") endPos += 1;
+	return {
+		startPos: range.start.index,
+		endPos,
+		insertedText: ""
+	};
+}
+function isInsideImportStatement(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "import_statement") return true;
+		current = current.parent();
+	}
+	return false;
+}
+function isInsideExportSpecifier(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "export_specifier") return true;
+		if (current.kind() === "export_statement") return false;
+		current = current.parent();
+	}
+	return false;
+}
+function isInsideTypeQuery(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "type_query") return true;
+		if (current.kind() === "statement_block" || current.kind() === "program") return false;
+		current = current.parent();
+	}
+	return false;
+}
+function isJsxTagName(node) {
+	const parentKind = node.parent()?.kind();
+	return parentKind === "jsx_opening_element" || parentKind === "jsx_self_closing_element" || parentKind === "jsx_closing_element";
+}
+function sameNode(left, right) {
+	if (!left) return false;
+	const leftRange = left.range();
+	const rightRange = right.range();
+	return leftRange.start.index === rightRange.start.index && leftRange.end.index === rightRange.end.index;
+}
+function typeParameterName(typeParameter) {
+	return typeParameter.children().find((child) => child.kind() === "type_identifier") ?? null;
+}
+function typeParametersDeclare(typeParameters, name) {
+	return typeParameters.children().some((child) => child.kind() === "type_parameter" && typeParameterName(child)?.text() === name);
+}
+function isTypeParameterScoped(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "type_parameter" && sameNode(typeParameterName(current), node)) return true;
+		const typeParameters = current.children().find((child) => child.kind() === "type_parameters");
+		if (typeParameters && typeParametersDeclare(typeParameters, node.text())) return true;
+		current = current.parent();
+	}
+	return false;
+}
+function isNestedTypeMember(node) {
+	const parent = node.parent();
+	if (parent?.kind() !== "nested_type_identifier") return false;
+	return !sameNode(parent.children().find((child) => child.kind() === "identifier" || child.kind() === "type_identifier"), node);
+}
+function localTypeScopeDeclarationNames(root) {
+	const names = /* @__PURE__ */ new Set();
+	for (const node of root.findAll({ rule: { any: [
+		{ kind: "type_parameter" },
+		{ kind: "infer_type" },
+		{ kind: "mapped_type_clause" }
+	] } })) {
+		const name = node.children().find((child) => child.kind() === "type_identifier");
+		if (name) names.add(name.text());
+	}
+	return names;
+}
+function hasExportSpecifierReference(root, names) {
+	return root.findAll({ rule: { kind: "export_specifier" } }).some((specifier) => specifier.children().some((child) => child.kind() === "identifier" && names.has(child.text())));
+}
+function hasNonTypeQueryTypeReference(root, names) {
+	return root.findAll({ rule: { kind: "type_identifier" } }).some((node) => {
+		if (!names.has(node.text())) return false;
+		if (isInsideImportStatement(node)) return false;
+		if (isInsideExportSpecifier(node)) return false;
+		if (isTypeParameterScoped(node)) return false;
+		if (isNestedTypeMember(node)) return false;
+		return !isInsideTypeQuery(node);
+	});
+}
+function hasNamespaceTypeMemberReference(root, namespaceLocal) {
+	return root.findAll({ rule: { kind: "nested_type_identifier" } }).some((node) => {
+		return node.children().find((child) => child.kind() === "identifier" || child.kind() === "type_identifier")?.text() === namespaceLocal;
+	});
+}
+function findExportStatements(root) {
+	return root.findAll({ rule: { kind: "export_statement" } }).filter((stmt) => stmt.parent()?.kind() === "program").toSorted((a, b) => a.range().start.index - b.range().start.index);
+}
+function aggregateFileImportLocals(imports) {
+	const locals = /* @__PURE__ */ new Set();
+	for (const importStmt of imports) {
+		if (importSource(importStmt) !== AGGREGATE_RUNTIME_SOURCE) continue;
+		for (const binding of importBindings(importStmt)) if (!binding.typeOnly && binding.importedName === "file") locals.add(binding.localName);
+	}
+	return locals;
+}
+function isValueBindingLeafKind(kind) {
+	return kind === "identifier" || kind === "shorthand_property_identifier_pattern";
+}
+function isValueBindingPatternKind(kind) {
+	return isValueBindingLeafKind(kind) || kind === "object_pattern" || kind === "array_pattern" || kind === "rest_pattern";
+}
+function collectValueBindingNames(node, names, result) {
+	if (isValueBindingLeafKind(node.kind())) {
+		if (names.has(node.text())) result.add(node.text());
+		return;
+	}
+	for (const child of node.children()) {
+		if (child.kind() === "property_identifier") continue;
+		if (child.kind() === "=") break;
+		collectValueBindingNames(child, names, result);
+	}
+}
+function valueBindingNames(node, names) {
+	const result = /* @__PURE__ */ new Set();
+	collectValueBindingNames(node, names, result);
+	return result;
+}
+function directValueBindingNames(node, names) {
+	const result = /* @__PURE__ */ new Set();
+	for (const child of node.children()) {
+		if (child.kind() === "=") break;
+		if (isValueBindingPatternKind(child.kind())) collectValueBindingNames(child, names, result);
+	}
+	return result;
+}
+function firstDeclaratorChild(node) {
+	return node.children().find((child) => child.kind() !== "=") ?? null;
+}
+function addShadowedRange(ranges, name, scope) {
+	const range = scope.range();
+	const existing = ranges.get(name) ?? [];
+	existing.push({
+		start: range.start.index,
+		end: range.end.index
+	});
+	ranges.set(name, existing);
+}
+function nearestValueScope(node) {
+	let current = node.parent();
+	while (current) {
+		const kind = current.kind();
+		if (kind === "statement_block" || kind === "program" || kind === "switch_body" || kind === "for_statement" || kind === "for_in_statement") return current;
+		current = current.parent();
+	}
+	return node;
+}
+function functionValueScope(node) {
+	let current = node.parent();
+	while (current) {
+		const kind = current.kind();
+		if (kind === "function_declaration" || kind === "function_expression" || kind === "arrow_function" || kind === "method_definition" || kind === "program") return current;
+		current = current.parent();
+	}
+	return node;
+}
+function variableValueScope(node) {
+	const declaration = node.parent();
+	return /^var\b/.test(declaration?.text().trimStart() ?? "") ? functionValueScope(node) : nearestValueScope(node);
+}
+function parameterValueScope(node) {
+	let current = node.parent();
+	while (current) {
+		const kind = current.kind();
+		if (kind === "formal_parameters") {
+			current = current.parent();
+			continue;
+		}
+		if (kind === "function_declaration" || kind === "function_expression" || kind === "arrow_function" || kind === "method_definition") return current;
+		break;
+	}
+	return nearestValueScope(node);
+}
+function buildShadowedRanges(root, names) {
+	const ranges = /* @__PURE__ */ new Map();
+	for (const decl of root.findAll({ rule: { kind: "variable_declarator" } })) {
+		if (isInsideImportStatement(decl)) continue;
+		const binding = firstDeclaratorChild(decl);
+		if (!binding) continue;
+		for (const name of valueBindingNames(binding, names)) addShadowedRange(ranges, name, variableValueScope(decl));
+	}
+	for (const decl of root.findAll({ rule: { any: [
+		{ kind: "function_declaration" },
+		{ kind: "class_declaration" },
+		{ kind: "enum_declaration" }
+	] } })) {
+		const name = decl.children().find((child) => child.kind() === "identifier" && names.has(child.text()));
+		if (name) addShadowedRange(ranges, name.text(), nearestValueScope(decl));
+	}
+	for (const expression of root.findAll({ rule: { any: [{ kind: "function_expression" }, { kind: "class" }] } })) {
+		const name = expression.children().find((child) => (child.kind() === "identifier" || child.kind() === "type_identifier") && names.has(child.text()));
+		if (name) addShadowedRange(ranges, name.text(), expression);
+	}
+	for (const param of root.findAll({ rule: { any: [{ kind: "required_parameter" }, { kind: "optional_parameter" }] } })) for (const name of directValueBindingNames(param, names)) addShadowedRange(ranges, name, parameterValueScope(param));
+	for (const arrow of root.findAll({ rule: { kind: "arrow_function" } })) {
+		const children = arrow.children();
+		const arrowIndex = children.findIndex((child) => child.kind() === "=>");
+		if (arrowIndex === -1) continue;
+		for (const child of children.slice(0, arrowIndex)) {
+			if (child.kind() === "=") break;
+			if (!isValueBindingPatternKind(child.kind())) continue;
+			for (const name of valueBindingNames(child, names)) addShadowedRange(ranges, name, arrow);
+		}
+	}
+	for (const catchClause of root.findAll({ rule: { kind: "catch_clause" } })) for (const name of directValueBindingNames(catchClause, names)) addShadowedRange(ranges, name, catchClause);
+	for (const loop of root.findAll({ rule: { kind: "for_in_statement" } })) {
+		const children = loop.children();
+		const keywordIndex = children.findIndex((child) => child.kind() === "in" || child.kind() === "of");
+		if (keywordIndex === -1) continue;
+		for (const child of children.slice(0, keywordIndex)) for (const name of valueBindingNames(child, names)) addShadowedRange(ranges, name, loop);
+	}
+	return ranges;
+}
+function isShadowed(node, ranges) {
+	const candidates = ranges.get(node.text());
+	if (!candidates) return false;
+	const position = node.range().start.index;
+	return candidates.some((range) => position >= range.start && position < range.end);
+}
+function isAggregateFileReceiver(node, fileLocals, shadowedRanges) {
+	return node?.kind() === "identifier" && fileLocals.has(node.text()) && !isShadowed(node, shadowedRanges);
+}
+function aggregateFileDeleteAccesses(root, imports) {
+	const fileLocals = aggregateFileImportLocals(imports);
+	if (fileLocals.size === 0) return [];
+	const shadowedRanges = buildShadowedRanges(root, fileLocals);
+	const accesses = [];
+	for (const member of root.findAll({ rule: { kind: "member_expression" } })) {
+		const receiver = member.field("object");
+		const property = member.children().find((child) => child.kind() === "property_identifier");
+		if (isAggregateFileReceiver(receiver, fileLocals, shadowedRanges) && property?.text() === "deleteFile") accesses.push({
+			node: member,
+			property,
+			computed: false
+		});
+	}
+	for (const subscript of root.findAll({ rule: { kind: "subscript_expression" } })) {
+		const receiver = subscript.field("object");
+		const property = subscript.field("index");
+		if (isAggregateFileReceiver(receiver, fileLocals, shadowedRanges) && property?.kind() === "string" && property.text().slice(1, -1) === "deleteFile") accesses.push({
+			node: subscript,
+			property,
+			computed: true
+		});
+	}
+	return accesses;
+}
+function aggregateFileDeleteEdits(root, imports) {
+	return aggregateFileDeleteAccesses(root, imports).map(({ property, computed }) => {
+		if (!computed) return property.replace("delete");
+		const quote = property.text()[0] ?? "\"";
+		return property.replace(`${quote}delete${quote}`);
+	});
+}
+function declaratorSides(node) {
+	const children = node.children();
+	const equalsIndex = children.findIndex((child) => child.kind() === "=");
+	if (equalsIndex === -1) return null;
+	const binding = children.slice(0, equalsIndex).find((child) => child.kind() !== "comment");
+	const value = children.slice(equalsIndex + 1).find((child) => child.kind() !== "comment");
+	return binding && value ? {
+		binding,
+		value
+	} : null;
+}
+function aggregateFileDeleteDestructures(root, imports) {
+	const fileLocals = aggregateFileImportLocals(imports);
+	if (fileLocals.size === 0) return [];
+	const shadowedRanges = buildShadowedRanges(root, fileLocals);
+	return root.findAll({ rule: { kind: "variable_declarator" } }).filter((declarator) => {
+		const sides = declaratorSides(declarator);
+		if (!sides || sides.binding.kind() !== "object_pattern" || !isAggregateFileReceiver(sides.value, fileLocals, shadowedRanges)) return false;
+		return sides.binding.findAll({ rule: { any: [{ kind: "property_identifier" }, { kind: "shorthand_property_identifier_pattern" }] } }).some((property) => property.text() === "deleteFile");
+	});
+}
+function aggregateFileDeleteFindingNodes(root, imports) {
+	return [...aggregateFileDeleteAccesses(root, imports).map((access) => access.node), ...aggregateFileDeleteDestructures(root, imports)];
+}
+function usedNames(root, imports, removedNames) {
+	const names = localDeclarationNames(root);
+	for (const importStmt of imports) for (const binding of importBindings(importStmt)) if (!removedNames.has(binding.localName)) names.add(binding.localName);
+	return names;
+}
+function uniqueNamespaceLocal(mod, root, imports, removedNames) {
+	const names = usedNames(root, imports, removedNames);
+	if (!names.has(mod.namespace)) return mod.namespace;
+	const base = `${mod.namespace}Runtime`;
+	if (!names.has(base)) return base;
+	for (let i = 2;; i++) {
+		const candidate = `${base}${i}`;
+		if (!names.has(candidate)) return candidate;
+	}
+}
+function selfNamespaceSpec(mod, localName) {
+	return localName === mod.namespace ? mod.namespace : `${mod.namespace} as ${localName}`;
+}
+function typeOnlySelfNamespaceSpec(mod, localName) {
+	return `type ${selfNamespaceSpec(mod, localName)}`;
+}
+function existingSelfNamespaceImport(importStmt, mod, statementTypeOnly) {
+	for (const spec of importStmt.findAll({ rule: { kind: "import_specifier" } })) {
+		const names = importSpecNames(spec);
+		if (!names || names.importedName !== mod.namespace) continue;
+		return {
+			localName: names.localName,
+			typeOnly: statementTypeOnly || names.typeOnly
+		};
+	}
+	return null;
+}
+function flatImportsFor(importStmt, mod) {
+	const statementTypeOnly = isTypeOnlyImport(importStmt);
+	const flatImports = [];
+	for (const spec of importStmt.findAll({ rule: { kind: "import_specifier" } })) {
+		const names = importSpecNames(spec);
+		if (!names) continue;
+		const memberName = mod.members[names.importedName];
+		if (!memberName) continue;
+		flatImports.push({
+			localName: names.localName,
+			memberName,
+			typeOnly: statementTypeOnly || names.typeOnly
+		});
+	}
+	return flatImports;
+}
+function plannedValueNamespaceLocal(importStmt, mod, root, imports) {
+	const source = importSource(importStmt);
+	if (!source) return null;
+	for (const candidate of imports) {
+		if (sameNode(candidate, importStmt)) continue;
+		if (importSource(candidate) !== source || isTypeOnlyImport(candidate)) continue;
+		const namespaceName = namespaceImportName(candidate);
+		if (namespaceName) return namespaceName;
+		const existingSelf = existingSelfNamespaceImport(candidate, mod, false);
+		if (existingSelf && !existingSelf.typeOnly) return existingSelf.localName;
+		const valueFlatImports = flatImportsFor(candidate, mod).filter((binding) => !binding.typeOnly);
+		if (valueFlatImports.length === 0) continue;
+		const removedNames = new Set(valueFlatImports.map((binding) => binding.localName));
+		const declaredNames = /* @__PURE__ */ new Set([...localDeclarationNames(root), ...localTypeScopeDeclarationNames(root)]);
+		if (valueFlatImports.some((binding) => declaredNames.has(binding.localName))) continue;
+		if (hasExportSpecifierReference(root, removedNames)) continue;
+		return uniqueNamespaceLocal(mod, root, imports, removedNames);
+	}
+	return null;
+}
+function buildImportReplacement(importStmt, mod, root, imports, sourceText, emittedNamespaceSpecifiers) {
+	const source = importSource(importStmt);
+	if (!source) return null;
+	const statementTypeOnly = isTypeOnlyImport(importStmt);
+	const attributes = importAttributeText(importStmt);
+	const namespaceName = namespaceImportName(importStmt);
+	if (namespaceName) {
+		if (hasNamespaceTypeMemberReference(root, namespaceName)) return null;
+		return {
+			edit: importStmt.replace(formatImport(source, [selfNamespaceSpec(mod, namespaceName)], statementTypeOnly, attributes)),
+			flatImports: [],
+			namespaceLocal: namespaceName
+		};
+	}
+	if (hasDefaultImport(importStmt)) return null;
+	const existingSelf = existingSelfNamespaceImport(importStmt, mod, statementTypeOnly);
+	const flatImports = [];
+	const keptSpecs = [];
+	for (const spec of importStmt.findAll({ rule: { kind: "import_specifier" } })) {
+		const names = importSpecNames(spec);
+		if (!names) continue;
+		const memberName = mod.members[names.importedName];
+		if (memberName) {
+			flatImports.push({
+				localName: names.localName,
+				memberName,
+				typeOnly: statementTypeOnly || names.typeOnly
+			});
+			continue;
+		}
+		keptSpecs.push(spec.text());
+	}
+	if (flatImports.length === 0) return null;
+	const removedNames = new Set(flatImports.map((binding) => binding.localName));
+	const declaredNames = /* @__PURE__ */ new Set([...localDeclarationNames(root), ...localTypeScopeDeclarationNames(root)]);
+	if (flatImports.some((binding) => declaredNames.has(binding.localName))) return null;
+	if (hasExportSpecifierReference(root, removedNames)) return null;
+	if (hasNonTypeQueryTypeReference(root, removedNames)) return null;
+	const flatImportsAreTypeOnly = flatImports.every((binding) => binding.typeOnly);
+	const canUseExistingSelf = existingSelf != null && (!existingSelf.typeOnly || flatImportsAreTypeOnly);
+	const plannedValueLocal = flatImportsAreTypeOnly ? plannedValueNamespaceLocal(importStmt, mod, root, imports) : null;
+	const namespaceLocal = plannedValueLocal ?? (canUseExistingSelf ? existingSelf.localName : uniqueNamespaceLocal(mod, root, imports, removedNames));
+	const namespaceSpecifierKey = [
+		source,
+		namespaceLocal,
+		flatImportsAreTypeOnly ? "type" : "value"
+	].join("\0");
+	const namespaceAlreadyEmitted = emittedNamespaceSpecifiers.has(namespaceSpecifierKey);
+	const needsNamespaceSpecifier = plannedValueLocal == null && !canUseExistingSelf && !namespaceAlreadyEmitted;
+	if (needsNamespaceSpecifier) emittedNamespaceSpecifiers.add(namespaceSpecifierKey);
+	const namespaceSpecifier = flatImportsAreTypeOnly && !statementTypeOnly ? typeOnlySelfNamespaceSpec(mod, namespaceLocal) : selfNamespaceSpec(mod, namespaceLocal);
+	return {
+		edit: replaceImportStatement(importStmt, formatImport(source, needsNamespaceSpecifier ? [namespaceSpecifier, ...keptSpecs] : keptSpecs, statementTypeOnly, attributes), sourceText),
+		flatImports,
+		namespaceLocal
+	};
+}
+function referenceEdits(root, replacements) {
+	const byLocalName = /* @__PURE__ */ new Map();
+	for (const replacement of replacements) for (const binding of replacement.flatImports) byLocalName.set(binding.localName, {
+		namespaceLocal: replacement.namespaceLocal,
+		memberName: binding.memberName,
+		typeOnly: binding.typeOnly
+	});
+	const edits = [];
+	const replacementFor = (name) => {
+		const binding = byLocalName.get(name);
+		return binding ? `${binding.namespaceLocal}.${binding.memberName}` : null;
+	};
+	for (const node of root.findAll({ rule: { kind: "identifier" } })) {
+		if (isInsideImportStatement(node)) continue;
+		if (isInsideExportSpecifier(node)) continue;
+		if (isJsxTagName(node)) continue;
+		if (byLocalName.get(node.text())?.typeOnly && !isInsideTypeQuery(node)) continue;
+		const replacement = replacementFor(node.text());
+		if (!replacement) continue;
+		edits.push(node.replace(replacement));
+	}
+	for (const node of root.findAll({ rule: { kind: "type_identifier" } })) {
+		if (isInsideImportStatement(node)) continue;
+		if (isInsideExportSpecifier(node)) continue;
+		if (!isInsideTypeQuery(node)) continue;
+		if (isTypeParameterScoped(node)) continue;
+		if (isNestedTypeMember(node)) continue;
+		const replacement = replacementFor(node.text());
+		if (!replacement) continue;
+		edits.push(node.replace(replacement));
+	}
+	for (const node of root.findAll({ rule: { kind: "shorthand_property_identifier" } })) {
+		if (byLocalName.get(node.text())?.typeOnly) continue;
+		const replacement = replacementFor(node.text());
+		if (!replacement) continue;
+		edits.push(node.replace(`${node.text()}: ${replacement}`));
+	}
+	return edits;
+}
+/**
+* Rewrite v1 runtime subpath imports to the v2 namespace object exports.
+* @param source - File contents
+* @param filePath - Absolute path to the file
+* @returns Transformed source or null when nothing matched.
+*/
+function transform(source, filePath) {
+	if (!quickFilter(source)) return null;
+	const root = parse(sourceLang(filePath, source), source).root();
+	const imports = findImportStatements(root);
+	const replacements = [];
+	const emittedNamespaceSpecifiers = /* @__PURE__ */ new Set();
+	for (const importStmt of imports) {
+		const sourceName = importSource(importStmt);
+		if (!sourceName) continue;
+		const mod = MODULES_BY_SOURCE.get(sourceName);
+		if (!mod) continue;
+		const replacement = buildImportReplacement(importStmt, mod, root, imports, source, emittedNamespaceSpecifiers);
+		if (replacement) replacements.push(replacement);
+	}
+	const aggregateEdits = aggregateFileDeleteEdits(root, imports);
+	if (replacements.length === 0 && aggregateEdits.length === 0) return null;
+	const edits = [
+		...replacements.map((replacement) => replacement.edit),
+		...referenceEdits(root, replacements),
+		...aggregateEdits
+	];
+	const result = root.commitEdits(edits);
+	return result === source ? null : result;
+}
+function hasRemovedFlatSpecifier(node, mod) {
+	return node.findAll({ rule: { any: [{ kind: "import_specifier" }, { kind: "export_specifier" }] } }).some((spec) => {
+		const names = importSpecNames(spec);
+		return names != null && mod.members[names.importedName] != null;
+	});
+}
+function isExportStar(node) {
+	if (node.children().some((child) => child.kind() === "*")) return true;
+	return node.children().find((child) => child.kind() === "namespace_export")?.children().some((child) => child.kind() === "*") ?? false;
+}
+function literalModuleSource(node) {
+	if (node.kind() === "string") return importSource(node);
+	if (node.kind() !== "template_string") return null;
+	if (node.children().some((child) => child.kind() === "template_substitution")) return null;
+	const text = node.text();
+	return text.startsWith("`") && text.endsWith("`") ? text.slice(1, -1) : null;
+}
+function isSourceScopeNode(node) {
+	const kind = node.kind();
+	return kind === "program" || kind === "statement_block" || kind === "function_declaration" || kind === "arrow_function" || kind === "method_definition";
+}
+function nearestSourceScope(node) {
+	let current = node.parent();
+	while (current) {
+		if (isSourceScopeNode(current)) return current;
+		current = current.parent();
+	}
+	return null;
+}
+function sameRange(left, right) {
+	if (!left) return false;
+	const leftRange = left.range();
+	const rightRange = right.range();
+	return leftRange.start.index === rightRange.start.index && leftRange.end.index === rightRange.end.index;
+}
+function isConstVariableDeclarator(node) {
+	return node.parent()?.children().some((child) => child.kind() === "const") ?? false;
+}
+function sourceConstInitializerContent(node) {
+	const directValue = literalModuleSource(node);
+	if (directValue != null) return directValue;
+	if (node.kind() !== "as_expression" && node.kind() !== "satisfies_expression" && node.kind() !== "parenthesized_expression") return null;
+	for (const child of node.children()) {
+		const childValue = sourceConstInitializerContent(child);
+		if (childValue != null) return childValue;
+	}
+	return null;
+}
+function sourceConstVariableDeclaratorContent(node, name) {
+	if (!isConstVariableDeclarator(node)) return null;
+	const names = /* @__PURE__ */ new Set();
+	collectBindingNames(node, names);
+	if (!names.has(name)) return null;
+	const initializer = node.children().findLast((child) => sourceConstInitializerContent(child) != null);
+	return initializer == null ? null : sourceConstInitializerContent(initializer);
+}
+function bindingNames(node) {
+	const names = /* @__PURE__ */ new Set();
+	collectBindingNames(node, names);
+	return names;
+}
+function sourceStringVariableInScope(scope, name, before) {
+	const bindings = scope.findAll({ rule: { any: [
+		{ kind: "variable_declarator" },
+		{ kind: "required_parameter" },
+		{ kind: "optional_parameter" },
+		{ kind: "catch_clause" }
+	] } }).filter((node) => node.range().start.index < before && sameRange(nearestSourceScope(node), scope)).toSorted((a, b) => b.range().start.index - a.range().start.index);
+	for (const binding of bindings) {
+		if (!bindingNames(binding).has(name)) continue;
+		return binding.kind() === "variable_declarator" ? sourceConstVariableDeclaratorContent(binding, name) : null;
+	}
+}
+function sourceScopedStringVariableContent(identifier) {
+	const name = identifier.text();
+	const before = identifier.range().start.index;
+	let current = identifier.parent();
+	while (current) {
+		if (isSourceScopeNode(current)) {
+			const value = sourceStringVariableInScope(current, name, before);
+			if (value !== void 0) return value;
+		}
+		current = current.parent();
+	}
+	return null;
+}
+function isDynamicImportCall(node) {
+	return node.kind() === "call_expression" && node.children().some((child) => child.kind() === "import");
+}
+function isRequireCall(node) {
+	return node.kind() === "call_expression" && node.children().some((child) => child.kind() === "identifier" && child.text() === "require");
+}
+function isArgumentSyntaxNode(node) {
+	const kind = node.kind();
+	return kind === "(" || kind === ")" || kind === "," || kind === "comment";
+}
+function firstCallArgument(callExpression) {
+	return callExpression.children().find((child) => child.kind() === "arguments")?.children().find((child) => !isArgumentSyntaxNode(child)) ?? null;
+}
+function moduleCallSourceName(callExpression) {
+	const sourceArg = firstCallArgument(callExpression);
+	if (!sourceArg) return null;
+	const sourceName = literalModuleSource(sourceArg);
+	if (sourceName != null) return sourceName;
+	return sourceArg.kind() === "identifier" ? sourceScopedStringVariableContent(sourceArg) : null;
+}
+function dynamicImportSourceName(callExpression) {
+	return moduleCallSourceName(callExpression);
+}
+function dynamicImportExcerptNode(callExpression) {
+	let current = callExpression;
+	while (current.parent()) {
+		const parent = current.parent();
+		if (!parent) break;
+		if (parent.kind() !== "await_expression" && parent.kind() !== "parenthesized_expression" && parent.kind() !== "member_expression") break;
+		current = parent;
+	}
+	return current;
+}
+function dynamicRuntimeImportFindings(root, relativePath) {
+	const findings = [];
+	for (const callExpression of root.findAll({ rule: { kind: "call_expression" } })) {
+		if (!isDynamicImportCall(callExpression)) continue;
+		const sourceName = dynamicImportSourceName(callExpression);
+		if (!sourceName || !MODULES_BY_SOURCE.has(sourceName)) continue;
+		const excerptNode = dynamicImportExcerptNode(callExpression);
+		findings.push({
+			file: relativePath,
+			line: excerptNode.range().start.line + 1,
+			message: "Dynamic runtime subpath import may still access a removed flat value export.",
+			excerpt: excerptNode.text().trim()
+		});
+	}
+	return findings;
+}
+function runtimeRequireFindings(root, relativePath) {
+	const findings = [];
+	for (const callExpression of root.findAll({ rule: { kind: "call_expression" } })) {
+		if (isInsideImportStatement(callExpression)) continue;
+		if (!isRequireCall(callExpression)) continue;
+		const sourceName = moduleCallSourceName(callExpression);
+		if (!sourceName || !MODULES_BY_SOURCE.has(sourceName)) continue;
+		findings.push({
+			file: relativePath,
+			line: callExpression.range().start.line + 1,
+			message: "CommonJS runtime subpath require may still access a removed flat value export.",
+			excerpt: callExpression.text().trim()
+		});
+	}
+	return findings;
+}
+function isImportRequireStatement(importStmt) {
+	return importStmt.children().some((child) => child.kind() === "import_require_clause");
+}
+function reviewFindings(source, filePath, relativePath) {
+	if (!quickFilter(source)) return [];
+	const root = parse(sourceLang(filePath, source), source).root();
+	const imports = findImportStatements(root);
+	const findings = [];
+	findings.push(...dynamicRuntimeImportFindings(root, relativePath));
+	findings.push(...runtimeRequireFindings(root, relativePath));
+	for (const access of aggregateFileDeleteFindingNodes(root, imports)) findings.push({
+		file: relativePath,
+		line: access.range().start.line + 1,
+		message: "Aggregate runtime file namespace still uses the removed deleteFile alias.",
+		excerpt: access.text().trim()
+	});
+	for (const importStmt of imports) {
+		const sourceName = importSource(importStmt);
+		if (!sourceName) continue;
+		const mod = MODULES_BY_SOURCE.get(sourceName);
+		if (!mod) continue;
+		const hasImportRequire = isImportRequireStatement(importStmt);
+		const hasRemovedDefaultImport = hasDefaultImport(importStmt);
+		const hasNamespaceImport = namespaceImportName(importStmt) != null;
+		const hasRemovedFlatImport = hasRemovedFlatSpecifier(importStmt, mod);
+		if (!hasImportRequire && !hasRemovedDefaultImport && !hasNamespaceImport && !hasRemovedFlatImport) continue;
+		findings.push({
+			file: relativePath,
+			line: importStmt.range().start.line + 1,
+			message: hasImportRequire ? "TypeScript runtime subpath import-equals may still access a removed flat value export." : "Runtime subpath import still uses a removed default, namespace-star, or flat value import.",
+			excerpt: importStmt.text().trim()
+		});
+	}
+	for (const exportStmt of findExportStatements(root)) {
+		const sourceName = importSource(exportStmt);
+		if (!sourceName) continue;
+		const mod = MODULES_BY_SOURCE.get(sourceName);
+		if (!mod || !hasRemovedFlatSpecifier(exportStmt, mod) && !isExportStar(exportStmt)) continue;
+		findings.push({
+			file: relativePath,
+			line: exportStmt.range().start.line + 1,
+			message: "Runtime subpath re-export still uses a removed flat value export.",
+			excerpt: exportStmt.text().trim()
+		});
+	}
+	return findings;
+}
+//#endregion
+export { transform as default, reviewFindings };

package/dist/index.js

@@ -116,6 +116,7 @@ const RENAME_BIN_QUOTED_LEGACY_COMMAND_PATTERN = new RegExp([
 ].join(""));
 const V2_NEXT_1 = "2.0.0-next.1";
 const V2_NEXT_2 = "2.0.0-next.2";
+const V2_NEXT_3 = "2.0.0-next.3";
 /** All registered codemods, in registration order. */
 const allCodemods = [
 	{
@@ -494,6 +495,54 @@ const allCodemods = [
 			"wrapper or global tailor.authconnection."
 		].join("\n")
 	},
+	{
+		id: "v2/runtime-subpath-namespace",
+		name: "Runtime subpath imports use namespace objects",
+		description: "Rewrite `@tailor-platform/sdk/runtime/*` namespace-star and flat value imports to self-named namespace imports, and aggregate `file.deleteFile` calls to `file.delete`. `TailorContextAPI` and `TailorWorkflowAPI` now describe SDK wrappers; direct platform globals use `PlatformContextAPI` and `PlatformWorkflowAPI`.",
+		since: "1.0.0",
+		until: "2.0.0",
+		prereleaseUntil: V2_NEXT_3,
+		scriptPath: "v2/runtime-subpath-namespace/scripts/transform.js",
+		filePatterns: ["**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}"],
+		legacyPatterns: [
+			"@tailor-platform/sdk/runtime/iconv",
+			"@tailor-platform/sdk/runtime/secretmanager",
+			"@tailor-platform/sdk/runtime/authconnection",
+			"@tailor-platform/sdk/runtime/idp",
+			"@tailor-platform/sdk/runtime/workflow",
+			"@tailor-platform/sdk/runtime/context",
+			"@tailor-platform/sdk/runtime/file",
+			"@tailor-platform/sdk/runtime/aigateway"
+		],
+		examples: [
+			{
+				before: "import * as iconv from \"@tailor-platform/sdk/runtime/iconv\";\niconv.convert(value, \"UTF-8\", \"Shift_JIS\");",
+				after: "import { iconv } from \"@tailor-platform/sdk/runtime/iconv\";\niconv.convert(value, \"UTF-8\", \"Shift_JIS\");"
+			},
+			{
+				before: "import { get } from \"@tailor-platform/sdk/runtime/aigateway\";\nconst gateway = await get(\"main\");",
+				after: "import { aigateway } from \"@tailor-platform/sdk/runtime/aigateway\";\nconst gateway = await aigateway.get(\"main\");"
+			},
+			{
+				before: "import { file } from \"@tailor-platform/sdk/runtime\";\nawait file.deleteFile(\"ns\", \"Doc\", \"blob\", \"record-id\");",
+				after: "import { file } from \"@tailor-platform/sdk/runtime\";\nawait file.delete(\"ns\", \"Doc\", \"blob\", \"record-id\");"
+			}
+		],
+		prompt: [
+			"In Tailor SDK v2, runtime subpath modules export only a self-named namespace",
+			"object (for example, `iconv` from `@tailor-platform/sdk/runtime/iconv`).",
+			"Default and flat value imports such as",
+			"`import { get } from \"@tailor-platform/sdk/runtime/aigateway\"` are removed.",
+			"The codemod rewrites straightforward namespace-star imports and flat named value",
+			"imports. It also rewrites direct `file.deleteFile` calls on the aggregate runtime",
+			"namespace to `file.delete`. Destructured aggregate `deleteFile` references require",
+			"manual migration. Review any remaining runtime imports manually, especially when",
+			"a local binding or nested scope shadows an imported value, or when",
+			"type-position namespace member references need explicit top-level type imports.",
+			"For direct platform globals, replace `TailorContextAPI` and `TailorWorkflowAPI`",
+			"type references with `PlatformContextAPI` and `PlatformWorkflowAPI` respectively."
+		].join("\n")
+	},
 	{
 		id: "v2/tailordb-namespace",
 		name: "Tailordb → tailordb (lowercase ambient namespace)",
@@ -518,6 +567,32 @@ const allCodemods = [
 			"declarations automatically on SDK import."
 		].join("\n")
 	},
+	{
+		id: "v2/db-type-to-table",
+		name: "db.type() → db.table()",
+		description: "Rename TailorDB schema builder calls from `db.type()` to `db.table()`. TailorDB schema definitions now use table terminology in SDK projects.",
+		since: "1.0.0",
+		until: "2.0.0",
+		prereleaseUntil: V2_NEXT_3,
+		scriptPath: "v2/db-type-to-table/scripts/transform.js",
+		filePatterns: ["**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}"],
+		legacyPatterns: ["db.type"],
+		examples: [{
+			before: "import { db } from \"@tailor-platform/sdk\";\n\nexport const user = db.type(\"User\", {\n  name: db.string(),\n});",
+			after: "import { db } from \"@tailor-platform/sdk\";\n\nexport const user = db.table(\"User\", {\n  name: db.string(),\n});"
+		}],
+		prompt: [
+			"In Tailor SDK v2, TailorDB schema definitions use db.table(...) instead of",
+			"db.type(...). The codemod rewrites member accesses on db imported from",
+			"@tailor-platform/sdk, including aliases such as `import { db as schema }`.",
+			"It flags destructured builder aliases such as `const { type } = db` and",
+			"local builder aliases such as `const schema = db`, `schema = db`, or",
+			"`function make(schema = db) { ... }` for manual review because the local",
+			"alias may require call-site renaming.",
+			"Review any remaining db.type references and rename SDK TailorDB schema builder",
+			"calls to db.table. Leave unrelated local objects with a .type() method unchanged."
+		].join("\n")
+	},
 	{
 		id: "v2/execute-script-arg",
 		name: "executeScript arg JSON.stringify → value",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tailor-platform/sdk-codemod",
-  "version": "0.3.0-next.3",
+  "version": "0.3.0-next.4",
   "description": "Codemod runner for Tailor Platform SDK upgrades",
   "license": "MIT",
   "repository": {