@oh-my-pi/pi-coding-agent 15.5.15 → 15.7.0

package/src/discovery/builtin-rules/rs-result-type.md

@@ -0,0 +1,19 @@
+---
+description: Result type aliases must include a defaulted error type parameter
+condition: "type\\s+Result<[A-Za-z_]\\w*>\\s*="
+scope: "tool:edit(*.rs), tool:write(*.rs)"
+---
+
+`Result` aliases must expose the error type as a defaulted parameter.
+
+```rust
+pub type Result<T, E = anyhow::Error> = std::result::Result<T, E>;
+```
+
+Never write:
+
+```rust
+type Result<T> = std::result::Result<T, anyhow::Error>;
+```
+
+The default keeps common call sites short while preserving escape hatches for precise errors.

package/src/discovery/builtin-rules/ts-bare-catch.md

@@ -0,0 +1,38 @@
+---
+description: Use bare `catch {` when the error binding is unused
+condition: "catch \\(_"
+scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
+---
+
+Use bare `catch {}` when the caught value is unused. An underscore-prefixed binding adds noise and still allocates a local name.
+
+## Replace
+
+```typescript
+// Bad
+try {
+	await loadConfig();
+} catch (_err) {
+	return null;
+}
+
+// Good
+try {
+	await loadConfig();
+} catch {
+	return null;
+}
+```
+
+## Keep a real name when used
+
+```typescript
+try {
+	await saveConfig();
+} catch (err) {
+	logger.error("save failed", { err });
+	throw err;
+}
+```
+
+Unused error? Bare `catch`. Used error? Name it for what it carries.

package/src/discovery/builtin-rules/ts-import-type.md

@@ -0,0 +1,42 @@
+---
+description: "Use `import type`, not `import('pkg').Type` in type positions"
+condition: "import\\("
+scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
+---
+
+Use top-level `import type` declarations for type-only dependencies. NEVER write `import("pkg").Type` inside source annotations.
+
+## Why
+
+- Top-level imports expose dependencies immediately.
+- Import sorting and deduplication can manage them.
+- Signatures stay readable and reviewable.
+- Re-exports do not inherit noisy inline paths.
+
+## Avoid
+
+```typescript
+// Bad — inline imports hide dependencies in signatures.
+function run(client: import("some-sdk").Client, input: import("zod/v4").infer<Schema>): Promise<Output>;
+
+// Bad — annotations become path dumps.
+const options: import("some-sdk/config").ClientOptions = { ... };
+```
+
+## Use
+
+```typescript
+import type { Client } from "some-sdk";
+import type { ClientOptions } from "some-sdk/config";
+import type { infer as Infer } from "zod/v4";
+
+function run(client: Client, input: Infer<Schema>): Promise<Output>;
+const options: ClientOptions = { ... };
+```
+
+## Exceptions
+
+- Ambient `.d.ts` globals that must not become modules.
+- Generated files whose generator owns import management.
+
+In normal `.ts` / `.tsx` source, use `import type`.

package/src/discovery/builtin-rules/ts-no-any.md

@@ -0,0 +1,56 @@
+---
+description: "Never use `any` in TypeScript annotations or assertions — use `unknown`, generics, or the actual type"
+condition: ": any|as any"
+scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
+---
+
+Never use `: any` or `as any`. They disable type checking exactly where the boundary needs precision.
+
+## Use instead
+
+- `unknown` for unvalidated input.
+- A domain type when the shape is known.
+- A generic when the caller supplies the shape.
+- A type guard when runtime checks establish shape.
+- `satisfies` for object literals that must match a contract.
+
+## Parameters and returns
+
+```typescript
+// Bad
+function readId(value: any): any {
+	return value.id;
+}
+
+// Good — validate unknown input.
+function readId(value: unknown): string | undefined {
+	if (value && typeof value === "object" && "id" in value) {
+		const candidate = (value as { id: unknown }).id;
+		return typeof candidate === "string" ? candidate : undefined;
+	}
+}
+```
+
+## Assertions
+
+```typescript
+// Bad
+const root = document.getElementById("root") as any;
+root.innerText = "ready";
+
+// Good
+const root = document.getElementById("root") as HTMLElement | null;
+root?.innerText = "ready";
+```
+
+## Object literals
+
+```typescript
+// Bad
+const config = { port: 3000 } as any as ServerConfig;
+
+// Good
+const config = { port: 3000 } satisfies ServerConfig;
+```
+
+If a library boundary truly requires an unchecked cast, use `as unknown as T` with a short reason. Never leave a bare `any`.

package/src/discovery/builtin-rules/ts-no-dynamic-import.md

@@ -0,0 +1,39 @@
+---
+description: "Do not use `await import()` — use static imports unless dynamic loading is unavoidable"
+condition: "await import\\("
+scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
+---
+
+Use static imports for modules known at author time. Reach for `await import()` only when the module specifier is genuinely runtime-selected.
+
+## Why
+
+- Static imports fail during build, not under load.
+- Bundlers, type checkers, and tree shakers see them.
+- The dependency graph remains reviewable.
+- Consumers keep precise module types without casts.
+
+## Avoid
+
+```typescript
+// Bad — the module path is a literal.
+const { createClient } = await import("some-sdk");
+
+// Bad — dynamic import followed by a shape assertion.
+const mod = (await import("./known-module")) as { run?: unknown };
+```
+
+## Use
+
+```typescript
+import { createClient } from "some-sdk";
+import { run } from "./known-module";
+```
+
+## Exceptions
+
+- Plugin loading from a runtime registry.
+- Platform-specific modules that do not exist everywhere.
+- Test cases that intentionally exercise module loading boundaries.
+
+Exception? Add a short comment naming why static import cannot work.

package/src/discovery/builtin-rules/ts-no-return-type.md

@@ -0,0 +1,45 @@
+---
+description: "Do not use `ReturnType<typeof fn>` — name the type explicitly"
+condition: "ReturnType<"
+scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
+---
+
+Do not publish contracts through `ReturnType<typeof fn>`. Name the type at the module that owns the value and import that name at consumers.
+
+## Why
+
+- Named types document the contract directly.
+- Consumers stop coupling to implementation helpers.
+- JSDoc and changelog notes attach to the exported type.
+- Type errors point at the intended API boundary.
+
+## Avoid
+
+```typescript
+// Bad — opaque and coupled to implementation names.
+type Config = Awaited<ReturnType<typeof loadConfig>>;
+type Message = ReturnType<typeof buildMessage>["message"];
+let service: ReturnType<typeof createService> | undefined;
+```
+
+## Use
+
+```typescript
+// In the module that owns the function:
+export interface LoadedConfig {
+	path: string;
+	values: Record<string, unknown>;
+}
+
+export function loadConfig(path: string): Promise<LoadedConfig> { ... }
+
+// At the consumer:
+import type { LoadedConfig } from "./config";
+```
+
+## Exceptions
+
+- Timer handles: `ReturnType<typeof setTimeout>` / `setInterval`.
+- Generic type utilities where the function is a type parameter.
+
+Concrete function? Export a concrete type.

package/src/discovery/builtin-rules/ts-no-tiny-functions.md

@@ -0,0 +1,50 @@
+---
+description: "Do not extract 1-2 line functions that only wrap an expression — inline them"
+condition: "\\{\\s*return [^;{}\\n]+;?\\s*\\}|\\b(?:const|let|var)\\s+[\\w$]+\\s*=\\s*(\\([^)]*\\)|[a-zA-Z_$][\\w$]*)\\s*=>\\s*[^{\\n]+$"
+scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
+interruptMode: never
+---
+
+Do not extract a function whose whole body is one expression or one `return`. Inline it unless the name creates a durable contract.
+
+## Why
+
+- One-line wrappers hide no real behavior.
+- Readers must jump to verify trivial code.
+- The signature freezes a shape too early.
+- Search and type flow work better with inline expressions.
+
+## Avoid
+
+```typescript
+// Bad — pure rename, no behavior added.
+function isEmpty(value: string): boolean {
+	return value.length === 0;
+}
+
+const getDisplayName = (user: User) => user.profile.displayName;
+
+function double(value: number) {
+	return value * 2;
+}
+
+if (isEmpty(name)) { ... }
+```
+
+## Use
+
+```typescript
+if (name.length === 0) { ... }
+const displayName = user.profile.displayName;
+const doubled = value * 2;
+```
+
+## Allowed tiny functions
+
+- Three or more call sites need lockstep behavior.
+- Exported name represents a stable domain concept.
+- Callback identity matters.
+- Type guard preserves narrowing.
+- Public API, test seam, or DI boundary needs indirection.
+
+If none apply, inline it.

package/src/discovery/builtin-rules/ts-promise-with-resolvers.md

@@ -0,0 +1,65 @@
+---
+description: Use Promise.withResolvers() instead of new Promise() constructor
+condition: "new Promise\\("
+scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
+---
+
+Use `Promise.withResolvers()` instead of `new Promise((resolve, reject) => ...)`. It keeps control flow linear and exposes typed resolver functions without callback nesting.
+
+## Basic operation
+
+```typescript
+// Bad
+function delay(ms: number): Promise<void> {
+	return new Promise(resolve => {
+		setTimeout(resolve, ms);
+	});
+}
+
+// Good
+function delay(ms: number): Promise<void> {
+	const { promise, resolve } = Promise.withResolvers<void>();
+	setTimeout(resolve, ms);
+	return promise;
+}
+```
+
+## Event-based completion
+
+```typescript
+// Bad
+function waitForEvent(emitter: EventEmitter, event: string): Promise<unknown> {
+	return new Promise((resolve, reject) => {
+		emitter.once(event, resolve);
+		emitter.once("error", reject);
+	});
+}
+
+// Good
+function waitForEvent(emitter: EventEmitter, event: string): Promise<unknown> {
+	const { promise, resolve, reject } = Promise.withResolvers<unknown>();
+	emitter.once(event, resolve);
+	emitter.once("error", reject);
+	return promise;
+}
+```
+
+## Stored resolver
+
+```typescript
+class Gate {
+	#promise: Promise<void>;
+	#resolve: () => void;
+
+	constructor() {
+		const { promise, resolve } = Promise.withResolvers<void>();
+		this.#promise = promise;
+		this.#resolve = resolve;
+	}
+
+	open(): void { this.#resolve(); }
+	wait(): Promise<void> { return this.#promise; }
+}
+```
+
+Use the constructor only when an API specifically requires the executor form.

package/src/discovery/builtin-rules/ts-set-map.md

@@ -0,0 +1,28 @@
+---
+description: Prefer Record<K, V> for small static literals; use Set/Map for anything dynamic
+condition: "\\bnew\\s+(Set|Map)\\b"
+scope: "tool:edit(**/*.{ts,tsx}), tool:write(**/*.{ts,tsx})"
+interruptMode: never
+---
+
+Use `Record<K, V>` / `Record<K, true>` for small, static string-keyed lookup tables.
+
+Use `Set` / `Map` when keys are dynamic, non-string, inserted or deleted at runtime, or when code needs `.size`, `.clear()`, stable insertion order, or iterator APIs.
+
+```typescript
+// Static literal → Record
+const LABEL_BY_KIND: Record<string, string> = {
+	text: "Text",
+	json: "JSON",
+	binary: "Binary",
+};
+
+// Dynamic membership → Set
+const seen = new Set<string>();
+for (const item of items) {
+	if (seen.has(item.id)) continue;
+	seen.add(item.id);
+}
+```
+
+Small fixed table? `Record`. Runtime collection? `Set` / `Map`.

package/src/discovery/index.ts

@@ -22,6 +22,7 @@ import "../capability/tool";
 // Import providers (each registers itself on import)
 import "./agents-md";
 import "./builtin";
+import "./builtin-defaults";
 import "./claude";
 import "./claude-plugins";
 import "./cline";

package/src/edit/hashline/block-resolver.ts

@@ -0,0 +1,14 @@
+/**
+ * Tree-sitter-backed {@link BlockResolver} for the hashline `replace block N:`
+ * operator. Bridges the pure hashline seam to the native `blockRangeAt`
+ * primitive in `@oh-my-pi/pi-natives`, which infers the language from the file
+ * path and returns the 1-indexed line span of the syntactic block beginning on
+ * the requested line (or `null` when none can be resolved).
+ */
+import type { BlockResolver } from "@oh-my-pi/hashline";
+import { blockRangeAt } from "@oh-my-pi/pi-natives";
+
+export const nativeBlockResolver: BlockResolver = ({ path, text, line }) => {
+	const range = blockRangeAt({ code: text, path, line });
+	return range ? { start: range.startLine, end: range.endLine } : null;
+};

package/src/edit/hashline/diff.ts

@@ -11,6 +11,7 @@
  */
 import {
 	Patch as HashlinePatch,
+	missingSnapshotTagMessage,
 	normalizeToLF,
 	type Patch,
 	type PatchSection,
@@ -21,6 +22,7 @@ import {
 import { resolveToCwd } from "../../tools/path-utils";
 import { generateDiffString } from "../diff";
 import { readEditFileText } from "../read-file";
+import { nativeBlockResolver } from "./block-resolver";
 
 export interface HashlineDiffOptions {
 	/**
@@ -40,10 +42,6 @@ async function readSectionText(absolutePath: string, sectionPath: string): Promi
 	}
 }
 
-function hasAnchorScoped(section: PatchSection): boolean {
-	return section.hasAnchorScopedEdit;
-}
-
 function snapshotMatchesCurrent(snapshot: Snapshot, currentText: string): boolean {
 	return snapshot.text === currentText;
 }
@@ -54,9 +52,10 @@ function validateSectionHash(
 	snapshots: SnapshotStore,
 ): string | null {
 	if (section.fileHash === undefined) {
-		return hasAnchorScoped(section)
-			? `Missing hashline snapshot tag for anchored edit to ${section.path}; use \`¶${section.path}#tag\` from your latest read.`
-			: null;
+		// The snapshot tag is mandatory on every section — head/tail inserts
+		// included — to keep this preview path in lockstep with the apply path
+		// (`Patcher.prepare`), which rejects tagless sections unconditionally.
+		return missingSnapshotTagMessage(section.path);
 	}
 	const snapshot = snapshots.byHash(absolutePath, section.fileHash);
 	if (snapshot && snapshotMatchesCurrent(snapshot, text)) return null;
@@ -76,7 +75,9 @@ export async function computeHashlineSectionDiff(
 		const normalized = normalizeToLF(content);
 		const hashError = validateSectionHash(section, absolutePath, normalized, snapshots);
 		if (hashError) return { error: hashError };
-		const result = options.streaming ? section.applyPartialTo(normalized) : section.applyTo(normalized);
+		const result = options.streaming
+			? section.applyPartialTo(normalized, nativeBlockResolver)
+			: section.applyTo(normalized, nativeBlockResolver);
 		if (normalized === result.text) return { error: `No changes would be made to ${section.path}.` };
 		return generateDiffString(normalized, result.text);
 	} catch (err) {

package/src/edit/hashline/execute.ts

@@ -25,6 +25,7 @@ import { outputMeta } from "../../tools/output-meta";
 import { generateDiffString } from "../diff";
 import { getFileSnapshotStore } from "../file-snapshot-store";
 import type { EditToolDetails, EditToolPerFileResult, LspBatchRequest } from "../renderer";
+import { nativeBlockResolver } from "./block-resolver";
 import { HashlineFilesystem } from "./filesystem";
 import { type HashlineParams, hashlineEditParamsSchema } from "./params";
 
@@ -133,7 +134,7 @@ export async function executeHashlineSingle(
 		batchRequest: options.batchRequest,
 	});
 	const snapshots = getFileSnapshotStore(options.session);
-	const patcher = new Patcher({ fs, snapshots });
+	const patcher = new Patcher({ fs, snapshots, blockResolver: nativeBlockResolver });
 
 	// Single-section fast path: prepare, commit, render.
 	if (patch.sections.length === 1) {

package/src/edit/hashline/index.ts

@@ -1,3 +1,4 @@
+export * from "./block-resolver";
 export * from "./diff";
 export * from "./execute";
 export * from "./filesystem";

package/src/eval/__tests__/shared-executors.test.ts

@@ -492,6 +492,42 @@ display({"label": "A"})`,
 		expect(reloaded.output.trim()).toBe("2");
 	});
 
+	it("loads TypeScript type-only imports in cells and local modules", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-js-type-imports-");
+		const sessionFile = path.join(tempDir.path(), "session.jsonl");
+		const sessionId = `js-type-imports:${crypto.randomUUID()}`;
+		const session = createToolSession(tempDir.path(), sessionFile);
+		const typesPath = path.join(tempDir.path(), "types.ts");
+		const valuesPath = path.join(tempDir.path(), "values.ts");
+		const entryPath = path.join(tempDir.path(), "entry.ts");
+		const typesSpec = JSON.stringify(typesPath);
+		const entrySpec = JSON.stringify(entryPath);
+		await Bun.write(typesPath, "export interface TypeOnly { value: number }\n");
+		await Bun.write(valuesPath, "export interface InlineOnly { value: number }\nexport const imported = 41;\n");
+		await Bun.write(
+			entryPath,
+			[
+				'import type { TypeOnly } from "./types.ts";',
+				'import { type InlineOnly, imported } from "./values.ts";',
+				"export const typeOnly = 1;",
+				"export const inlineType = imported;",
+				"",
+			].join("\n"),
+		);
+
+		const result = await executeJs(
+			`import type { TypeOnly } from ${typesSpec};\nconst mod = await import(${entrySpec});\nreturn mod.typeOnly + mod.inlineType;`,
+			{
+				sessionId,
+				session,
+				sessionFile,
+			},
+		);
+
+		expect(result.exitCode).toBe(0);
+		expect(result.output.trim()).toBe("42");
+	});
+
 	it("refreshes the Python tool proxy when bridge env appears after kernel warm-up", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-py-tool-proxy-");
 		const sessionFile = path.join(tempDir.path(), "session.jsonl");

package/src/eval/js/shared/local-module-loader.ts

@@ -88,7 +88,10 @@ export class LocalModuleLoader {
 
 	async #buildLocalModule(modulePath: string): Promise<LocalModuleEntry> {
 		const rawSource = fs.readFileSync(modulePath, "utf8");
-		const stripped = stripTypeScriptSyntax(rawSource);
+		const stripped = stripTypeScriptSyntax(rawSource, {
+			force: isTypeScriptModulePath(modulePath),
+			loader: stripLoaderForPath(modulePath),
+		});
 		const moduleDir = path.dirname(modulePath);
 		const localDeps = new Set<string>();
 		for (const specifier of collectModuleSourceSpecifiers(stripped)) {
@@ -251,6 +254,15 @@ function isLocalPathSpecifier(source: string): boolean {
 	);
 }
 
+function isTypeScriptModulePath(modulePath: string): boolean {
+	const ext = path.extname(modulePath);
+	return ext === ".ts" || ext === ".tsx" || ext === ".mts";
+}
+
+function stripLoaderForPath(modulePath: string): "ts" | "tsx" {
+	return path.extname(modulePath) === ".tsx" ? "tsx" : "ts";
+}
+
 function isManagedLocalModulePath(target: string): boolean {
 	return (
 		path.isAbsolute(target) &&

package/src/eval/js/shared/rewrite-imports.ts

@@ -75,6 +75,7 @@ function parseProgram(code: string): { program: { body: ReadonlyArray<BabelProgr
 			allowSuperOutsideMethod: true,
 			allowUndeclaredExports: true,
 			errorRecovery: true,
+			plugins: ["typescript"],
 		}) as unknown as { program: { body: ReadonlyArray<BabelProgramNode> } };
 	} catch {
 		return null;
@@ -178,8 +179,7 @@ export function rewriteImports(code: string): string {
 		if (node.type !== "CallExpression") return;
 		const call = node as unknown as { callee?: { type?: string; start?: number; end?: number } };
 		const callee = call.callee;
-		if (!callee || callee.type !== "Import" || typeof callee.start !== "number" || typeof callee.end !== "number")
-			return;
+		if (callee?.type !== "Import" || typeof callee.start !== "number" || typeof callee.end !== "number") return;
 		edits.push({ start: callee.start, end: callee.end, text: "__omp_import__" });
 	});
 
@@ -252,12 +252,7 @@ export function rewriteDynamicImports(code: string, callee = "__omp_import__"):
 		if (node.type !== "CallExpression") return;
 		const call = node as unknown as { callee?: { type?: string; start?: number; end?: number } };
 		const callCallee = call.callee;
-		if (
-			!callCallee ||
-			callCallee.type !== "Import" ||
-			typeof callCallee.start !== "number" ||
-			typeof callCallee.end !== "number"
-		) {
+		if (callCallee?.type !== "Import" || typeof callCallee.start !== "number" || typeof callCallee.end !== "number") {
 			return;
 		}
 		edits.push({ start: callCallee.start, end: callCallee.end, text: callee });
@@ -453,38 +448,48 @@ function requiresAsyncWrapper(code: string): boolean {
 }
 
 /**
- * Strip TypeScript syntax (type annotations, `interface`, `as`, `satisfies`, generics in
- * call expressions, etc.) before the import/lexical rewriters parse the code. We use Bun's
- * native transpiler in `ts` loader mode — fast, no JSX transforms, preserves `import`/
- * `export` declarations so the downstream Babel rewrites keep working.
+ * Strip TypeScript syntax (type annotations, type-only imports/exports, `interface`, `as`,
+ * `satisfies`, generics in call expressions, etc.) before the import/lexical rewriters parse
+ * the code. Bun's native transpiler preserves `import`/`export` declarations, so downstream
+ * Babel rewrites still control module resolution.
  *
- * Skipped when the code parses as plain JavaScript already (Babel can accept it), so the
- * common case avoids an extra transpile pass. We detect "looks like TS" with a cheap regex
- * before invoking the transpiler.
+ * Eval cells use a cheap "looks like TS" heuristic to avoid transpiling ordinary JS. Known
+ * TypeScript modules pass `force` because a file can contain TS-only module syntax such as
+ * `import type` without any value-level type annotations.
  */
-function stripTypeScript(code: string): string {
-	if (!LOOKS_LIKE_TS.test(code)) return code;
+type TypeScriptStripLoader = "ts" | "tsx";
+
+const TS_TRANSPILER = new Bun.Transpiler({ loader: "ts" });
+const TSX_TRANSPILER = new Bun.Transpiler({ loader: "tsx" });
+
+function stripTypeScript(code: string, options: { force?: boolean; loader?: TypeScriptStripLoader } = {}): string {
+	if (!options.force && !LOOKS_LIKE_TS.test(code)) return code;
 	try {
-		return new Bun.Transpiler({ loader: "ts" }).transformSync(code);
+		const transpiler = options.loader === "tsx" ? TSX_TRANSPILER : TS_TRANSPILER;
+		return transpiler.transformSync(code);
 	} catch {
 		// Transpiler failed (e.g. unrecoverable syntax). Hand the original source back so the
 		// downstream rewriter / VM surfaces the real error to the user.
 		return code;
 	}
 }
-export function stripTypeScriptSyntax(code: string): string {
-	return stripTypeScript(code);
+export function stripTypeScriptSyntax(
+	code: string,
+	options: { force?: boolean; loader?: TypeScriptStripLoader } = {},
+): string {
+	return stripTypeScript(code, options);
 }
 
-// Heuristic: any of the obvious TS-only tokens. Plain JS using `as` only inside strings
-// won't match because we require a leading word boundary plus a colon/keyword neighbor.
+// Heuristic: obvious TS-only tokens, including type-only module syntax. Plain JS using `as`
+// only inside strings won't match because we require a leading word boundary plus a
+// colon/keyword neighbor.
 const LOOKS_LIKE_TS =
-	/(?:\binterface\s+\w|\btype\s+\w+\s*=|\b(?:as|satisfies)\s+(?:[A-Z]|\bconst\b)|:\s*(?:string|number|boolean|any|unknown|void|never|object|[A-Z]\w*)\b|<\s*[A-Z]\w*\s*[,>])/;
+	/(?:\bimport\s+type\b|\bexport\s+type\b|\b(?:import|export)\s*\{[^}\n]*\btype\s+\w|\binterface\s+\w|\btype\s+\w+\s*=|\b(?:as|satisfies)\s+(?:[A-Z]|\bconst\b)|:\s*(?:string|number|boolean|any|unknown|void|never|object|[A-Z]\w*)\b|<\s*[A-Z]\w*\s*[,>])/;
 
 export function wrapCode(code: string): { source: string; asyncWrapped: boolean; finalExpressionReturned: boolean } {
-	const stripped = stripTypeScript(code);
-	const finalExpression = returnFinalExpression(stripped);
-	const importsRewritten = rewriteImports(finalExpression.source);
+	const finalExpression = returnFinalExpression(code);
+	const stripped = stripTypeScript(finalExpression.source);
+	const importsRewritten = rewriteImports(stripped);
 	const needsAsyncWrapper = requiresAsyncWrapper(importsRewritten);
 	const rewritten = {
 		source: demoteTopLevelLexicals(importsRewritten, { publishGlobals: needsAsyncWrapper }),