carrick 0.3.53

package/sidecar/dist/src/bundler.js

@@ -0,0 +1,680 @@
+/**
+ * Surface Emitter - Emits .d.ts surface files with rewritten module specifiers
+ *
+ * This module replaces the previous dts-bundle-generator approach with a
+ * ts-morph-based AST transformation and emission pipeline.
+ *
+ * Key features:
+ * - Does NOT bundle dependencies (unlike dts-bundle-generator)
+ * - Rewrites module specifiers to repo-specific aliases (@carrick/{repoName}/{spec})
+ * - Handles ImportDeclaration, ImportTypeNode, and ExportDeclaration
+ * - Supports scoped packages and subpaths
+ * - Includes a safety pass for any compiler-introduced raw specifiers
+ */
+import { Node, } from 'ts-morph';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { expandTypeStructural } from './type-structural-expander.js';
+/**
+ * #248: upper bound on `SymbolRequest.array_depth`. SDL list nesting is
+ * realistically 1-3 levels (`[Order!]!`, at most `[[Order!]!]!`); this is a
+ * generous ceiling, not a realistic value. `array_depth` wraps via string
+ * repetition (`'[]'.repeat(depth)`), so an unbounded value from the model
+ * would let a single symbol blow up the emitted `.d.ts` (and the memory/CPU
+ * spent producing it). Depths above this are treated as unresolvable, same
+ * as any other symbol the bundler can't extract a type for.
+ */
+const MAX_ARRAY_DEPTH = 10;
+/**
+ * SurfaceEmitter - Generates .d.ts surface files with rewritten imports
+ *
+ * Usage:
+ *   const emitter = new SurfaceEmitter({ project, repoRoot });
+ *   const result = emitter.emit(repoName, payloads, outputPath);
+ */
+export class SurfaceEmitter {
+    project;
+    repoRoot;
+    constructor(options) {
+        this.project = options.project;
+        this.repoRoot = options.repoRoot;
+    }
+    /**
+     * Emit a surface .d.ts file containing payload type declarations
+     *
+     * @param repoName - Repository name for specifier rewriting
+     * @param payloads - Payload definitions to include
+     * @param outputPath - Path to write the surface file
+     * @returns SurfaceEmitResult
+     */
+    emit(repoName, payloads, outputPath) {
+        const errors = [];
+        const manifest = [];
+        try {
+            // Phase 1: Generate surface content as a string
+            const surfaceLines = [
+                '// Generated surface file for type compatibility checking',
+                '// Do not edit - this file is auto-generated by Carrick',
+                '',
+            ];
+            // Collect all import specifiers we need to track for rewriting
+            const importSpecifiers = new Set();
+            // Phase 2: Add payload type declarations
+            for (const payload of payloads) {
+                const { alias, type_string, source_file } = payload;
+                // Analyze type string for import references
+                const detectedImports = this.extractImportReferences(type_string);
+                for (const imp of detectedImports) {
+                    importSpecifiers.add(imp);
+                }
+                // Add type alias declaration
+                surfaceLines.push(`export type ${alias} = ${type_string};`);
+                surfaceLines.push('');
+                manifest.push({
+                    alias,
+                    type_string,
+                    rewritten_imports: [],
+                });
+            }
+            // Phase 3: Create a temporary source file for AST manipulation
+            const tempFileName = `__carrick_surface_${repoName}_${Date.now()}.d.ts`;
+            const tempFilePath = path.join(this.repoRoot, tempFileName);
+            const initialContent = surfaceLines.join('\n');
+            const tempSourceFile = this.project.createSourceFile(tempFilePath, initialContent, { overwrite: true });
+            // Phase 4: Rewrite module specifiers in the AST
+            const rewrittenImports = this.rewriteModuleSpecifiers(tempSourceFile, repoName);
+            // Update manifest with rewritten imports
+            for (const entry of manifest) {
+                entry.rewritten_imports = rewrittenImports;
+            }
+            // Phase 5: Get the transformed content
+            let surfaceContent = tempSourceFile.getFullText();
+            // Phase 6: Safety pass - catch any raw specifiers the compiler might have added
+            surfaceContent = this.safetyRewritePass(surfaceContent, repoName);
+            // Phase 7: Clean up temporary source file from project
+            this.project.removeSourceFile(tempSourceFile);
+            // Phase 8: Write output file
+            const absoluteOutputPath = path.isAbsolute(outputPath)
+                ? outputPath
+                : path.join(this.repoRoot, outputPath);
+            // Ensure directory exists
+            const outputDir = path.dirname(absoluteOutputPath);
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+            fs.writeFileSync(absoluteOutputPath, surfaceContent, 'utf-8');
+            this.log(`Emitted surface file: ${absoluteOutputPath}`);
+            return {
+                success: true,
+                surface_content: surfaceContent,
+                output_path: absoluteOutputPath,
+                manifest,
+            };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            this.logError(`Surface emission failed: ${error}`);
+            errors.push(error);
+            return {
+                success: false,
+                errors,
+            };
+        }
+    }
+    /**
+     * Extract potential import references from a type string.
+     * These are module specifiers that might need rewriting.
+     */
+    extractImportReferences(typeString) {
+        const imports = [];
+        // Match import("...") syntax
+        const importTypeRegex = /import\s*\(\s*["']([^"']+)["']\s*\)/g;
+        let match;
+        while ((match = importTypeRegex.exec(typeString)) !== null) {
+            imports.push(match[1]);
+        }
+        // Match from "..." syntax (in case of inline imports)
+        const fromRegex = /from\s+["']([^"']+)["']/g;
+        while ((match = fromRegex.exec(typeString)) !== null) {
+            imports.push(match[1]);
+        }
+        return imports;
+    }
+    /**
+     * Rewrite all module specifiers in a source file to use repo-scoped aliases.
+     *
+     * Targets:
+     * 1. ImportDeclaration.moduleSpecifier
+     * 2. ImportTypeNode argument (import("..."))
+     * 3. ExportDeclaration.moduleSpecifier
+     *
+     * @returns Array of rewritten specifiers
+     */
+    rewriteModuleSpecifiers(sourceFile, repoName) {
+        const rewrittenSpecifiers = [];
+        // 1. Rewrite ImportDeclaration specifiers
+        const importDecls = sourceFile.getImportDeclarations();
+        for (const importDecl of importDecls) {
+            const specifier = importDecl.getModuleSpecifierValue();
+            if (this.shouldRewriteSpecifier(specifier)) {
+                const newSpecifier = this.rewriteSpecifier(specifier, repoName);
+                importDecl.setModuleSpecifier(newSpecifier);
+                rewrittenSpecifiers.push(`${specifier} → ${newSpecifier}`);
+            }
+        }
+        // 2. Rewrite ExportDeclaration specifiers
+        const exportDecls = sourceFile.getExportDeclarations();
+        for (const exportDecl of exportDecls) {
+            const specifier = exportDecl.getModuleSpecifierValue();
+            if (specifier && this.shouldRewriteSpecifier(specifier)) {
+                const newSpecifier = this.rewriteSpecifier(specifier, repoName);
+                exportDecl.setModuleSpecifier(newSpecifier);
+                rewrittenSpecifiers.push(`${specifier} → ${newSpecifier}`);
+            }
+        }
+        // 3. Rewrite ImportTypeNode arguments
+        // These appear in type positions: import("module").Type
+        sourceFile.forEachDescendant((node) => {
+            if (Node.isImportTypeNode(node)) {
+                const arg = node.getArgument();
+                if (Node.isLiteralTypeNode(arg)) {
+                    const literal = arg.getLiteral();
+                    if (Node.isStringLiteral(literal)) {
+                        const specifier = literal.getLiteralValue();
+                        if (this.shouldRewriteSpecifier(specifier)) {
+                            const newSpecifier = this.rewriteSpecifier(specifier, repoName);
+                            literal.setLiteralValue(newSpecifier);
+                            rewrittenSpecifiers.push(`${specifier} → ${newSpecifier}`);
+                        }
+                    }
+                }
+            }
+        });
+        return rewrittenSpecifiers;
+    }
+    /**
+     * Determine if a module specifier should be rewritten.
+     * Only non-relative specifiers should be rewritten.
+     */
+    shouldRewriteSpecifier(specifier) {
+        // Don't rewrite relative imports
+        if (specifier.startsWith('./') || specifier.startsWith('../')) {
+            return false;
+        }
+        // Don't rewrite already-rewritten specifiers
+        if (specifier.startsWith('@carrick/')) {
+            return false;
+        }
+        // Don't rewrite node built-ins
+        if (specifier.startsWith('node:')) {
+            return false;
+        }
+        // Some common node built-ins without prefix
+        const nodeBuiltins = [
+            'fs', 'path', 'os', 'util', 'events', 'stream', 'http', 'https',
+            'url', 'querystring', 'crypto', 'buffer', 'child_process', 'cluster',
+            'dgram', 'dns', 'net', 'readline', 'tls', 'tty', 'zlib', 'assert',
+            'async_hooks', 'console', 'constants', 'domain', 'inspector', 'module',
+            'perf_hooks', 'process', 'punycode', 'string_decoder', 'timers',
+            'trace_events', 'v8', 'vm', 'worker_threads'
+        ];
+        if (nodeBuiltins.includes(specifier) || nodeBuiltins.includes(specifier.split('/')[0])) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Rewrite a module specifier to the repo-scoped format.
+     *
+     * Format: @carrick/{repoName}/{originalSpecifier}
+     *
+     * Preserves:
+     * - Scoped packages: "@scope/pkg" → "@carrick/repo-a/@scope/pkg"
+     * - Subpaths: "zod/lib/helpers" → "@carrick/repo-a/zod/lib/helpers"
+     * - Combined: "@scope/pkg/subpath" → "@carrick/repo-a/@scope/pkg/subpath"
+     */
+    rewriteSpecifier(specifier, repoName) {
+        return `@carrick/${repoName}/${specifier}`;
+    }
+    /**
+     * Safety pass: Scan emitted content for any raw specifiers that might have
+     * been introduced by the TypeScript compiler and rewrite them.
+     *
+     * This catches edge cases where the compiler emits types with their original
+     * module specifiers that weren't caught by AST traversal.
+     */
+    safetyRewritePass(content, repoName) {
+        // Common patterns to catch:
+        // - from "package"
+        // - import("package")
+        // - export * from "package"
+        // We need to be careful not to double-rewrite @carrick/ specifiers
+        // Pattern for import("...") that's not already @carrick
+        const importTypePattern = /import\s*\(\s*["'](?!@carrick\/|\.\.?\/|node:)([^"']+)["']\s*\)/g;
+        content = content.replace(importTypePattern, (match, specifier) => {
+            const newSpecifier = this.rewriteSpecifier(specifier, repoName);
+            return match.replace(`"${specifier}"`, `"${newSpecifier}"`).replace(`'${specifier}'`, `'${newSpecifier}'`);
+        });
+        // Pattern for from "..." that's not already @carrick
+        const fromPattern = /from\s+["'](?!@carrick\/|\.\.?\/|node:)([^"']+)["']/g;
+        content = content.replace(fromPattern, (match, specifier) => {
+            const newSpecifier = this.rewriteSpecifier(specifier, repoName);
+            return match.replace(`"${specifier}"`, `"${newSpecifier}"`).replace(`'${specifier}'`, `'${newSpecifier}'`);
+        });
+        return content;
+    }
+    /**
+     * Log a message to stderr
+     */
+    log(message) {
+        console.error(`[sidecar:surface-emitter] ${message}`);
+    }
+    /**
+     * Log an error to stderr
+     */
+    logError(message) {
+        console.error(`[sidecar:surface-emitter:error] ${message}`);
+    }
+}
+// =============================================================================
+// Legacy TypeBundler (kept for backwards compatibility during migration)
+// =============================================================================
+/**
+ * TypeBundler - Legacy bundler using simpler approach
+ *
+ * This is a simplified replacement that doesn't use dts-bundle-generator.
+ * It extracts type definitions directly using ts-morph.
+ *
+ * @deprecated Use SurfaceEmitter instead for the new architecture
+ */
+export class TypeBundler {
+    project;
+    repoRoot;
+    constructor(options) {
+        this.project = options.project;
+        this.repoRoot = options.repoRoot;
+    }
+    /**
+     * Bundle the requested symbols into type definitions
+     *
+     * @param symbols - Array of symbol requests to bundle
+     * @returns BundleResult with the bundled content or errors
+     */
+    bundle(symbols) {
+        const manifest = [];
+        const symbolFailures = [];
+        const errors = [];
+        // Dedupe symbols
+        const uniqueSymbols = this.dedupeSymbols(symbols);
+        // Validate all symbols exist
+        const validatedSymbols = this.validateSymbols(uniqueSymbols, symbolFailures);
+        if (validatedSymbols.length === 0) {
+            return {
+                success: false,
+                symbol_failures: symbolFailures,
+                errors: symbolFailures.length > 0
+                    ? ['All requested symbols failed to resolve']
+                    : ['No symbols provided'],
+            };
+        }
+        try {
+            // Generate type definitions directly
+            const dtsLines = [
+                '// Generated by Carrick TypeBundler',
+                '// This file contains extracted type definitions',
+                '',
+            ];
+            for (const symbol of validatedSymbols) {
+                const typeInfo = this.extractTypeDefinition(symbol);
+                if (typeInfo) {
+                    dtsLines.push(typeInfo.definition);
+                    dtsLines.push('');
+                    manifest.push({
+                        alias: symbol.alias || symbol.symbol_name,
+                        original_name: symbol.symbol_name,
+                        source_file: symbol.source_file,
+                        type_string: typeInfo.typeString,
+                        is_explicit: true,
+                    });
+                }
+                else {
+                    symbolFailures.push({
+                        symbol_name: symbol.symbol_name,
+                        source_file: symbol.source_file,
+                        reason: `Could not extract type definition for '${symbol.symbol_name}'`,
+                    });
+                }
+            }
+            const dtsContent = dtsLines.join('\n');
+            return {
+                success: true,
+                dts_content: dtsContent,
+                manifest,
+                symbol_failures: symbolFailures.length > 0 ? symbolFailures : undefined,
+            };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            this.logError(`Bundle generation failed: ${error}`);
+            errors.push(error);
+            return {
+                success: false,
+                symbol_failures: symbolFailures.length > 0 ? symbolFailures : undefined,
+                errors,
+            };
+        }
+    }
+    dedupeSymbols(symbols) {
+        const seen = new Set();
+        const unique = [];
+        for (const symbol of symbols) {
+            const key = `${symbol.source_file}::${symbol.symbol_name}::${symbol.alias || ''}`;
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            unique.push(symbol);
+        }
+        return unique;
+    }
+    validateSymbols(symbols, failures) {
+        const validated = [];
+        for (const symbol of symbols) {
+            const result = this.validateSymbol(symbol);
+            if (result.valid) {
+                validated.push(symbol);
+            }
+            else {
+                failures.push({
+                    symbol_name: symbol.symbol_name,
+                    source_file: symbol.source_file,
+                    reason: result.reason || 'Unknown error',
+                });
+            }
+        }
+        return validated;
+    }
+    validateSymbol(symbol) {
+        if (this.isPlaceholderSource(symbol.source_file)) {
+            return {
+                valid: false,
+                reason: `Unsupported source placeholder: ${symbol.source_file}`,
+            };
+        }
+        if (!this.isPathSource(symbol.source_file)) {
+            return { valid: true };
+        }
+        // Resolve the source file path
+        const absolutePath = path.isAbsolute(symbol.source_file)
+            ? symbol.source_file
+            : path.resolve(this.repoRoot, symbol.source_file);
+        // Check if file exists
+        if (!fs.existsSync(absolutePath)) {
+            return {
+                valid: false,
+                reason: `Source file not found: ${symbol.source_file}`,
+            };
+        }
+        // Get or add the source file to the project
+        let sourceFile;
+        try {
+            sourceFile =
+                this.project.getSourceFile(absolutePath) ||
+                    this.project.addSourceFileAtPath(absolutePath);
+        }
+        catch (err) {
+            return {
+                valid: false,
+                reason: `Failed to load source file: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        // Look for the symbol in the file
+        const symbolName = symbol.symbol_name;
+        // Check interfaces
+        if (sourceFile.getInterface(symbolName))
+            return { valid: true };
+        // Check type aliases
+        if (sourceFile.getTypeAlias(symbolName))
+            return { valid: true };
+        // Check classes
+        if (sourceFile.getClass(symbolName))
+            return { valid: true };
+        // Check enums
+        if (sourceFile.getEnum(symbolName))
+            return { valid: true };
+        // Check exported variables
+        if (sourceFile.getVariableDeclaration(symbolName))
+            return { valid: true };
+        // Check functions
+        if (sourceFile.getFunction(symbolName))
+            return { valid: true };
+        // Symbol not found
+        return {
+            valid: false,
+            reason: `Symbol '${symbolName}' not found in ${symbol.source_file}`,
+        };
+    }
+    /**
+     * Structural body (`{ ... }`) for an interface/object type, with every nested
+     * named member inlined recursively. Returns null when the expansion is not a
+     * usable object body (e.g. the expander fell back to a bare name), so the
+     * caller can keep the verbatim declaration instead of emitting an invalid
+     * interface. The expander already guards recursion (depth + per-branch cycle
+     * set) and keeps builtins/`node_modules` types by name.
+     */
+    expandObjectBody(type) {
+        try {
+            const expanded = expandTypeStructural(type);
+            return expanded.startsWith('{') ? expanded : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    extractTypeDefinition(symbol) {
+        const base = this.extractTypeDefinitionBase(symbol);
+        if (!base)
+            return null;
+        // #248: wrap the resolved element type in the SDL list depth. A GraphQL
+        // producer field `[Order!]!` backed by `interface Order` bundles `Order`
+        // with `array_depth: 1`; the alias becomes `Order[]` (arrays can't be
+        // interfaces, so it is always emitted as a type alias). The element's
+        // structurally-expanded body carries the shape, so downstream resolution
+        // and the eval's whitespace-collapsed `{...}[]` comparison both hold.
+        const depth = symbol.array_depth ?? 0;
+        if (depth <= 0)
+            return base;
+        // Reject rather than clamp: silently clamping would emit a type at a
+        // depth the model never asked for, which is wrong in a different way.
+        // Falling through to the symbol's normal "could not extract" failure
+        // keeps this on the existing per-symbol failure path (`symbol_failures`)
+        // instead of rejecting the whole batch.
+        if (depth > MAX_ARRAY_DEPTH)
+            return null;
+        // The wrap suffixes `typeString` with `[]`, which is only valid when it is
+        // a standalone type EXPRESSION. The base's fallback branches (interface
+        // whose expansion failed, class/enum/function) return declaration text,
+        // and `export type A = enum X {...}[]` is not parseable .d.ts — fail the
+        // symbol instead, same per-symbol path as an over-depth request.
+        if (!base.typeStringIsExpression)
+            return null;
+        const alias = symbol.alias || symbol.symbol_name;
+        // Parenthesise a union/intersection/function element so `(A | B)[]` doesn't
+        // misparse as `A | B[]` and `(() => T)[]` as `() => T[]`. Decide from the
+        // TYPE (not the string): a single object literal `{ a: A | B }` is NOT a
+        // top-level union and must stay unparenthesised (`{ a: A | B }[]`).
+        const element = this.elementNeedsArrayParens(symbol)
+            ? `(${base.typeString})`
+            : base.typeString;
+        const typeString = `${element}${'[]'.repeat(depth)}`;
+        return { definition: `export type ${alias} = ${typeString};`, typeString };
+    }
+    /// Whether the element type must be parenthesised before an `[]` suffix.
+    /// Interfaces/classes/enums are always object/nominal (never a top-level
+    /// union), so only type aliases and typed variables can carry a bare
+    /// union/intersection/function that would misparse; those are re-resolved
+    /// from the source Type here (this runs only on the rare array_depth path).
+    elementNeedsArrayParens(symbol) {
+        const absolutePath = path.isAbsolute(symbol.source_file)
+            ? symbol.source_file
+            : path.resolve(this.repoRoot, symbol.source_file);
+        const sourceFile = this.project.getSourceFile(absolutePath);
+        if (!sourceFile)
+            return false;
+        const name = symbol.symbol_name;
+        const decl = sourceFile.getTypeAlias(name) ?? sourceFile.getVariableDeclaration(name);
+        if (!decl)
+            return false;
+        const t = decl.getType();
+        return (t.isUnion() ||
+            t.isIntersection() ||
+            t.getCallSignatures().length > 0 ||
+            t.getConstructSignatures().length > 0);
+    }
+    // `typeStringIsExpression`: whether `typeString` is a standalone type
+    // expression (an object body, alias RHS, or `Type#getText()`), as opposed to
+    // verbatim declaration text from a fallback branch. Only expressions can be
+    // array-wrapped by `extractTypeDefinition`.
+    extractTypeDefinitionBase(symbol) {
+        const absolutePath = path.isAbsolute(symbol.source_file)
+            ? symbol.source_file
+            : path.resolve(this.repoRoot, symbol.source_file);
+        const sourceFile = this.project.getSourceFile(absolutePath);
+        if (!sourceFile) {
+            return null;
+        }
+        const symbolName = symbol.symbol_name;
+        const alias = symbol.alias || symbolName;
+        // Try interface
+        const iface = sourceFile.getInterface(symbolName);
+        if (iface) {
+            // Inline nested named members structurally (`total: { amountCents: number;
+            // currency: string; }`, not `total: MoneyView`). The bundle carries only
+            // the alias declaration — never the source decls of nested types — so a
+            // bare named reference is dangling and resolves to `any` downstream. The
+            // expansion happens here, in the real source project, where the nested
+            // symbol still resolves. Falls back to the verbatim rename if the type
+            // can't be safely rendered as an object body.
+            const expanded = this.expandObjectBody(iface.getType());
+            const text = iface.getText();
+            if (expanded) {
+                const definition = `export interface ${alias} ${expanded}`;
+                return { definition, typeString: expanded, typeStringIsExpression: true };
+            }
+            const typeString = text;
+            const alreadyExported = text.trimStart().startsWith('export');
+            const definition = alias !== symbolName
+                ? (alreadyExported
+                    ? text.replace(`interface ${symbolName}`, `interface ${alias}`)
+                    : text.replace(`interface ${symbolName}`, `export interface ${alias}`))
+                : alreadyExported
+                    ? text
+                    : `export ${text}`;
+            return { definition, typeString, typeStringIsExpression: false };
+        }
+        // Try type alias
+        const typeAlias = sourceFile.getTypeAlias(symbolName);
+        if (typeAlias) {
+            // Same nested-member inlining as the interface branch above. A type alias
+            // can resolve to any shape (object, union, array, primitive); the
+            // structural expander renders each correctly and keeps builtins/library
+            // types by name, so the alias RHS is always emittable.
+            const text = typeAlias.getText();
+            const expanded = expandTypeStructural(typeAlias.getType());
+            if (expanded && expanded !== 'unknown') {
+                const definition = `export type ${alias} = ${expanded};`;
+                return { definition, typeString: expanded, typeStringIsExpression: true };
+            }
+            const typeString = typeAlias.getType().getText();
+            const alreadyExported = text.trimStart().startsWith('export');
+            const definition = alias !== symbolName
+                ? (alreadyExported
+                    ? text.replace(`type ${symbolName}`, `type ${alias}`)
+                    : text.replace(`type ${symbolName}`, `export type ${alias}`))
+                : alreadyExported
+                    ? text
+                    : `export ${text}`;
+            return { definition, typeString, typeStringIsExpression: true };
+        }
+        // Try class
+        const classDecl = sourceFile.getClass(symbolName);
+        if (classDecl) {
+            const text = classDecl.getText();
+            const typeString = text;
+            const alreadyExported = text.trimStart().startsWith('export');
+            const definition = alias !== symbolName
+                ? (alreadyExported
+                    ? text.replace(`class ${symbolName}`, `declare class ${alias}`)
+                    : text.replace(`class ${symbolName}`, `export declare class ${alias}`))
+                : alreadyExported
+                    ? text
+                    : `export declare ${text}`;
+            return { definition, typeString, typeStringIsExpression: false };
+        }
+        // Try enum
+        const enumDecl = sourceFile.getEnum(symbolName);
+        if (enumDecl) {
+            const text = enumDecl.getText();
+            const typeString = text;
+            const alreadyExported = text.trimStart().startsWith('export');
+            const definition = alias !== symbolName
+                ? (alreadyExported
+                    ? text.replace(`enum ${symbolName}`, `enum ${alias}`)
+                    : text.replace(`enum ${symbolName}`, `export enum ${alias}`))
+                : alreadyExported
+                    ? text
+                    : `export ${text}`;
+            return { definition, typeString, typeStringIsExpression: false };
+        }
+        // Try variable (const type definitions)
+        const varDecl = sourceFile.getVariableDeclaration(symbolName);
+        if (varDecl) {
+            const type = varDecl.getType();
+            const typeString = type.getText();
+            const definition = `export type ${alias} = ${typeString};`;
+            return { definition, typeString, typeStringIsExpression: true };
+        }
+        // Try function
+        const funcDecl = sourceFile.getFunction(symbolName);
+        if (funcDecl) {
+            const text = funcDecl.getText();
+            const typeString = text;
+            const alreadyExported = text.trimStart().startsWith('export');
+            const definition = alias !== symbolName
+                ? (alreadyExported
+                    ? text.replace(`function ${symbolName}`, `declare function ${alias}`)
+                    : text.replace(`function ${symbolName}`, `export declare function ${alias}`))
+                : alreadyExported
+                    ? text
+                    : `export declare ${text}`;
+            return { definition, typeString, typeStringIsExpression: false };
+        }
+        return null;
+    }
+    isPathSource(sourceFile) {
+        if (sourceFile.startsWith('.') ||
+            sourceFile.startsWith('/') ||
+            path.isAbsolute(sourceFile)) {
+            return true;
+        }
+        const basePath = path.resolve(this.repoRoot, sourceFile);
+        if (fs.existsSync(basePath)) {
+            return true;
+        }
+        if (path.extname(sourceFile) !== '') {
+            return false;
+        }
+        const extensions = ['.ts', '.tsx', '.js', '.jsx', '.d.ts'];
+        return extensions.some((ext) => fs.existsSync(basePath + ext));
+    }
+    isPlaceholderSource(sourceFile) {
+        const trimmed = sourceFile.trim();
+        return trimmed === '' || trimmed === '%none%' || trimmed === '%inline%';
+    }
+    log(message) {
+        console.error(`[sidecar:bundler] ${message}`);
+    }
+    logError(message) {
+        console.error(`[sidecar:bundler:error] ${message}`);
+    }
+}