tjs-lang 0.6.44 → 0.7.3

package/CLAUDE.md

@@ -52,6 +52,14 @@ bun run docs                # Generate documentation
 # Build standalone CLI binaries
 bun run build:cli           # Compiles tjs + tjsx to dist/
 
+# Compatibility testing (transpile popular TS libraries with fromTS)
+bun scripts/compat-zod.ts          # Zod validation library
+bun scripts/compat-effect.ts       # Effect (HKTs, intersections)
+bun scripts/compat-radash.ts       # Radash utilities
+bun scripts/compat-superstruct.ts  # Superstruct validation
+bun scripts/compat-ts-pattern.ts   # ts-pattern matching
+bun scripts/compat-kysely.ts       # Kysely SQL builder
+
 # Deployment (Firebase)
 bun run deploy              # Build demo + deploy functions + hosting
 bun run deploy:hosting      # Hosting only (serves from .demo/)
@@ -80,6 +88,7 @@ bun run functions:serve     # Local functions emulator
 - `src/lang/emitters/from-ts.ts` - TypeScript to TJS/JS transpiler with class metadata extraction
 - `src/lang/emitters/dts.ts` - .d.ts declaration file generator from TJS transpilation results
 - `src/lang/inference.ts` - Type inference from example values
+- `src/lang/json-schema.ts` - JSON Schema generation from TypeDescriptors and example values
 - `src/lang/linter.ts` - Static analysis (unused vars, unreachable code, no-explicit-new)
 - `src/lang/runtime.ts` - TJS runtime (monadic errors, type checking, wrapClass)
 - `src/lang/wasm.ts` - WASM compiler (opcodes, disassembler, bytecode generation)
@@ -110,6 +119,16 @@ await vm.run(ast, args, { fuel, capabilities, timeoutMs, trace })
 // Builder
 Agent.take(schema).varSet(...).httpFetch(...).return(schema)
 vm.Agent  // Builder with custom atoms included
+
+// JSON Schema
+Type('user', { name: '', age: 0 }).toJSONSchema()  // → JSON Schema object
+Type('user', { name: '', age: 0 }).strip(value)     // → strip extra fields
+functionMetaToJSONSchema(fn.__tjs)                   // → { input, output } schemas
+
+// Error History (on by default, zero cost on happy path)
+__tjs.errors()          // → recent MonadicErrors (ring buffer, max 64)
+__tjs.clearErrors()     // → returns and clears
+__tjs.getErrorCount()   // → total since last clear
 ```
 
 ### Package Entry Points
@@ -128,7 +147,7 @@ TJS supports transpiling TypeScript to JavaScript with runtime type validation.
 **Step 1: TypeScript → TJS** (`fromTS`)
 
 ```typescript
-import { fromTS } from 'tosijs/lang/from-ts'
+import { fromTS } from 'tjs-lang/lang/from-ts'
 
 const tsSource = `
 function greet(name: string): string {
@@ -138,7 +157,7 @@ function greet(name: string): string {
 
 const result = fromTS(tsSource, { emitTJS: true })
 // result.code contains TJS:
-// function greet(name: '') -> '' {
+// function greet(name: ''): '' {
 //   return \`Hello, \${name}!\`
 // }
 ```
@@ -146,10 +165,10 @@ const result = fromTS(tsSource, { emitTJS: true })
 **Step 2: TJS → JavaScript** (`tjs`)
 
 ```typescript
-import { tjs } from 'tosijs/lang'
+import { tjs } from 'tjs-lang/lang'
 
 const tjsSource = `
-function greet(name: '') -> '' {
+function greet(name: ''): '' {
   return \`Hello, \${name}!\`
 }
 `
@@ -161,8 +180,8 @@ const jsResult = tjs(tjsSource)
 **Full Chain Example:**
 
 ```typescript
-import { fromTS } from 'tosijs/lang/from-ts'
-import { tjs } from 'tosijs/lang'
+import { fromTS } from 'tjs-lang/lang/from-ts'
+import { tjs } from 'tjs-lang/lang'
 
 // TypeScript source with type annotations
 const tsSource = `
@@ -271,421 +290,53 @@ The `resolveValue()` function handles multiple input patterns:
 
 When `ctx.error` is set, subsequent atoms in a `seq` skip execution. Errors are wrapped in `AgentError`, not thrown. This prevents exception-based exploits.
 
-### TJS Parser Syntax Extensions
-
-TJS extends JavaScript with type annotations that survive to runtime.
-
-#### Classes (Callable Without `new`)
-
-TJS classes are wrapped to be callable without the `new` keyword:
-
-```typescript
-class Point {
-  constructor(public x: number, public y: number) {}
-}
-
-// Both work identically:
-const p1 = Point(10, 20) // TJS way - clean
-const p2 = new Point(10, 20) // Still works, but linter warns
-
-// The linter flags explicit `new` usage:
-// Warning: Unnecessary 'new' keyword. In TJS, classes are callable without 'new'
-```
-
-The `wrapClass()` function in the runtime uses a Proxy to intercept calls and auto-construct. Only `class` declarations in `.tjs` files with `TjsClass` are wrapped — built-in constructors (`Boolean`, `Number`, `String`, etc.) and old-style `function` + `prototype` constructors are never touched because they may have intentional dual behavior (e.g., `Boolean(0)` returns `false` but `new Boolean(0)` returns a truthy wrapper object).
-
-#### Function Parameters
-
-```typescript
-// Required param with example value (colon shorthand)
-function greet(name: 'Alice') { }        // name is required, type inferred as string
-
-// Numeric type narrowing (all valid JS syntax)
-function calc(rate: 3.14) { }            // number (float) -- has decimal point
-function calc(count: 42) { }             // integer -- whole number
-function calc(index: +0) { }             // non-negative integer -- + prefix
-
-// Optional param with default
-function greet(name = 'Alice') { }       // name is optional, defaults to 'Alice'
-
-// Object parameter with shape
-function createUser(user: { name: '', age: 0 }) { }
-
-// Nullable type
-function find(id: 0 | null) { }           // integer or null
-
-// Optional TS-style
-function greet(name?: '') { }            // same as name = ''
-
-// Rest parameters — array example is the type (annotation stripped in JS output)
-function sum(...nums: [0]) { }           // nums: array of integers
-function log(...args: ['', 0, true]) { } // args: array<string | integer | boolean>
-```
-
-#### Return Types
-
-```typescript
-// Return type annotation (arrow syntax)
-function add(a: 0, b: 0) -> 0 { return a + b }
-
-// Object return type
-function getUser(id: 0) -> { name: '', age: 0 } { ... }
-```
-
-#### Safety Markers
-
-```typescript
-// Unsafe function (skips runtime validation)
-function fastAdd(! a: 0, b: 0) { return a + b }
-
-// Safe function (explicit validation)
-function safeAdd(? a: 0, b: 0) { return a + b }
-
-// Unsafe block
-unsafe {
-  // All calls in here skip validation
-  fastPath(data)
-}
-```
-
-#### Type Declarations
-
-```typescript
-// Simple type from example
-Type Name 'Alice'
-
-// Type with description and example
-Type User {
-  description: 'a user object'
-  example: { name: '', age: 0 }
-}
-
-// Type with predicate (auto-generates type guard from example)
-Type EvenNumber {
-  description: 'an even number'
-  example: 2
-  predicate(x) { return x % 2 === 0 }
-}
-```
-
-#### Generic Declarations
-
-```typescript
-// Simple generic
-Generic Box<T> {
-  description: 'a boxed value'
-  predicate(x, T) {
-    return typeof x === 'object' && x !== null && 'value' in x && T(x.value)
-  }
-}
-
-// Generic with default type parameter
-Generic Container<T, U = ''> {
-  description: 'container with label'
-  predicate(obj, T, U) {
-    return T(obj.item) && U(obj.label)
-  }
-}
-
-// Generic with declaration block (for .d.ts emission)
-// The declaration block contains TypeScript syntax emitted verbatim into .d.ts
-// It is stripped from runtime JS output
-Generic BoxedProxy<T> {
-  predicate(x, T) { return typeof x === 'object' && T(x.value) }
-  declaration {
-    value: T
-    path: string
-    observe(cb: (path: string) => void): void
-  }
-}
-```
-
-#### FunctionPredicate Declarations
-
-First-class function types, completing the Type/Generic/FunctionPredicate triad:
-
-```typescript
-// Block form — declare a function type shape
-FunctionPredicate Callback {
-  params: { x: 0, y: 0 }
-  returns: ''
-}
-
-// Function form — extract signature from existing function
-FunctionPredicate Handler(existingFn, 'description')
-
-// Return contracts:
-// ->  returns (standard)
-// -!  assertReturns (throws on mismatch)
-// -?  checkedReturns (wraps in MonadicError)
-```
-
-Runtime creates a `RuntimeType` that checks `typeof === 'function'`. The spec includes params, returns, and returnContract. In `fromTS`, TS function type aliases (`type Cb = (x: number) => void`) emit FunctionPredicate declarations automatically.
-
-#### Bare Assignments
-
-```typescript
-// Uppercase identifiers auto-get const
-Foo = Type('test', 'example') // becomes: const Foo = Type(...)
-MyConfig = { debug: true } // becomes: const MyConfig = { ... }
-```
-
-#### Module Safety Directive
-
-```typescript
-// At top of file - sets default validation level
-safety none     // No validation (metadata only)
-safety inputs   // Validate function inputs (default)
-safety all      // Validate everything (debug mode)
-```
-
-#### TJS Mode Directives
+### TJS Syntax Reference
 
-JavaScript semantics are the default. TJS improvements are opt-in via file-level directives:
+Full syntax documentation is in [`CLAUDE-TJS-SYNTAX.md`](CLAUDE-TJS-SYNTAX.md). Key concepts:
 
-```typescript
-TjsStrict // Enables ALL modes below at once
-
-TjsEquals // == and != use honest equality (Eq/NotEq) — no coercion, unwraps boxed primitives
-TjsClass // Classes callable without new, explicit new is banned
-TjsDate // Date is banned, use Timestamp/LegalDate instead
-TjsNoeval // eval() and new Function() are banned
-TjsNoVar // var declarations are syntax errors — use const or let
-TjsStandard // Newlines as statement terminators (prevents ASI footguns)
-TjsSafeEval // Include Eval/SafeFunction in runtime for dynamic code
-```
-
-Multiple directives can be combined. Place them at the top of the file before any code.
-
-#### Compile-Time Immutability (`const!`)
-
-`const!` declares bindings whose properties cannot be mutated. Enforced at transpile time with zero runtime cost — emits as plain `const`.
-
-```typescript
-const! config = { debug: false, port: 8080 }
-console.log(config.port)   // OK — reads are fine
-config.debug = true        // ERROR at transpile time
-
-const! items = [1, 2, 3]
-items.map(x => x * 2)     // OK — non-mutating methods
-items.push(4)              // ERROR — mutating method
-```
-
-Catches: property assignment, compound assignment (`+=`), increment/decrement, `delete`, and mutating array methods (`push`, `pop`, `splice`, `shift`, `unshift`, `sort`, `reverse`, `fill`).
-
-When runtimes support records/tuples, `const!` can emit those instead.
-
-#### Equality Operators
-
-With `TjsEquals` (or `TjsStrict`), TJS fixes JavaScript's confusing `==` coercion without the performance cost of deep structural comparison.
-
-| Operator    | Meaning                                      | Example                            |
-| ----------- | -------------------------------------------- | ---------------------------------- |
-| `==`        | Honest equality (no coercion, unwraps boxed) | `new String('x') == 'x'` is `true` |
-| `!=`        | Honest inequality                            | `0 != ''` is `true` (no coercion)  |
-| `===`       | Identity (same reference)                    | `obj === obj` is `true`            |
-| `!==`       | Not same reference                           | `{a:1} !== {a:1}` is `true`        |
-| `a Is b`    | Deep structural equality (explicit)          | `{a:1} Is {a:1}` is `true`         |
-| `a IsNot b` | Deep structural inequality (explicit)        | `[1,2] IsNot [2,1]` is `true`      |
-
-```typescript
-// == is honest: no coercion, unwraps boxed primitives
-'foo' == 'foo'                    // true
-new String('foo') == 'foo'        // true  (unwraps)
-new Boolean(false) == false       // true  (unwraps)
-null == undefined                 // true  (nullish equality preserved)
-0 == ''                           // false (no coercion!)
-false == []                       // false (no coercion!)
-
-// == is fast: objects/arrays use reference equality (O(1))
-{a:1} == {a:1}                    // false (different refs)
-[1,2] == [1,2]                    // false (different refs)
-
-// Is/IsNot for explicit deep structural comparison (O(n))
-{a:1} Is {a:1}                    // true
-[1,2,3] Is [1,2,3]               // true
-new Set([1,2]) Is new Set([2,1]) // true  (Sets are order-independent)
-```
-
-**Implementation Notes:**
-
-- **AJS (VM)**: The VM's expression evaluator (`src/vm/runtime.ts`) uses `isStructurallyEqual()` for `==`/`!=`
-- **TJS (browser/Node)**: Source transformation converts `==` to `Eq()` and `!=` to `NotEq()` calls
-- **`===` and `!==`**: Always preserved as identity checks, never transformed
-- `Eq()`/`NotEq()` — fast honest equality (unwraps boxed primitives, nullish equality, reference for objects)
-- `Is()`/`IsNot()` — deep structural comparison (arrays, objects, Sets, Maps, Dates, RegExps)
-
-**Custom Equality Protocol:**
-
-- `[tjsEquals]` symbol (`Symbol.for('tjs.equals')`) — highest priority, ideal for Proxies
-- `.Equals` method — backward-compatible, works on any object/class
-- Priority: symbol → `.Equals` → structural comparison
-- `tjsEquals` is exported from `src/lang/runtime.ts` and available as `__tjs.tjsEquals`
-
-#### Polymorphic Functions
-
-Multiple function declarations with the same name are merged into a dispatcher:
-
-```typescript
-function area(radius: 3.14) {
-  return Math.PI * radius * radius
-}
-function area(w: 0.0, h: 0.0) {
-  return w * h
-}
-
-area(5) // dispatches to variant 1 (one number)
-area(3, 4) // dispatches to variant 2 (two numbers)
-```
-
-Dispatch order: arity first, then type specificity, then declaration order. Ambiguous signatures (same types at same arity) are caught at transpile time.
-
-#### Polymorphic Constructors
-
-Classes can have multiple constructor signatures (requires `TjsClass` directive):
-
-```typescript
-TjsClass
-
-class Point {
-  constructor(x: 0.0, y: 0.0) {
-    this.x = x
-    this.y = y
-  }
-  constructor(coords: { x: 0.0; y: 0.0 }) {
-    this.x = coords.x
-    this.y = coords.y
-  }
-}
+- **Colon shorthand**: `function foo(x: 'hello')` — colon value is an _example_, not a type. This is the most common LLM mistake.
+- **Numeric narrowing**: `3.14` = float, `42` = integer, `+0` = non-negative integer
+- **Return types**: `function add(a: 0, b: 0): 0 { ... }` (colon syntax, same as TypeScript)
+- **Safety markers**: `!` = unsafe (skip validation), `?` = safe (explicit validation)
+- **Mode defaults**: Native TJS has all modes ON by default (`TjsEquals`, `TjsClass`, `TjsDate`, `TjsNoeval`, `TjsNoVar`, `TjsStandard`). TS-originated code (`fromTS`) and AJS/VM code get modes OFF. `TjsCompat` directive explicitly disables all modes. `TjsStrict` enables all modes (useful for TS-originated code opting in).
+- **Bang access**: `x!.foo` — returns MonadicError if `x` is null/undefined, otherwise bare `x.foo`. Chains propagate: `x!.foo!.bar`.
+- **Type/Generic/FunctionPredicate**: Three declaration forms for runtime type predicates
+- **`const!`**: Compile-time immutability, zero runtime cost
+- **Equality**: `==`/`!=` = structural equality by default in native TJS (via `Is`/`IsNot`), `===`/`!==` = identity
+- **Polymorphic functions**: Multiple same-name declarations merge into arity/type dispatcher
+- **`extend` blocks**: Local class extensions without prototype pollution
+- **WASM blocks**: Inline WebAssembly compiled at transpile time, with SIMD intrinsics and `wasmBuffer()` zero-copy arrays
+- **`@tjs` annotations**: `/* @tjs ... */` comments in TS files enrich TJS output
 
-Point(3, 4) // variant 1
-Point({ x: 10, y: 20 }) // variant 2 (both produce correct instanceof)
-```
-
-The first constructor becomes the real JS constructor; additional variants become factory functions using `Object.create`.
-
-#### Local Class Extensions
-
-Add methods to built-in types without prototype pollution:
-
-```typescript
-extend String {
-  capitalize() { return this[0].toUpperCase() + this.slice(1) }
-}
-
-extend Array {
-  last() { return this[this.length - 1] }
-}
-
-'hello'.capitalize()  // 'Hello' — rewritten to __ext_String.capitalize.call('hello')
-[1, 2, 3].last()      // 3
-```
-
-- Methods are rewritten to `.call()` at transpile time for known-type receivers (zero overhead)
-- Runtime fallback via `registerExtension()`/`resolveExtension()` for unknown types
-- Arrow functions rejected (need `this` binding)
-- Multiple `extend` blocks for same type merge left-to-right
-- File-local only — no cross-module leaking
-
-## WASM Blocks
-
-TJS supports inline WebAssembly for performance-critical code. WASM blocks are compiled at transpile time and embedded as base64 in the output.
-
-### Syntax
+#### Runtime Configuration
 
 ```typescript
-const add = wasm (a: i32, b: i32) -> i32 {
-  local.get $a
-  local.get $b
-  i32.add
-}
-```
+import { configure } from 'tjs-lang/lang'
 
-### Features
-
-- **Transpile-time compilation**: WASM bytecode is generated during transpilation, not at runtime
-- **WAT comments**: Human-readable WebAssembly Text format is included as comments above the base64
-- **Type-safe**: Parameters and return types are validated
-- **Self-contained**: Compiled WASM is embedded in output JS, no separate .wasm files needed
-
-### Output Example
-
-The transpiler generates code like:
-
-```javascript
-/*
- * WASM Block: add
- * WAT (WebAssembly Text):
- *   (func $add (param $a i32) (param $b i32) (result i32)
- *     local.get 0
- *     local.get 1
- *     i32.add
- *   )
- */
-const add = await (async () => {
-  const bytes = Uint8Array.from(atob('AGFzbQEAAAA...'), (c) => c.charCodeAt(0))
-  const { instance } = await WebAssembly.instantiate(bytes)
-  return instance.exports.fn
-})()
+configure({ logTypeErrors: true }) // Log type errors to console
+configure({ throwTypeErrors: true }) // Throw instead of return (debugging)
+configure({ callStacks: true }) // Track call stacks in errors (~2x overhead)
+configure({ trackErrors: false }) // Disable error history (on by default)
 ```
 
-### SIMD Intrinsics (f32x4)
+#### Error History
 
-WASM blocks support explicit SIMD via `f32x4_*` intrinsics:
+Type errors are tracked in a ring buffer (on by default, zero cost on happy path):
 
 ```typescript
-const scale = wasm (arr: Float32Array, len: 0, factor: 0.0) -> 0 {
-  let s = f32x4_splat(factor)
-  for (let i = 0; i < len; i += 4) {
-    let off = i * 4
-    let v = f32x4_load(arr, off)
-    f32x4_store(arr, off, f32x4_mul(v, s))
-  }
-} fallback {
-  for (let i = 0; i < len; i++) arr[i] *= factor
-}
+__tjs.errors() // → recent MonadicErrors (newest last, max 64)
+__tjs.clearErrors() // → returns and clears the buffer
+__tjs.getErrorCount() // → total since last clear (survives buffer wrap)
 ```
 
-Available: `f32x4_load`, `f32x4_store`, `f32x4_splat`, `f32x4_extract_lane`, `f32x4_replace_lane`, `f32x4_add`, `f32x4_sub`, `f32x4_mul`, `f32x4_div`, `f32x4_neg`, `f32x4_sqrt`.
+Use for debugging (find silent failures), testing (`clearErrors()` → run → check), and monitoring.
 
-### Zero-Copy Arrays: `wasmBuffer()`
+#### Standalone JS Output
 
-`wasmBuffer(Constructor, length)` allocates typed arrays directly in WASM linear memory. When passed to a `wasm {}` block, these arrays are zero-copy — no marshalling overhead.
-
-```typescript
-// Allocate in WASM memory (zero-copy when passed to wasm blocks)
-const xs = wasmBuffer(Float32Array, 50000)
-
-// Works like a normal Float32Array from JS
-xs[0] = 3.14
-for (let i = 0; i < xs.length; i++) xs[i] = Math.random()
-
-// Zero-copy in WASM blocks — data is already in WASM memory
-function process(! xs: Float32Array, len: 0, delta: 0.0) {
-  wasm {
-    let vd = f32x4_splat(delta)
-    for (let i = 0; i < len; i += 4) {
-      let off = i * 4
-      f32x4_store(xs, off, f32x4_add(f32x4_load(xs, off), vd))
-    }
-  } fallback {
-    for (let i = 0; i < len; i++) xs[i] += delta
-  }
-}
-
-// After WASM runs, JS sees mutations immediately (same memory)
-```
-
-- Regular `Float32Array` args are copied in before and out after each WASM call
-- `wasmBuffer` arrays skip both copies (detected via `buffer === wasmMemory.buffer`)
-- Uses a bump allocator — allocations persist for program lifetime (no deallocation)
-- All WASM blocks in a file share one `WebAssembly.Memory` (64MB / 1024 pages)
-- Supports `Float32Array`, `Float64Array`, `Int32Array`, `Uint8Array`
-
-### Current Limitations
-
-- No imports/exports beyond the function itself
-- `wasmBuffer` allocations are permanent (bump allocator, no free)
+Emitted `.js` files work without any runtime setup. Each file includes an inline
+minimal runtime as fallback — only the functions actually used are included (~500
+bytes for a basic validated function). If `globalThis.__tjs` exists (shared runtime),
+it's used instead.
 
 ## Dependencies
 
@@ -731,7 +382,7 @@ Both `llmBattery` and `vector` can be `undefined`/`null` if LM Studio isn't avai
 
 ### Bun Plugin
 
-`bunfig.toml` preloads `src/bun-plugin/tjs-plugin.ts` which enables importing `.tjs` files directly in bun. It also aliases `tjs-lang` to `./src/index.ts` for local development (monorepo-style resolution).
+`bunfig.toml` preloads `src/bun-plugin/tjs-plugin.ts` which enables importing `.tjs` files directly in bun (transpiled on-the-fly). It also aliases `tjs-lang` to `./src/index.ts` for local development, so `import { tjs } from 'tjs-lang'` resolves to the source tree without needing `npm link` or a published package.
 
 ### Code Style
 
@@ -759,29 +410,41 @@ The `docs/` directory contains real documentation (markdown), not build artifact
 
 - `DOCS-TJS.md` — TJS language guide
 - `DOCS-AJS.md` — AJS runtime guide
+- `TJS-FOR-JS.md` — TJS guide for JavaScript developers (syntax differences, gotchas)
+- `TJS-FOR-TS.md` — TJS guide for TypeScript developers (migration, interop)
 - `CONTEXT.md` — Architecture deep dive
-- `AGENTS.md` — Agent workflow instructions (issue tracking with `bd`, mandatory push-before-done). **Critical**: work is NOT complete until `git push` succeeds; use `bd ready` to find work, `bd close <id>` to complete
+- `AGENTS.md` — Agent workflow instructions (issue tracking with `bd`, mandatory push-before-done)
 - `PLAN.md` — Roadmap
 
+### Issue Tracking with `bd`
+
+The project uses `bd` (beads) for issue tracking. Key commands:
+
+```bash
+bd ready                          # Find available work
+bd show <id>                      # View issue details
+bd update <id> --status in_progress  # Claim work
+bd close <id>                     # Complete work
+bd sync                           # Sync with git
+```
+
+**Critical rule**: Work is NOT complete until `git push` succeeds. Never stop before pushing — work stranded locally is work lost. If push fails, resolve and retry.
+
 ### Known Gotcha: `tjs()` Returns an Object, Not a String
 
 `tjs(source)` returns `{ code, types, metadata, testResults, ... }`. Use `.code` to get the transpiled JavaScript string. This is a common mistake.
 
-### Known Gotcha: Running Emitted TJS Code in Tests
+### Running Emitted TJS Code
 
-Transpiled TJS code requires `globalThis.__tjs` to be set up with `createRuntime()` before execution:
+Emitted JS works standalone — no setup required. Each file includes an inline
+runtime fallback. If you want the shared runtime (e.g. for `isMonadicError` to
+work across files), install it first:
 
 ```typescript
-import { createRuntime } from '../lang/runtime'
-
-const saved = globalThis.__tjs
-globalThis.__tjs = createRuntime()
-try {
-  const fn = new Function(result.code + '\nreturn fnName')()
-  // ... test fn
-} finally {
-  globalThis.__tjs = saved
-}
-```
+import { installRuntime, createRuntime } from '../lang/runtime'
+installRuntime() // or: globalThis.__tjs = createRuntime()
 
-A `{ standalone: true }` option to inline the ~1KB runtime is planned but not yet implemented.
+const fn = new Function(result.code + '\nreturn fnName')()
+fn('valid') // works
+fn(42) // returns MonadicError (not thrown)
+```