@elliots/typical-tsc-plugin 0.2.0-beta.1

package/bin/ttsc

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import { execSync } from "child_process";
+
+const tscCommand = `node $(node -p "require.resolve('ts-patch/compiler/tsc.js')") ${process.argv.slice(2).join(" ")}`;
+const patchTsConfig = new URL("../src/patch-tsconfig.cjs", import.meta.url);
+
+execSync(tscCommand, {
+  stdio: "inherit",
+  cwd: process.cwd(),
+  env: { ...process.env, NODE_OPTIONS: `--require ${patchTsConfig.pathname}` },
+});

package/dist/index.d.mts

@@ -0,0 +1,26 @@
+import ts from "typescript";
+import { PluginConfig, ProgramTransformerExtras } from "ts-patch";
+
+//#region src/index.d.ts
+
+/**
+* TSC Program Transformer Plugin for typical.
+*
+* Uses transformProgram to intercept program creation and transform source files
+* before TypeScript processes them. This allows us to inject validators into
+* the source code while maintaining proper TypeScript semantics.
+*
+* Configure in tsconfig.json:
+* {
+*   "compilerOptions": {
+*     "plugins": [
+*       { "transform": "@elliots/typical-tsc-plugin", "transformProgram": true }
+*     ]
+*   }
+* }
+*/
+declare function export_default(program: ts.Program, host: ts.CompilerHost | undefined, _pluginConfig: PluginConfig, {
+  ts: tsInstance
+}: ProgramTransformerExtras): ts.Program;
+//#endregion
+export { export_default as default };

package/dist/index.mjs

@@ -0,0 +1,303 @@
+import { createRequire } from "node:module";
+import { spawn } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadConfig, validateConfig } from "@elliots/typical";
+import deasync from "deasync";
+
+//#region ../compiler/dist/protocol.js
+/**
+* MessagePack-like binary protocol for communicating with the typical compiler.
+* This matches the protocol used by tsgo's --api mode.
+*/
+const MessagePackTypeFixedArray3 = 147;
+const MessagePackTypeBin8 = 196;
+const MessagePackTypeBin16 = 197;
+const MessagePackTypeBin32 = 198;
+const MessagePackTypeU8 = 204;
+function encodeRequest(method, payload) {
+	const methodBuf = Buffer.from(method, "utf8");
+	const payloadStr = JSON.stringify(payload);
+	const payloadBuf = Buffer.from(payloadStr, "utf8");
+	const methodBinSize = getBinEncodingSize(methodBuf.length);
+	const payloadBinSize = getBinEncodingSize(payloadBuf.length);
+	const totalSize = 3 + methodBinSize + methodBuf.length + payloadBinSize + payloadBuf.length;
+	const buf = Buffer.alloc(totalSize);
+	let offset = 0;
+	buf[offset++] = MessagePackTypeFixedArray3;
+	buf[offset++] = MessagePackTypeU8;
+	buf[offset++] = 1;
+	offset = writeBin(buf, offset, methodBuf);
+	offset = writeBin(buf, offset, payloadBuf);
+	return buf;
+}
+function decodeResponse(data) {
+	let offset = 0;
+	if (data[offset++] !== MessagePackTypeFixedArray3) throw new Error(`Expected 0x93, got 0x${data[0].toString(16)}`);
+	if (data[offset++] !== MessagePackTypeU8) throw new Error(`Expected 0xCC for message type`);
+	const messageType = data[offset++];
+	const { value: methodBuf, newOffset: offset2 } = readBin(data, offset);
+	offset = offset2;
+	const method = methodBuf.toString("utf8");
+	const { value: payload, newOffset: offset3 } = readBin(data, offset);
+	return {
+		messageType,
+		method,
+		payload,
+		bytesConsumed: offset3
+	};
+}
+function getBinEncodingSize(length) {
+	if (length < 256) return 2;
+	if (length < 65536) return 3;
+	return 5;
+}
+function writeBin(buf, offset, data) {
+	const length = data.length;
+	if (length < 256) {
+		buf[offset++] = MessagePackTypeBin8;
+		buf[offset++] = length;
+	} else if (length < 65536) {
+		buf[offset++] = MessagePackTypeBin16;
+		buf.writeUInt16BE(length, offset);
+		offset += 2;
+	} else {
+		buf[offset++] = MessagePackTypeBin32;
+		buf.writeUInt32BE(length, offset);
+		offset += 4;
+	}
+	data.copy(buf, offset);
+	return offset + length;
+}
+function readBin(buf, offset) {
+	if (offset >= buf.length) throw new Error("Not enough data: need type byte");
+	const type = buf[offset++];
+	let length;
+	switch (type) {
+		case MessagePackTypeBin8:
+			if (offset >= buf.length) throw new Error("Not enough data: need length byte");
+			length = buf[offset++];
+			break;
+		case MessagePackTypeBin16:
+			if (offset + 2 > buf.length) throw new Error("Not enough data: need 2 length bytes");
+			length = buf.readUInt16BE(offset);
+			offset += 2;
+			break;
+		case MessagePackTypeBin32:
+			if (offset + 4 > buf.length) throw new Error("Not enough data: need 4 length bytes");
+			length = buf.readUInt32BE(offset);
+			offset += 4;
+			break;
+		default: throw new Error(`Expected bin type (0xC4-0xC6), got 0x${type.toString(16)}`);
+	}
+	if (offset + length > buf.length) throw new Error(`Not enough data: need ${length} bytes, have ${buf.length - offset}`);
+	return {
+		value: buf.subarray(offset, offset + length),
+		newOffset: offset + length
+	};
+}
+
+//#endregion
+//#region ../compiler/dist/client.js
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const debug = process.env.DEBUG === "1";
+function debugLog(...args) {
+	if (debug) console.error(...args);
+}
+function getBinaryPath() {
+	const pkgName = `@elliots/typical-compiler-${process.platform}-${process.arch}`;
+	try {
+		const pkg = require(pkgName);
+		debugLog(`[CLIENT] Using platform binary from ${pkgName}`);
+		return pkg.binaryPath;
+	} catch {
+		debugLog(`[CLIENT] Platform package ${pkgName} not found, falling back to local bin`);
+		return join(__dirname, "..", "bin", "typical");
+	}
+}
+var TypicalCompiler = class {
+	process = null;
+	pendingRequests = /* @__PURE__ */ new Map();
+	buffer = Buffer.alloc(0);
+	binaryPath;
+	cwd;
+	nextRequestId = 0;
+	constructor(options = {}) {
+		this.binaryPath = options.binaryPath ?? getBinaryPath();
+		this.cwd = options.cwd ?? process.cwd();
+	}
+	async start() {
+		if (this.process) throw new Error("Compiler already started");
+		this.process = spawn(this.binaryPath, ["--cwd", this.cwd], { stdio: [
+			"pipe",
+			"pipe",
+			"inherit"
+		] });
+		this.process.unref();
+		this.process.stdout.on("data", (data) => {
+			this.handleData(data);
+		});
+		this.process.on("error", (err) => {
+			console.error("Compiler process error:", err);
+		});
+		this.process.on("exit", (code) => {
+			this.process = null;
+			for (const [, { reject }] of this.pendingRequests) reject(/* @__PURE__ */ new Error(`Compiler process exited with code ${code}`));
+			this.pendingRequests.clear();
+		});
+		const result = await this.request("echo", "ping");
+		if (result !== "ping") throw new Error(`Echo test failed: expected "ping", got "${result}"`);
+	}
+	async close() {
+		if (this.process) {
+			const proc = this.process;
+			this.process = null;
+			this.pendingRequests.clear();
+			proc.stdin?.end();
+			proc.kill();
+		}
+	}
+	async loadProject(configFileName) {
+		return this.request("loadProject", { configFileName });
+	}
+	async transformFile(project, fileName) {
+		const projectId = typeof project === "string" ? project : project.id;
+		return this.request("transformFile", {
+			project: projectId,
+			fileName
+		});
+	}
+	async release(handle) {
+		const id = typeof handle === "string" ? handle : handle.id;
+		await this.request("release", id);
+	}
+	/**
+	* Transform a standalone TypeScript source string.
+	* Creates a temporary project to enable type checking.
+	*
+	* @param fileName - Virtual filename for error messages (e.g., "test.ts")
+	* @param source - TypeScript source code
+	* @returns Transformed code with validation
+	*/
+	async transformSource(fileName, source) {
+		return this.request("transformSource", {
+			fileName,
+			source
+		});
+	}
+	async request(method, payload) {
+		if (!this.process) throw new Error("Compiler not started");
+		const requestId = `${method}:${this.nextRequestId++}`;
+		const requestData = encodeRequest(requestId, payload);
+		return new Promise((resolve, reject) => {
+			this.pendingRequests.set(requestId, {
+				resolve,
+				reject
+			});
+			this.process.stdin.write(requestData);
+		});
+	}
+	handleData(data) {
+		this.buffer = Buffer.concat([this.buffer, data]);
+		debugLog(`[CLIENT DEBUG] handleData: received ${data.length} bytes, buffer now ${this.buffer.length} bytes`);
+		while (this.buffer.length > 0) try {
+			debugLog(`[CLIENT DEBUG] Attempting to decode ${this.buffer.length} bytes...`);
+			const { messageType, method, payload, bytesConsumed } = decodeResponse(this.buffer);
+			debugLog(`[CLIENT DEBUG] Decoded: type=${messageType} method=${method} payload=${payload.length} bytes, consumed=${bytesConsumed}`);
+			const pending = this.pendingRequests.get(method);
+			if (!pending) {
+				const pendingKeys = [...this.pendingRequests.keys()].join(", ") || "(none)";
+				throw new Error(`No pending request for method: ${method}. Pending requests: ${pendingKeys}. This indicates a protocol bug - received response for a request that wasn't made or was already resolved.`);
+			}
+			this.pendingRequests.delete(method);
+			if (messageType === 4) {
+				const result = payload.length > 0 ? JSON.parse(payload.toString("utf8")) : null;
+				pending.resolve(result);
+			} else if (messageType === 5) pending.reject(new Error(payload.toString("utf8")));
+			else pending.reject(/* @__PURE__ */ new Error(`Unexpected message type: ${messageType}`));
+			this.buffer = this.buffer.subarray(bytesConsumed);
+		} catch (e) {
+			debugLog(`[CLIENT DEBUG] Decode failed (waiting for more data): ${e}`);
+			break;
+		}
+	}
+};
+
+//#endregion
+//#region src/index.ts
+/**
+* Synchronous wrapper around the async compiler transformFile.
+*/
+function transformFileSync(compiler, project, fileName) {
+	let result;
+	let error;
+	let done = false;
+	compiler.transformFile(project, fileName).then((res) => {
+		result = res.code;
+		done = true;
+	}, (err) => {
+		error = err;
+		done = true;
+	});
+	deasync.loopWhile(() => !done);
+	if (error) throw error;
+	return result;
+}
+/**
+* TSC Program Transformer Plugin for typical.
+*
+* Uses transformProgram to intercept program creation and transform source files
+* before TypeScript processes them. This allows us to inject validators into
+* the source code while maintaining proper TypeScript semantics.
+*
+* Configure in tsconfig.json:
+* {
+*   "compilerOptions": {
+*     "plugins": [
+*       { "transform": "@elliots/typical-tsc-plugin", "transformProgram": true }
+*     ]
+*   }
+* }
+*/
+function src_default(program, host, _pluginConfig, { ts: tsInstance }) {
+	validateConfig(loadConfig());
+	const compiler = new TypicalCompiler({ cwd: process.cwd() });
+	let projectHandle;
+	let initError;
+	let initDone = false;
+	compiler.start().then(() => compiler.loadProject("tsconfig.json")).then((handle) => {
+		projectHandle = handle.id;
+		initDone = true;
+	}).catch((err) => {
+		initError = err;
+		initDone = true;
+	});
+	deasync.loopWhile(() => !initDone);
+	if (initError) throw initError;
+	const compilerOptions = program.getCompilerOptions();
+	const originalHost = host ?? tsInstance.createCompilerHost(compilerOptions);
+	const transformedFiles = /* @__PURE__ */ new Map();
+	for (const sourceFile of program.getSourceFiles()) {
+		if (sourceFile.isDeclarationFile || sourceFile.fileName.includes("node_modules")) continue;
+		try {
+			const transformed = transformFileSync(compiler, projectHandle, sourceFile.fileName);
+			transformedFiles.set(sourceFile.fileName, transformed);
+		} catch (err) {
+			console.error(`[typical] Failed to transform ${sourceFile.fileName}:`, err);
+		}
+	}
+	const newHost = {
+		...originalHost,
+		getSourceFile: (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+			const transformed = transformedFiles.get(fileName);
+			if (transformed) return tsInstance.createSourceFile(fileName, transformed, typeof languageVersionOrOptions === "object" ? languageVersionOrOptions : { languageVersion: languageVersionOrOptions });
+			return originalHost.getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+		}
+	};
+	const rootNames = program.getRootFileNames();
+	return tsInstance.createProgram(rootNames, compilerOptions, newHost, program);
+}
+
+//#endregion
+export { src_default as default };

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@elliots/typical-tsc-plugin",
+  "version": "0.2.0-beta.1",
+  "description": "TSC plugin for typical - runtime safe TypeScript transformer",
+  "keywords": [
+    "runtime",
+    "transformer",
+    "ts-patch",
+    "tsc",
+    "typescript",
+    "typical",
+    "validation"
+  ],
+  "homepage": "https://github.com/elliots/typical#readme",
+  "bugs": {
+    "url": "https://github.com/elliots/typical/issues"
+  },
+  "license": "MIT",
+  "author": "Elliot Shepherd <elliot@jarofworms.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/elliots/typical.git",
+    "directory": "packages/tsc-plugin"
+  },
+  "bin": {
+    "ttsc": "bin/ttsc"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "src/patch-tsconfig.cjs"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@elliots/typical": "0.2.0-beta.1",
+    "deasync": "0.1.30",
+    "strip-json-comments": "5.0.3"
+  },
+  "devDependencies": {
+    "@types/deasync": "0.1.5",
+    "@types/node": "^22.0.0",
+    "tsdown": "^0.18.3"
+  },
+  "peerDependencies": {
+    "ts-patch": "^3.0.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/patch-tsconfig.cjs

@@ -0,0 +1,41 @@
+// monkeypatch fs.readFileSync to automatically add @elliots/typical-tsc-plugin to tsconfig.json (if not present)
+
+const fs = require('fs')
+const stripJsonComments = require('strip-json-comments').default
+
+const origFsReadFileSync = fs.readFileSync
+
+fs.readFileSync = function (path, ...args) {
+  const result = origFsReadFileSync.call(this, path, ...args)
+
+  if (typeof path === 'string' && path.endsWith('/tsconfig.json')) {
+    try {
+      const json = stripJsonComments(result.toString(), { trailingCommas: true })
+
+      const config = JSON.parse(json)
+
+      if (!config.compilerOptions) {
+        config.compilerOptions = {}
+      }
+
+      if (!config.compilerOptions.plugins) {
+        config.compilerOptions.plugins = []
+      }
+
+      const hasTypical = config.compilerOptions.plugins.some(plugin => plugin.transform === '@elliots/typical-tsc-plugin' || plugin.transform === '@elliots/typical/tsc-plugin')
+
+      if (!hasTypical) {
+        config.compilerOptions.plugins.push({
+          transform: '@elliots/typical-tsc-plugin',
+          transformProgram: true,
+        })
+      }
+
+      return JSON.stringify(config, null, 2)
+    } catch (e) {
+      console.error('ERROR patching tsconfig.json to add @elliots/typical-tsc-plugin', e)
+      throw e
+    }
+  }
+  return result
+}