@soederpop/luca 0.0.36 → 0.1.1

package/src/introspection/generated.web.ts

@@ -1,7 +1,7 @@
 import { setBuildTimeData, setContainerBuildTimeData } from './index.js';
 
 // Auto-generated introspection registry data
-// Generated at: 2026-03-28T00:36:29.848Z
+// Generated at: 2026-03-28T06:19:48.239Z
 
 setBuildTimeData('features.containerLink', {
   "id": "features.containerLink",

package/src/node/container.ts

@@ -24,7 +24,7 @@ import { basename, parse, relative, resolve, join } from "path";
 import "./features/disk-cache";
 import "./features/content-db";
 import "./features/downloader";
-import "./features/esbuild";
+import "./features/transpiler";
 import "./features/file-manager";
 import "./features/fs";
 import "./features/git";
@@ -69,7 +69,7 @@ import type { ChildProcess } from "./features/proc";
 import type { DiskCache } from "./features/disk-cache";
 import type { ContentDb } from "./features/content-db";
 import type { Downloader } from "./features/downloader";
-import type { ESBuild } from "./features/esbuild";
+import type { Transpiler } from "./features/transpiler";
 import type { FileManager } from "./features/file-manager";
 import type { FS } from "./features/fs";
 import type { Git } from "./features/git";
@@ -147,6 +147,7 @@ export {
   type SemanticSearch,
   type Dns,
   type Redis,
+  type Transpiler,
 };
 
 export type { FeatureOptions };
@@ -184,7 +185,7 @@ export interface NodeFeatures extends AvailableFeatures {
   packageFinder: typeof PackageFinder;
   repl: typeof Repl;
   yaml: typeof YAML;
-  esbuild: typeof ESBuild;
+  transpiler: typeof Transpiler;
   diskCache: typeof DiskCache;
   vault: typeof Vault;
   jsonTree: typeof JsonTree;
@@ -233,7 +234,7 @@ export interface NodeContainerState extends ContainerState {
  * Server-side container for Node.js and Bun environments. Extends the base Container with
  * file system access, process management, git integration, and other server-side capabilities.
  *
- * Auto-enables core features on construction: fs, proc, git, grep, os, networking, ui, vm, esbuild, helpers.
+ * Auto-enables core features on construction: fs, proc, git, grep, os, networking, ui, vm, transpiler, helpers.
  * Also attaches Client, Server, Command, Endpoint, and Selector helper types, providing
  * `container.client()`, `container.server()`, `container.command()`, etc. factory methods.
  *
@@ -274,7 +275,7 @@ export class NodeContainer<
   yamlTree?: YamlTree;
   packageFinder?: PackageFinder;
   repl?: Repl;
-  esbuild?: ESBuild;
+  transpiler?: Transpiler;
   diskCache?: DiskCache;
   vault?: Vault;
   python?: Python;
@@ -309,7 +310,7 @@ export class NodeContainer<
     this.feature("networking", { enable: true });
     this.feature("ui", { enable: true });
     this.feature("vm", { enable: true, context: {} });
-    this.feature("esbuild", { enable: true });
+    this.feature("transpiler", { enable: true });
     this.feature("helpers", { enable: true });
 
     const enable = castArray(this.options.enable)

package/src/node/features/figlet-fonts.ts

@@ -294,7 +294,10 @@ import f292 from "figlet/importable-fonts/Whimsy.js";
 import f293 from "figlet/importable-fonts/Wow.js";
 import f294 from "figlet/importable-fonts/miniwi.js";
 
-import figlet from "figlet/lib/figlet.js";
+// Use the browser (core) subpath — filesystem-free, works in compiled binaries.
+// figlet 1.11.0 replaced lib/ with dist/ and added an exports map; "./browser" is the stable subpath.
+// @ts-ignore — figlet/browser exists at runtime via the package exports map
+import figlet from "figlet/browser";
 
 // Register all fonts with figlet (filesystem-free, works in compiled binaries)
 figlet.parseFont("1Row", f0);

package/src/node/features/transpiler.ts

@@ -0,0 +1,111 @@
+import { Feature } from '../feature.js'
+import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
+
+export interface TransformOptions {
+  loader?: 'ts' | 'tsx' | 'jsx' | 'js'
+  format?: 'esm' | 'cjs'
+  minify?: boolean
+}
+
+export interface TransformResult {
+  code: string
+  map: string
+  warnings: any[]
+}
+
+/**
+ * Convert ESM import/export statements to CJS require/module.exports
+ * so the code can run in a vm context that provides `require`.
+ */
+function esmToCjs(code: string): string {
+  return code
+    // import Foo, { bar, baz } from 'x' → const Foo = require('x').default ?? require('x'); const { bar, baz } = require('x')
+    .replace(/^import\s+(\w+)\s*,\s*\{([^}]+)\}\s+from\s+(['"][^'"]+['"])\s*;?$/gm,
+      'const $1 = require($3).default ?? require($3); const {$2} = require($3);')
+    // import { a, b } from 'x' → const { a, b } = require('x')
+    .replace(/^import\s+\{([^}]+)\}\s+from\s+(['"][^'"]+['"])\s*;?$/gm,
+      'const {$1} = require($2);')
+    // import x from 'y' → const x = require('y').default ?? require('y')
+    .replace(/^import\s+(\w+)\s+from\s+(['"][^'"]+['"])\s*;?$/gm,
+      'const $1 = require($2).default ?? require($2);')
+    // import * as x from 'y' → const x = require('y')
+    .replace(/^import\s+\*\s+as\s+(\w+)\s+from\s+(['"][^'"]+['"])\s*;?$/gm,
+      'const $1 = require($2);')
+    // import 'y' → require('y')
+    .replace(/^import\s+(['"][^'"]+['"])\s*;?$/gm,
+      'require($1);')
+    // export default → module.exports.default =
+    .replace(/^export\s+default\s+/gm, 'module.exports.default = ')
+    // export { a, b } from 'x' → Object.assign(module.exports, require('x'))  (re-exports)
+    .replace(/^export\s+\{[^}]*\}\s+from\s+(['"][^'"]+['"])\s*;?$/gm,
+      'Object.assign(module.exports, require($1));')
+    // export { ... } → strip (vars already in scope)
+    .replace(/^export\s+\{[^}]*\}\s*;?$/gm, '')
+    // export const/let/var → const/let/var
+    .replace(/^export\s+(const|let|var)\s+/gm, '$1 ')
+    // export function → function (keep declaration, strip export keyword)
+    .replace(/^export\s+(function|class)\s+/gm, '$1 ')
+    // export async function → async function
+    .replace(/^export\s+(async\s+function)\s+/gm, '$1 ')
+}
+
+/**
+ * Transpile TypeScript, TSX, and JSX to JavaScript at runtime using Bun's
+ * built-in transpiler. Compile code strings on the fly without touching the
+ * filesystem or spawning external processes.
+ *
+ * @example
+ * ```typescript
+ * const transpiler = container.feature('transpiler')
+ * const result = transpiler.transformSync('const x: number = 1')
+ * console.log(result.code) // 'const x = 1;\n'
+ * ```
+ */
+export class Transpiler extends Feature {
+  static override shortcut = 'features.transpiler' as const
+  static override stateSchema = FeatureStateSchema
+  static override optionsSchema = FeatureOptionsSchema
+  static { Feature.register(this, 'transpiler') }
+
+  /**
+   * Transform code synchronously
+   * @param code - The code to transform
+   * @param options - Transform options (loader, format, minify)
+   * @returns The transformed code as { code, map, warnings }
+   */
+  transformSync(code: string, options: TransformOptions = {}): TransformResult {
+    const loader = options.loader || 'ts'
+    const format = options.format || 'esm'
+
+    const transpiler = new Bun.Transpiler({ loader })
+    let result = transpiler.transformSync(code)
+
+    if (format === 'cjs') {
+      result = esmToCjs(result)
+    }
+
+    return { code: result, map: '', warnings: [] }
+  }
+
+  /**
+   * Transform code asynchronously
+   * @param code - The code to transform
+   * @param options - Transform options (loader, format, minify)
+   * @returns The transformed code as { code, map, warnings }
+   */
+  async transform(code: string, options: TransformOptions = {}): Promise<TransformResult> {
+    const loader = options.loader || 'ts'
+    const format = options.format || 'esm'
+
+    const transpiler = new Bun.Transpiler({ loader })
+    let result = await transpiler.transform(code)
+
+    if (format === 'cjs') {
+      result = esmToCjs(result)
+    }
+
+    return { code: result, map: '', warnings: [] }
+  }
+}
+
+export default Transpiler

package/src/node/features/vm.ts

@@ -390,7 +390,7 @@ export class VM<
     if (!fs.exists(filePath)) return {}
 
     const raw = fs.readFile(filePath)
-    const { code } = this.container.feature('esbuild').transformSync(raw, { format: 'cjs' })
+    const { code } = this.container.feature('transpiler').transformSync(raw, { format: 'cjs' })
 
     const { context } = this.performSync(code, {
       require: this.createRequireFor(filePath),

package/src/python/generated.ts

@@ -1,5 +1,5 @@
 // Auto-generated Python bridge script
-// Generated at: 2026-03-28T00:36:32.420Z
+// Generated at: 2026-03-28T06:19:50.936Z
 // Source: src/python/bridge.py
 //
 // Do not edit manually. Run: luca build-python-bridge

package/src/scaffolds/generated.ts

@@ -1,5 +1,5 @@
 // Auto-generated scaffold and MCP readme content
-// Generated at: 2026-03-28T00:36:30.792Z
+// Generated at: 2026-03-28T06:19:49.219Z
 // Source: docs/scaffolds/*.md, docs/examples/assistant/, and docs/mcp/readme.md
 //
 // Do not edit manually. Run: luca build-scaffolds

package/test/integration.test.ts

@@ -618,27 +618,27 @@ describe('Integration: Proc + FS for script execution', () => {
   })
 })
 
-describe('Integration: ESBuild + FS for code transformation', () => {
+describe('Integration: Transpiler + FS for code transformation', () => {
   it('transforms typescript to javascript', async () => {
     const c = new NodeContainer({ cwd: testDir })
-    const esbuild = c.feature('esbuild', { enable: true })
+    const transpiler = c.feature('transpiler', { enable: true })
 
     const tsCode = `
       const greet = (name: string): string => 'Hello, ' + name + '!'
       export default greet
     `
 
-    const result = await esbuild.transform(tsCode, { loader: 'ts' })
+    const result = await transpiler.transform(tsCode, { loader: 'ts' })
     expect(result.code).toContain('greet')
     expect(result.code).not.toContain(': string')
   })
 
   it('reads ts file from disk, transforms it, writes js output', async () => {
     const c = new NodeContainer({ cwd: testDir })
-    const esbuild = c.feature('esbuild', { enable: true })
+    const transpiler = c.feature('transpiler', { enable: true })
 
     const tsSource = c.fs.readFile(join(testDir, 'src', 'utils.ts'))
-    const result = await esbuild.transform(tsSource, { loader: 'ts' })
+    const result = await transpiler.transform(tsSource, { loader: 'ts' })
 
     const outPath = join(testDir, 'src', 'utils.js')
     await c.fs.writeFileAsync(outPath, result.code)

package/src/node/features/esbuild.ts

@@ -1,79 +0,0 @@
-import * as esbuild from 'esbuild-wasm'
-import { Feature } from '../feature.js'
-import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
-
-/**
- * A Feature for compiling typescript / esm modules, etc to JavaScript
- * that the container can run at runtime. Uses esbuild for fast, reliable
- * TypeScript/ESM transformation with full format support (esm, cjs, iife).
- *
- * @example
- * ```typescript
- * const esbuild = container.feature('esbuild')
- * const result = esbuild.transformSync('const x: number = 1')
- * console.log(result.code) // 'const x = 1;\n'
- * ```
-*/
-export class ESBuild extends Feature {
-  static override shortcut = 'features.esbuild' as const
-  static override stateSchema = FeatureStateSchema
-  static override optionsSchema = FeatureOptionsSchema
-  static { Feature.register(this, 'esbuild') }
-
-  /**
-  /**
-   * Transform code synchronously
-   * @param code - The code to transform
-   * @param options - The options to pass to esbuild
-   * @returns The transformed code
-   */
-  transformSync(code: string, options?: esbuild.TransformOptions): esbuild.TransformResult {
-    return esbuild.transformSync(code, {
-      loader: 'ts',
-      format: 'esm',
-      target: 'esnext',
-      sourcemap: false,
-      minify: false,
-      ...options
-    })
-  }
-
-  /**
-   * Transform code asynchronously
-   * @param code - The code to transform
-   * @param options - The options to pass to esbuild
-   * @returns The transformed code
-   */
-  async transform(code: string, options?: esbuild.TransformOptions): Promise<esbuild.TransformResult> {
-    return esbuild.transform(code, {
-      loader: 'ts',
-      format: 'esm',
-      target: 'esnext',
-      sourcemap: false,
-      minify: false,
-      ...options
-    })
-  }
-
-  /**
-   * Bundle one or more entry points, resolving imports and requires into a single output.
-   * Supports Node platform by default so require() and Node builtins are handled.
-   * Returns in-memory output files unless write is enabled in options.
-   * @param entryPoints - File paths to bundle from
-   * @param options - esbuild BuildOptions overrides
-   * @returns The build result with outputFiles when write is false
-   */
-  async bundle(entryPoints: string[], options?: esbuild.BuildOptions): Promise<esbuild.BuildResult> {
-    return esbuild.build({
-      entryPoints,
-      bundle: true,
-      platform: 'node',
-      format: 'esm',
-      target: 'esnext',
-      write: false,
-      ...options
-    })
-  }
-}
-
-export default ESBuild