@justscale/typescript 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JustScale
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,128 @@
+# @justscale/typescript
+
+Drop-in TypeScript replacement (`ptsc`, `ptscserver`) with two extensions your normal `tsc` can't do:
+
+1. **Durable-process handler compilation** — handlers passed to `createProcess(...)` are rewritten into an opcode-driven shape that can be serialized at any suspension point, survive a restart, and resume mid-flight.
+2. **TSPxxxx diagnostics** — process-specific errors (unhandled `await`, non-serializable `const`, unsupported control flow) surface as TS diagnostics with stable error codes.
+
+Everything else behaves exactly like `tsc` / `tsserver`.
+
+## Install
+
+```bash
+pnpm add -D @justscale/typescript typescript
+```
+
+`typescript` (>=6.0) is a peer dep — bring your own, `@justscale/typescript` wraps it.
+
+## CLI
+
+```bash
+npx ptsc                     # compile using tsconfig.json
+npx ptsc --noEmit            # type-check only
+npx ptsc -w                  # watch
+npx ptsc -b tsconfig.build.json
+npx ptsc --init              # scaffold a tsconfig.json
+```
+
+Every `tsc` flag passes through. Also installed: `ptscserver` (tsserver equivalent), plus `justscale-tsc` / `justscale-tsserver` aliases.
+
+## IDE
+
+### VS Code
+
+Point the TypeScript SDK at this package:
+
+```json
+// .vscode/settings.json
+{ "typescript.tsdk": "node_modules/@justscale/typescript/lib" }
+```
+
+Full TypeScript IntelliSense plus JustScale diagnostics in the editor.
+
+## tsconfig
+
+A `justscale` section at the root of `tsconfig.json` configures the extensions:
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true
+  },
+  "justscale": {
+    "processFilePattern": "*.process.ts",
+    "processModules": ["@justscale/core/process"],
+    "strict": true,
+    "verbose": false
+  }
+}
+```
+
+Defaults are almost always right; you only need the `justscale` section if you're customising the process-file convention or pointing at a non-standard process module.
+
+## TSPxxxx diagnostics
+
+Stable error codes for process-specific issues:
+
+| Code | Meaning |
+|-|-|
+| TSP0001 | Missing `await` on a suspension point (`delay`, `signal`, `race`, ...) |
+| TSP0002 | Variable captured incorrectly across a suspension point |
+| TSP0003 | Invalid process handler signature |
+| TSP0004 | Unsupported control flow in a process handler |
+| TSP1001 | Awaited service call needs `using` instead of `const` so the value is re-fetched on resume |
+
+TSP1001 in practice:
+
+```ts
+// fails — const captures the value; after a resume it's stale
+const order = await orders.findById(orderId);
+
+// works — using tells the runtime to re-hydrate on resume
+using order = await orders.findById(orderId);
+```
+
+Full list: https://justscale.sh/docs/processes/compiler.
+
+## Programmatic API
+
+```ts
+import { transpile, transpileProject } from '@justscale/typescript/api';
+
+const result = transpile(source, 'example.process.ts');
+if (result.success) console.log(result.code);
+
+const project = transpileProject('./tsconfig.json');
+for (const [file] of project.files) console.log('compiled:', file);
+```
+
+`createProcessTransformer(program, opts)` is also exported for wiring the transform into a custom `ts.createProgram` pipeline or ts-patch setup.
+
+## Subpath exports
+
+- `@justscale/typescript` — main programmatic API (`transpile`, `transpileProject`, `createProgram`, `createProcessTransformer`, `formatDiagnostics`).
+- `@justscale/typescript/api` — the narrower `transpile*` surface if that's all you need.
+- `@justscale/typescript/config` — config parsing (`parseConfig`, `findConfig`, `defaultConfig`).
+- `@justscale/typescript/register` — Node `--import` hook; used by the monorepo's test runner (`node --import @justscale/typescript/register ...`) so tests see the same transform as production.
+- `@justscale/typescript/loader` — lower-level loader primitives if you're building your own runtime.
+- `@justscale/typescript/server` — embeddable `ptscserver` internals.
+- `@justscale/typescript/editor` — editor-side helpers for refactors, quick fixes.
+
+## How the process compilation works
+
+The transformer walks each `createProcess(...)` handler AST:
+
+1. **Analyses** suspension points (`delay`, `signal`, `race`, `for await`).
+2. **Splits** the handler into synchronous blocks separated by suspension points.
+3. **Generates opcodes** (WAIT, BLOCK, JUMP, RACE_START, ...) that the runtime executes.
+4. **Tracks rehydration** for `using` declarations so the runtime knows what to re-fetch when resuming.
+5. **Emits** a compiled process descriptor that replaces the handler at runtime.
+
+The runtime pairs with `@justscale/core/process` to execute the opcodes, serialise state at any checkpoint, and resume from a saved state when a signal fires or a timer expires.
+
+## Docs
+
+https://justscale.sh/docs/processes/signals · https://justscale.sh/docs/processes/compiler · [VSCODE.md](./VSCODE.md) for detailed editor setup.

package/dist/api.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Programmatic API for the JustScale TypeScript compiler.
+ *
+ * @example
+ * ```typescript
+ * import { transpile, transpileProject } from '@justscale/typescript/api'
+ * const result = transpile(source, 'example.process.ts')
+ * ```
+ */
+import ts from 'typescript';
+import { type JustScaleConfig } from './config/index.js';
+/**
+ * Result of transpiling a single file
+ */
+export interface TranspileResult {
+    /** Transpiled JavaScript code */
+    code: string;
+    /** Source map (if enabled) */
+    sourceMap?: string;
+    /** Declaration file content (if enabled) */
+    declaration?: string;
+    /** Diagnostics from compilation */
+    diagnostics: ts.Diagnostic[];
+    /** Whether compilation was successful (no errors) */
+    success: boolean;
+}
+/**
+ * Result of transpiling a project
+ */
+export interface TranspileProjectResult {
+    /** Results for each file */
+    files: Map<string, TranspileResult>;
+    /** Project-wide diagnostics */
+    diagnostics: ts.Diagnostic[];
+    /** Whether compilation was successful */
+    success: boolean;
+}
+/**
+ * Options for transpilation
+ */
+export interface TranspileOptions {
+    /** TypeScript compiler options */
+    compilerOptions?: ts.CompilerOptions;
+    /** JustScale-specific options */
+    justscale?: JustScaleConfig;
+    /** Custom transformers to apply before JustScale transformer */
+    transformers?: ts.CustomTransformers;
+    /** Generate source maps */
+    sourceMap?: boolean;
+    /** Generate declaration files */
+    declaration?: boolean;
+}
+/**
+ * Transpile a single TypeScript source string
+ *
+ * @param source - TypeScript source code
+ * @param fileName - Virtual file name (affects process detection)
+ * @param options - Compilation options
+ * @returns Transpilation result
+ *
+ * @example
+ * ```typescript
+ * const result = transpile(`
+ *   import { createProcess, delay } from '@justscale/core/process'
+ *
+ *   export const myProcess = createProcess({
+ *     name: 'my-process',
+ *     async handler() {
+ *       await delay(1000)
+ *       return 'done'
+ *     }
+ *   })
+ * `, 'example.process.ts')
+ *
+ * console.log(result.code)
+ * ```
+ */
+export declare function transpile(source: string, fileName?: string, options?: TranspileOptions): TranspileResult;
+/**
+ * Transpile a TypeScript project from a tsconfig.json
+ *
+ * @param configPath - Path to tsconfig.json
+ * @param options - Additional options to override config
+ * @returns Results for all files in the project
+ *
+ * @example
+ * ```typescript
+ * const result = transpileProject('./tsconfig.json')
+ *
+ * if (result.success) {
+ *   for (const [file, output] of result.files) {
+ *     console.log(`${file}: ${output.code.length} bytes`)
+ *   }
+ * } else {
+ *   console.error('Compilation failed:', result.diagnostics)
+ * }
+ * ```
+ */
+export declare function transpileProject(configPath: string, options?: TranspileOptions): TranspileProjectResult;
+/**
+ * Create a TypeScript Program with JustScale extensions
+ *
+ * Use this for advanced use cases where you need full control over
+ * the compilation process.
+ *
+ * @param fileNames - Files to include in the program
+ * @param options - Compiler options
+ * @returns A TypeScript Program
+ *
+ * @example
+ * ```typescript
+ * const program = createProgram(['./src/index.ts'], {
+ *   target: ts.ScriptTarget.ES2022,
+ *   module: ts.ModuleKind.NodeNext,
+ * })
+ *
+ * // Get process diagnostics
+ * const diagnostics = getProcessDiagnostics(program)
+ *
+ * // Custom emit with transformer
+ * program.emit(undefined, undefined, undefined, undefined, {
+ *   before: [createProcessTransformer(program)]
+ * })
+ * ```
+ */
+export declare function createProgram(fileNames: string[], options?: ts.CompilerOptions): ts.Program;
+/**
+ * Get JustScale process diagnostics for a program
+ *
+ * @param program - TypeScript program
+ * @param config - JustScale configuration
+ * @returns Array of diagnostics
+ */
+export declare function getProcessDiagnostics(program: ts.Program, config?: JustScaleConfig): ts.Diagnostic[];
+/**
+ * Format diagnostics for console output
+ */
+export declare function formatDiagnostics(diagnostics: ts.Diagnostic[]): string;
+export { createProcessTransformer } from './compiler/transformer.js';
+export { analyzeHandler } from './compiler/analyzer.js';
+export { formatErrorCode, ProcessErrorCode } from './compiler/errors.js';
+export { parseConfig, defaultConfig } from './config/index.js';
+export type { JustScaleConfig, ParsedConfig } from './config/index.js';
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAC;AAM5B,OAAO,EAA8B,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAErF;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,8BAA8B;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mCAAmC;IACnC,WAAW,EAAE,EAAE,CAAC,UAAU,EAAE,CAAA;IAC5B,qDAAqD;IACrD,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,4BAA4B;IAC5B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IACnC,+BAA+B;IAC/B,WAAW,EAAE,EAAE,CAAC,UAAU,EAAE,CAAA;IAC5B,yCAAyC;IACzC,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,kCAAkC;IAClC,eAAe,CAAC,EAAE,EAAE,CAAC,eAAe,CAAA;IACpC,iCAAiC;IACjC,SAAS,CAAC,EAAE,eAAe,CAAA;IAC3B,gEAAgE;IAChE,YAAY,CAAC,EAAE,EAAE,CAAC,kBAAkB,CAAA;IACpC,2BAA2B;IAC3B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,iCAAiC;IACjC,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,QAAQ,SAAa,EACrB,OAAO,GAAE,gBAAqB,GAC7B,eAAe,CA8GjB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,gBAAqB,GAC7B,sBAAsB,CAmGxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,CAAC,EAAE,EAAE,CAAC,eAAe,GAC3B,EAAE,CAAC,OAAO,CAYZ;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,EAAE,CAAC,OAAO,EACnB,MAAM,GAAE,eAA+B,GACtC,EAAE,CAAC,UAAU,EAAE,CAWjB;AAoFD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,EAAE,CAAC,UAAU,EAAE,GAAG,MAAM,CAQtE;AAGD,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/api.js

@@ -0,0 +1,380 @@
+/**
+ * Programmatic API for the JustScale TypeScript compiler.
+ *
+ * @example
+ * ```typescript
+ * import { transpile, transpileProject } from '@justscale/typescript/api'
+ * const result = transpile(source, 'example.process.ts')
+ * ```
+ */
+import ts from 'typescript';
+import { resolve } from 'node:path';
+import { analyzeHandler } from './compiler/analyzer.js';
+import { filterUsingExportsDiagnostics } from './compiler/errors.js';
+import { createProcessTransformer } from './compiler/transformer.js';
+import { extractAndInjectExportsTypes, createModifiedHost } from './compiler/exports-prepass.js';
+import { parseConfig, defaultConfig } from './config/index.js';
+/**
+ * Transpile a single TypeScript source string
+ *
+ * @param source - TypeScript source code
+ * @param fileName - Virtual file name (affects process detection)
+ * @param options - Compilation options
+ * @returns Transpilation result
+ *
+ * @example
+ * ```typescript
+ * const result = transpile(`
+ *   import { createProcess, delay } from '@justscale/core/process'
+ *
+ *   export const myProcess = createProcess({
+ *     name: 'my-process',
+ *     async handler() {
+ *       await delay(1000)
+ *       return 'done'
+ *     }
+ *   })
+ * `, 'example.process.ts')
+ *
+ * console.log(result.code)
+ * ```
+ */
+export function transpile(source, fileName = 'input.ts', options = {}) {
+    const compilerOptions = {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.NodeNext,
+        moduleResolution: ts.ModuleResolutionKind.NodeNext,
+        // Include ES2022 lib by default for Promise, async/await, etc.
+        lib: ['lib.es2022.d.ts'],
+        ...options.compilerOptions,
+        sourceMap: options.sourceMap ?? options.compilerOptions?.sourceMap,
+        declaration: options.declaration ?? options.compilerOptions?.declaration,
+    };
+    const jsConfig = options.justscale ?? defaultConfig;
+    const sourceFile = ts.createSourceFile(fileName, source, compilerOptions.target ?? ts.ScriptTarget.ES2022, true);
+    const defaultHost = ts.createCompilerHost(compilerOptions);
+    const host = {
+        ...defaultHost,
+        getSourceFile: (name, languageVersion) => {
+            if (name === fileName)
+                return sourceFile;
+            // Use the default host to load lib files and other dependencies
+            return defaultHost.getSourceFile(name, languageVersion);
+        },
+        writeFile: () => { }, // We'll capture output differently
+        fileExists: (name) => name === fileName || defaultHost.fileExists(name),
+        readFile: (name) => {
+            if (name === fileName)
+                return source;
+            return defaultHost.readFile(name);
+        },
+    };
+    const program1 = ts.createProgram([fileName], compilerOptions, host);
+    const modifiedSources = extractAndInjectExportsTypes(program1);
+    let program;
+    if (modifiedSources.size > 0) {
+        const modifiedText = modifiedSources.get(fileName);
+        if (modifiedText) {
+            const host2 = {
+                ...host,
+                getSourceFile: (name, languageVersionOrOptions, onError) => {
+                    if (name === fileName) {
+                        return ts.createSourceFile(name, modifiedText, languageVersionOrOptions, true);
+                    }
+                    return host.getSourceFile(name, languageVersionOrOptions, onError);
+                },
+                readFile: (name) => {
+                    if (name === fileName)
+                        return modifiedText;
+                    return host.readFile(name);
+                },
+            };
+            program = ts.createProgram([fileName], compilerOptions, host2, program1);
+        }
+        else {
+            program = program1;
+        }
+    }
+    else {
+        program = program1;
+    }
+    const finalSourceFile = program.getSourceFile(fileName);
+    const diagnostics = filterUsingExportsDiagnostics([
+        ...program.getSyntacticDiagnostics(finalSourceFile),
+        ...program.getSemanticDiagnostics(finalSourceFile),
+    ]);
+    const processDiagnostics = getProcessDiagnosticsForFile(program, finalSourceFile, jsConfig);
+    diagnostics.push(...processDiagnostics);
+    let code = '';
+    let sourceMap;
+    let declaration;
+    program.emit(finalSourceFile, (name, text) => {
+        if (name.endsWith('.map')) {
+            sourceMap = text;
+        }
+        else if (name.endsWith('.d.ts')) {
+            declaration = text;
+        }
+        else {
+            code = text;
+        }
+    }, undefined, undefined, {
+        before: [
+            ...(options.transformers?.before ?? []),
+            createProcessTransformer(program, { verbose: jsConfig.verbose ?? false }),
+        ],
+        after: options.transformers?.after,
+        afterDeclarations: options.transformers?.afterDeclarations,
+    });
+    const hasErrors = diagnostics.some((d) => d.category === ts.DiagnosticCategory.Error);
+    return {
+        code,
+        sourceMap,
+        declaration,
+        diagnostics,
+        success: !hasErrors,
+    };
+}
+/**
+ * Transpile a TypeScript project from a tsconfig.json
+ *
+ * @param configPath - Path to tsconfig.json
+ * @param options - Additional options to override config
+ * @returns Results for all files in the project
+ *
+ * @example
+ * ```typescript
+ * const result = transpileProject('./tsconfig.json')
+ *
+ * if (result.success) {
+ *   for (const [file, output] of result.files) {
+ *     console.log(`${file}: ${output.code.length} bytes`)
+ *   }
+ * } else {
+ *   console.error('Compilation failed:', result.diagnostics)
+ * }
+ * ```
+ */
+export function transpileProject(configPath, options = {}) {
+    const resolvedPath = resolve(configPath);
+    const config = parseConfig(resolvedPath, options.compilerOptions);
+    const mergedOptions = {
+        ...config.compilerOptions,
+        ...options.compilerOptions,
+    };
+    const jsConfig = {
+        ...config.justscale,
+        ...options.justscale,
+    };
+    const program1 = ts.createProgram({
+        rootNames: config.fileNames,
+        options: mergedOptions,
+        projectReferences: config.projectReferences,
+    });
+    const modifiedSources = extractAndInjectExportsTypes(program1);
+    let program;
+    if (modifiedSources.size > 0) {
+        const defaultHost = ts.createCompilerHost(mergedOptions);
+        const host2 = createModifiedHost(defaultHost, modifiedSources);
+        program = ts.createProgram({
+            rootNames: config.fileNames,
+            options: mergedOptions,
+            projectReferences: config.projectReferences,
+            host: host2,
+            oldProgram: program1,
+        });
+    }
+    else {
+        program = program1;
+    }
+    const allDiagnostics = filterUsingExportsDiagnostics([
+        ...program.getConfigFileParsingDiagnostics(),
+        ...program.getSyntacticDiagnostics(),
+        ...program.getOptionsDiagnostics(),
+        ...program.getGlobalDiagnostics(),
+        ...program.getSemanticDiagnostics(),
+    ]);
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile)
+            continue;
+        if (sourceFile.fileName.includes('node_modules'))
+            continue;
+        const processDiagnostics = getProcessDiagnosticsForFile(program, sourceFile, jsConfig);
+        allDiagnostics.push(...processDiagnostics);
+    }
+    const files = new Map();
+    const emitResult = program.emit(undefined, (fileName, text, writeByteOrderMark, onError, sourceFiles) => {
+        if (!sourceFiles || sourceFiles.length === 0)
+            return;
+        const sourceFile = sourceFiles[0];
+        const originalName = sourceFile.fileName;
+        const existing = files.get(originalName) ?? {
+            code: '',
+            diagnostics: [],
+            success: true,
+        };
+        if (fileName.endsWith('.map')) {
+            existing.sourceMap = text;
+        }
+        else if (fileName.endsWith('.d.ts')) {
+            existing.declaration = text;
+        }
+        else {
+            existing.code = text;
+        }
+        files.set(originalName, existing);
+    }, undefined, undefined, {
+        before: [
+            ...(options.transformers?.before ?? []),
+            createProcessTransformer(program, { verbose: jsConfig.verbose ?? false }),
+        ],
+        after: options.transformers?.after,
+        afterDeclarations: options.transformers?.afterDeclarations,
+    });
+    allDiagnostics.push(...emitResult.diagnostics);
+    const hasErrors = allDiagnostics.some((d) => d.category === ts.DiagnosticCategory.Error);
+    return {
+        files,
+        diagnostics: allDiagnostics,
+        success: !hasErrors,
+    };
+}
+/**
+ * Create a TypeScript Program with JustScale extensions
+ *
+ * Use this for advanced use cases where you need full control over
+ * the compilation process.
+ *
+ * @param fileNames - Files to include in the program
+ * @param options - Compiler options
+ * @returns A TypeScript Program
+ *
+ * @example
+ * ```typescript
+ * const program = createProgram(['./src/index.ts'], {
+ *   target: ts.ScriptTarget.ES2022,
+ *   module: ts.ModuleKind.NodeNext,
+ * })
+ *
+ * // Get process diagnostics
+ * const diagnostics = getProcessDiagnostics(program)
+ *
+ * // Custom emit with transformer
+ * program.emit(undefined, undefined, undefined, undefined, {
+ *   before: [createProcessTransformer(program)]
+ * })
+ * ```
+ */
+export function createProgram(fileNames, options) {
+    const compilerOptions = {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.NodeNext,
+        moduleResolution: ts.ModuleResolutionKind.NodeNext,
+        ...options,
+    };
+    return ts.createProgram({
+        rootNames: fileNames,
+        options: compilerOptions,
+    });
+}
+/**
+ * Get JustScale process diagnostics for a program
+ *
+ * @param program - TypeScript program
+ * @param config - JustScale configuration
+ * @returns Array of diagnostics
+ */
+export function getProcessDiagnostics(program, config = defaultConfig) {
+    const diagnostics = [];
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile)
+            continue;
+        if (sourceFile.fileName.includes('node_modules'))
+            continue;
+        diagnostics.push(...getProcessDiagnosticsForFile(program, sourceFile, config));
+    }
+    return diagnostics;
+}
+/**
+ * Get process diagnostics for a single file
+ */
+function getProcessDiagnosticsForFile(program, sourceFile, config) {
+    const diagnostics = [];
+    const typeChecker = program.getTypeChecker();
+    const processModules = config.processModules ?? defaultConfig.processModules;
+    // Check if this is a process file
+    if (!isProcessFile(sourceFile, config, processModules)) {
+        return diagnostics;
+    }
+    // Find createProcess calls and analyze
+    ts.forEachChild(sourceFile, function visit(node) {
+        if (ts.isCallExpression(node)) {
+            const expr = node.expression;
+            if (ts.isIdentifier(expr) && expr.text === 'createProcess') {
+                const configArg = node.arguments[0];
+                if (configArg && ts.isObjectLiteralExpression(configArg)) {
+                    const handler = findHandler(configArg);
+                    if (handler) {
+                        const analysis = analyzeHandler(handler, typeChecker);
+                        diagnostics.push(...analysis.diagnostics);
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    });
+    return diagnostics;
+}
+function isProcessFile(sourceFile, config, processModules) {
+    const pattern = config.processFilePattern;
+    if (pattern && sourceFile.fileName.includes(pattern.replace('*', ''))) {
+        return true;
+    }
+    if (sourceFile.fileName.includes('.process.'))
+        return true;
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            const moduleSpecifier = stmt.moduleSpecifier;
+            if (ts.isStringLiteral(moduleSpecifier)) {
+                if (processModules.includes(moduleSpecifier.text)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function findHandler(configObj) {
+    for (const prop of configObj.properties) {
+        if (ts.isMethodDeclaration(prop)) {
+            if (ts.isIdentifier(prop.name) && prop.name.text === 'handler') {
+                return prop;
+            }
+        }
+        else if (ts.isPropertyAssignment(prop)) {
+            if (ts.isIdentifier(prop.name) && prop.name.text === 'handler') {
+                if (ts.isFunctionExpression(prop.initializer) || ts.isArrowFunction(prop.initializer)) {
+                    return prop.initializer;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Format diagnostics for console output
+ */
+export function formatDiagnostics(diagnostics) {
+    const host = {
+        getCanonicalFileName: (path) => path,
+        getCurrentDirectory: () => process.cwd(),
+        getNewLine: () => '\n',
+    };
+    return ts.formatDiagnosticsWithColorAndContext(diagnostics, host);
+}
+// Re-export the transformer for custom usage
+export { createProcessTransformer } from './compiler/transformer.js';
+export { analyzeHandler } from './compiler/analyzer.js';
+export { formatErrorCode, ProcessErrorCode } from './compiler/errors.js';
+export { parseConfig, defaultConfig } from './config/index.js';
+//# sourceMappingURL=api.js.map