tjs-lang 0.2.7 → 0.3.0

package/src/lang/lang.test.ts

@@ -15,6 +15,7 @@ import {
   wrap,
 } from './index'
 import { preprocess } from './parser'
+import { createRuntime, isMonadicError } from './runtime'
 import { Schema } from './schema'
 
 describe('Transpiler', () => {
@@ -293,7 +294,7 @@ test 'always fails' { throw new Error('intentional') }
           return { count }
         }
       `)
-      expect(signature.parameters.count.type.kind).toBe('number')
+      expect(signature.parameters.count.type.kind).toBe('integer')
       expect(signature.parameters.count.required).toBe(true)
     })
 
@@ -303,7 +304,7 @@ test 'always fails' { throw new Error('intentional') }
           return { limit }
         }
       `)
-      expect(signature.parameters.limit.type.kind).toBe('number')
+      expect(signature.parameters.limit.type.kind).toBe('integer')
       expect(signature.parameters.limit.required).toBe(false)
       expect(signature.parameters.limit.default).toBe(10)
     })
@@ -336,7 +337,7 @@ test 'always fails' { throw new Error('intentional') }
       `)
       expect(signature.parameters.user.type.kind).toBe('object')
       expect(signature.parameters.user.type.shape?.name.kind).toBe('string')
-      expect(signature.parameters.user.type.shape?.age.kind).toBe('number')
+      expect(signature.parameters.user.type.shape?.age.kind).toBe('integer')
     })
 
     it('should handle array types with colon syntax', () => {
@@ -357,13 +358,150 @@ test 'always fails' { throw new Error('intentional') }
       `)
       expect(signature.parameters.name.type.kind).toBe('string')
       expect(signature.parameters.name.required).toBe(true)
-      expect(signature.parameters.count.type.kind).toBe('number')
+      expect(signature.parameters.count.type.kind).toBe('integer')
       expect(signature.parameters.count.required).toBe(true)
-      expect(signature.parameters.limit.type.kind).toBe('number')
+      expect(signature.parameters.limit.type.kind).toBe('integer')
       expect(signature.parameters.limit.required).toBe(false)
     })
   })
 
+  describe('Numeric type narrowing', () => {
+    it('should infer integer from whole number literal', () => {
+      const { signature } = transpile(`
+        function test(count: 42) { return { count } }
+      `)
+      expect(signature.parameters.count.type.kind).toBe('integer')
+    })
+
+    it('should infer float (number) from decimal literal', () => {
+      const { signature } = transpile(`
+        function test(rate: 3.14) { return { rate } }
+      `)
+      expect(signature.parameters.rate.type.kind).toBe('number')
+    })
+
+    it('should infer float from 0.0', () => {
+      const { signature } = transpile(`
+        function test(value: 0.0) { return { value } }
+      `)
+      expect(signature.parameters.value.type.kind).toBe('number')
+    })
+
+    it('should infer non-negative-integer from +N syntax', () => {
+      const { signature } = transpile(`
+        function test(age: +20) { return { age } }
+      `)
+      expect(signature.parameters.age.type.kind).toBe('non-negative-integer')
+    })
+
+    it('should infer non-negative-integer from +0', () => {
+      const { signature } = transpile(`
+        function test(index: +0) { return { index } }
+      `)
+      expect(signature.parameters.index.type.kind).toBe('non-negative-integer')
+    })
+
+    it('should infer integer from negative literal', () => {
+      const { signature } = transpile(`
+        function test(offset: -5) { return { offset } }
+      `)
+      expect(signature.parameters.offset.type.kind).toBe('integer')
+    })
+
+    it('should infer number from negative decimal', () => {
+      const { signature } = transpile(`
+        function test(temp: -3.5) { return { temp } }
+      `)
+      expect(signature.parameters.temp.type.kind).toBe('number')
+    })
+
+    it('should generate correct runtime validation for integer', () => {
+      const result = tjs(`function test(n: 1) -> 0 { return n }`)
+      // Should check Number.isInteger
+      expect(result.code).toContain('Number.isInteger')
+    })
+
+    it('should generate correct runtime validation for non-negative-integer', () => {
+      const result = tjs(`function test(n: +1) -> 0 { return n }`)
+      // Should check Number.isInteger AND >= 0
+      expect(result.code).toContain('Number.isInteger')
+      expect(result.code).toContain('< 0')
+    })
+
+    it('should validate integer at runtime', () => {
+      const result = tjs(`function check(n: 1) -> 0 { return n }`)
+      const savedTjs = globalThis.__tjs
+      globalThis.__tjs = createRuntime()
+      try {
+        const fn = new Function(result.code + '\nreturn check')()
+        // Valid integer
+        expect(fn(42)).toBe(42)
+        // Float should fail
+        const bad = fn(3.14)
+        expect(isMonadicError(bad)).toBe(true)
+      } finally {
+        globalThis.__tjs = savedTjs
+      }
+    })
+
+    it('should validate non-negative-integer at runtime', () => {
+      const result = tjs(`function check(n: +1) -> 0 { return n }`)
+      const savedTjs = globalThis.__tjs
+      globalThis.__tjs = createRuntime()
+      try {
+        const fn = new Function(result.code + '\nreturn check')()
+        // Valid non-negative integer
+        expect(fn(0)).toBe(0)
+        expect(fn(42)).toBe(42)
+        // Negative integer should fail
+        const negResult = fn(-1)
+        expect(isMonadicError(negResult)).toBe(true)
+        // Float should fail
+        const floatResult = fn(3.14)
+        expect(isMonadicError(floatResult)).toBe(true)
+      } finally {
+        globalThis.__tjs = savedTjs
+      }
+    })
+
+    it('should validate float (number) accepts all numbers at runtime', () => {
+      const result = tjs(`function check(n: 0.0) -> 0.0 { return n }`)
+      const savedTjs = globalThis.__tjs
+      globalThis.__tjs = createRuntime()
+      try {
+        const fn = new Function(result.code + '\nreturn check')()
+        // All numbers should pass for float
+        expect(fn(42)).toBe(42)
+        expect(fn(3.14)).toBe(3.14)
+        expect(fn(-5)).toBe(-5)
+        expect(fn(0)).toBe(0)
+      } finally {
+        globalThis.__tjs = savedTjs
+      }
+    })
+
+    it('should handle numeric types in object shapes', () => {
+      const { signature } = transpile(`
+        function test(point: { x: 0.0, y: 0.0, index: 0 }) { return point }
+      `)
+      expect(signature.parameters.point.type.shape?.x.kind).toBe('number')
+      expect(signature.parameters.point.type.shape?.y.kind).toBe('number')
+      expect(signature.parameters.point.type.shape?.index.kind).toBe('integer')
+    })
+
+    it('should handle numeric types in array items', () => {
+      const { signature } = transpile(`
+        function test(counts: [0]) { return counts }
+      `)
+      expect(signature.parameters.counts.type.items?.kind).toBe('integer')
+
+      const { signature: sig2 } = transpile(`
+        function test(values: [0.0]) { return values }
+      `)
+      expect(sig2.parameters.values.type.items?.kind).toBe('number')
+    })
+  })
+
   describe('Basic transpilation', () => {
     it('should transpile a simple function', () => {
       const { ast } = transpile(`
@@ -934,7 +1072,7 @@ describe('TJS Emitter', () => {
       `)
       expect(result.code).not.toContain('->')
       expect(result.types.add.returns).toBeDefined()
-      expect(result.types.add.returns?.kind).toBe('number')
+      expect(result.types.add.returns?.kind).toBe('integer')
     })
 
     it('should mark parameters as required when using colon syntax', () => {
@@ -968,7 +1106,7 @@ describe('TJS Emitter', () => {
         'string'
       )
       expect(result.types.process.params.user.type.shape?.age.kind).toBe(
-        'number'
+        'integer'
       )
     })
 
@@ -979,7 +1117,7 @@ describe('TJS Emitter', () => {
         }
       `)
       expect(result.types.sum.params.numbers.type.kind).toBe('array')
-      expect(result.types.sum.params.numbers.type.items?.kind).toBe('number')
+      expect(result.types.sum.params.numbers.type.items?.kind).toBe('integer')
     })
 
     it('should generate __tjs metadata object', () => {
@@ -1052,7 +1190,7 @@ function greet(name: 'world') {
         }
       `
       expect(result.code).toContain('function double')
-      expect(result.types.double.params.n.type.kind).toBe('number')
+      expect(result.types.double.params.n.type.kind).toBe('integer')
     })
 
     it('should handle interpolation in tagged template', () => {
@@ -1106,7 +1244,7 @@ function greet(name: 'world') {
       `)
       expect(result.types.test.returns).toBeDefined()
       expect(result.types.test.returns?.kind).toBe('object')
-      expect(result.types.test.returns?.shape?.result.kind).toBe('number')
+      expect(result.types.test.returns?.shape?.result.kind).toBe('integer')
     })
   })
 
@@ -1155,9 +1293,9 @@ function greet(name: 'world') {
           return x
         }
       `)
-      expect(result.types.compute.params.x.type.kind).toBe('number')
+      expect(result.types.compute.params.x.type.kind).toBe('integer')
       expect(result.types.compute.params.y.type.kind).toBe('string')
-      expect(result.types.compute.returns?.kind).toBe('number')
+      expect(result.types.compute.returns?.kind).toBe('integer')
     })
 
     // === NEW TESTS: Multi-function and no-function support ===
@@ -1350,8 +1488,8 @@ function greet(name: 'world') {
       `,
         { runTests: false }
       )
-      // Should have inline validation
-      expect(result.code).toContain("if (typeof a !== 'number')")
+      // Should have inline validation (integer check for integer examples)
+      expect(result.code).toContain('Number.isInteger(a)')
       expect(result.code).toContain('__tjs.typeError')
     })
 
@@ -1482,7 +1620,7 @@ describe('TypeScript to TJS Transpiler', () => {
         `function sum(nums: number[]): number { return 0 }`,
         { emitTJS: true }
       )
-      expect(result.code).toContain('nums: [0]')
+      expect(result.code).toContain('nums: [0.0]')
     })
 
     it('should handle object literal types', () => {
@@ -1490,7 +1628,7 @@ describe('TypeScript to TJS Transpiler', () => {
         `function getUser(): { name: string, age: number } { return { name: '', age: 0 } }`,
         { emitTJS: true }
       )
-      expect(result.code).toContain("-! { name: '', age: 0 }") // -! for TS-transpiled
+      expect(result.code).toContain("-! { name: '', age: 0.0 }") // -! for TS-transpiled
     })
 
     it('should handle nullable types', () => {
@@ -2816,7 +2954,10 @@ function process(a: [], b: []) {
     expect(result.source).toContain('globalThis.__tjs_wasm_1')
   })
 
-  it('should execute fallback when WASM not available', () => {
+  it('should compile WASM at transpile time and embed in output', async () => {
+    const { installRuntime } = require('./runtime')
+    installRuntime()
+
     const result = tjs(`
 function double(x: 0, y: 0) {
   return wasm {
@@ -2824,12 +2965,27 @@ function double(x: 0, y: 0) {
   }
 }`)
 
-    // Execute with fallback (no WASM registered)
-    const fn = new Function(`${result.code}; return double(3, 4);`)
-    expect(fn()).toBe(15) // 3 * 4 + 3 = 15
+    // WASM should be compiled at transpile time
+    expect(result.wasmCompiled).toBeDefined()
+    expect(result.wasmCompiled?.length).toBe(1)
+    expect(result.wasmCompiled?.[0].success).toBe(true)
+    expect(result.wasmCompiled?.[0].byteLength).toBeGreaterThan(0)
+
+    // Output should contain base64-encoded WASM
+    expect(result.code).toContain('__wasmBlocks')
+    expect(result.code).toContain('b64:')
+
+    // Execute with async function to allow WASM instantiation
+    const fn = new Function(
+      'return (async () => {' + result.code + '; return double(3, 4); })()'
+    )
+    expect(await fn()).toBe(15) // 3 * 4 + 3 = 15
   })
 
-  it('should use WASM when available', () => {
+  it('should use WASM compute function when instantiated', async () => {
+    const { installRuntime } = require('./runtime')
+    installRuntime()
+
     const result = tjs(`
 function compute(a: 0, b: 0) {
   return wasm {
@@ -2837,30 +2993,31 @@ function compute(a: 0, b: 0) {
   }
 }`)
 
-    // Register a mock WASM implementation
-    const code = `
-      globalThis.__tjs_wasm_0 = (a, b) => a * b * 100;
-      ${result.code}
-      const result = compute(3, 4);
-      delete globalThis.__tjs_wasm_0;
-      return result;
-    `
-    const fn = new Function(code)
-    // Should use the "WASM" version (our mock)
-    expect(fn()).toBe(1200) // 3 * 4 * 100
+    // Execute async to allow WASM instantiation
+    const fn = new Function(
+      'return (async () => {' + result.code + '; return compute(3, 4); })()'
+    )
+    // Should use the actual WASM version
+    expect(await fn()).toBe(7) // 3 + 4 = 7
   })
 
-  it('should use explicit fallback when provided', () => {
+  it('should use explicit fallback when WASM compilation fails', () => {
+    // Test with code that can't compile to WASM (array.map)
     const result = tjs(`
 function transform(arr: []) {
   return wasm {
-    return arr
+    return arr.map(x => x * 2)
   } fallback {
     return arr.map(x => x * 2)
   }
 }`)
 
-    // Fallback should use the explicit fallback code
+    // WASM compilation should fail (array.map not supported)
+    expect(result.wasmCompiled?.[0].success).toBe(false)
+
+    // But code should still work using fallback
+    const { installRuntime } = require('./runtime')
+    installRuntime()
     const fn = new Function(`${result.code}; return transform([1, 2, 3]);`)
     expect(fn()).toEqual([2, 4, 6])
   })

package/src/lang/roundtrip.test.ts

@@ -0,0 +1,155 @@
+/**
+ * TJS Roundtrip Tests
+ *
+ * These tests verify that TJS code "just works" through the full pipeline:
+ * 1. Parse TJS source
+ * 2. Transpile to JS
+ * 3. Execute the result
+ *
+ * NOTE: Currently transpiled code requires globalThis.__tjs runtime to be set up.
+ * This is a known limitation - see TODO.md for "self-contained transpiler output".
+ */
+
+import { describe, test, expect, beforeAll } from 'bun:test'
+import { tjs } from './index'
+import { Is, IsNot } from './runtime'
+
+// Set up the minimal runtime needed for transpiled code
+beforeAll(() => {
+  ;(globalThis as any).__tjs = {
+    Is,
+    IsNot,
+    pushStack: () => {},
+    popStack: () => {},
+    typeError: (path: string, expected: string, got: any) => {
+      const err = new Error(
+        `Type error at ${path}: expected ${expected}, got ${typeof got}`
+      )
+      ;(err as any).$error = true
+      return err
+    },
+    createRuntime: () => (globalThis as any).__tjs,
+  }
+})
+
+/** Helper to execute transpiled code and capture console output */
+function execCode(code: string): any[] {
+  const logs: any[] = []
+  const mockConsole = { log: (...args: any[]) => logs.push(args) }
+  const fn = new Function('console', code)
+  fn(mockConsole)
+  return logs
+}
+
+describe('TJS roundtrip - code should just work', () => {
+  test('basic function with type annotations', () => {
+    const source = `
+function add(a: 0, b: 0) -> 0 {
+  return a + b
+}
+console.log(add(2, 3))
+`
+    const result = tjs(source, { runTests: false })
+    expect(result.code).toBeDefined()
+
+    const logs = execCode(result.code)
+    expect(logs[0]).toEqual([5])
+  })
+
+  test('template literals (backticks)', () => {
+    const source = `
+function greet(name: 'World') -> '' {
+  return \`Hello, \${name}!\`
+}
+console.log(greet('TJS'))
+`
+    const result = tjs(source, { runTests: false })
+    expect(result.code).toContain('Hello')
+
+    const logs = execCode(result.code)
+    expect(logs[0]).toEqual(['Hello, TJS!'])
+  })
+
+  test('inline tests execute at transpile time', () => {
+    const source = `
+function double(x: 0) -> 0 {
+  return x * 2
+}
+
+test 'double works' {
+  expect(double(5)).toBe(10)
+}
+`
+    // Tests run during transpilation - check the testResults array
+    const result = tjs(source, { runTests: 'report' })
+
+    // testResults contains test outcomes
+    expect(result.testResults).toBeDefined()
+    expect(result.testResults!.length).toBeGreaterThan(0)
+    const allPassed = result.testResults!.every((r: any) => r.passed)
+    expect(allPassed).toBe(true)
+  })
+
+  test('apostrophes in strings', () => {
+    const source = `
+const msg1 = "You can't do this in Jest"
+const msg2 = "You'd need to export everything"
+console.log(msg1, msg2)
+`
+    const result = tjs(source, { runTests: false })
+    expect(result.code).toContain("can't")
+    expect(result.code).toContain("You'd")
+  })
+
+  test('escaped newlines in strings', () => {
+    const source = `
+console.log('Line 1\\nLine 2')
+`
+    const result = tjs(source, { runTests: false })
+    const logs = execCode(result.code)
+    expect(logs[0][0]).toContain('\n')
+  })
+
+  test('regex patterns with escapes', () => {
+    const source = `
+const EMAIL_REGEX = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/
+console.log(EMAIL_REGEX.test('test@example.com'))
+`
+    const result = tjs(source, { runTests: false })
+    const logs = execCode(result.code)
+    expect(logs[0]).toEqual([true])
+  })
+
+  test('multiline JSDoc comments with backticks', () => {
+    const source = `
+/**
+ * Returns \`hello\` to the caller
+ */
+function myFunc() {
+  return 42
+}
+console.log(myFunc())
+`
+    const result = tjs(source, { runTests: false })
+    const logs = execCode(result.code)
+    expect(logs[0]).toEqual([42])
+  })
+})
+
+describe('TJS imports', () => {
+  test('imports pass through unchanged (current behavior)', () => {
+    const source = `
+import { AgentVM, ajs } from 'tjs-lang'
+
+async function run() {
+  const vm = new AgentVM()
+  return vm
+}
+`
+    const result = tjs(source, { runTests: false })
+
+    // Currently imports pass through - this means code won't work
+    // standalone in browser without import map resolution
+    expect(result.code).toContain("import { AgentVM, ajs } from 'tjs-lang'")
+  })
+})

package/src/lang/runtime.ts

@@ -563,6 +563,13 @@ export function checkType(
   if (expected === 'number' && actual === 'number') return null
   if (expected === 'integer' && actual === 'number' && Number.isInteger(value))
     return null
+  if (
+    expected === 'non-negative-integer' &&
+    actual === 'number' &&
+    Number.isInteger(value) &&
+    (value as number) >= 0
+  )
+    return null
 
   // Object matching (basic)
   if (expected === 'object' && actual === 'object') return null

package/src/lang/types.ts

@@ -14,6 +14,8 @@ export interface TypeDescriptor {
   kind:
     | 'string'
     | 'number'
+    | 'integer'
+    | 'non-negative-integer'
     | 'boolean'
     | 'null'
     | 'undefined'

package/src/lang/typescript-syntax.test.ts

@@ -42,7 +42,7 @@ describe('Basic Types', () => {
           return x * 2
         }
       `)
-      expect(getFirstFunc(metadata).params.x.type.kind).toBe('number')
+      expect(getFirstFunc(metadata).params.x.type.kind).toBe('integer')
     })
 
     test('boolean parameter', () => {
@@ -76,7 +76,7 @@ describe('Basic Types', () => {
         'string'
       )
       expect(getFirstFunc(metadata).params.user.type.shape?.age.kind).toBe(
-        'number'
+        'integer'
       )
     })
 
@@ -101,7 +101,9 @@ describe('Basic Types', () => {
         }
       `)
       expect(getFirstFunc(metadata).params.nums.type.kind).toBe('array')
-      expect(getFirstFunc(metadata).params.nums.type.items?.kind).toBe('number')
+      expect(getFirstFunc(metadata).params.nums.type.items?.kind).toBe(
+        'integer'
+      )
     })
 
     test('array of objects', () => {
@@ -729,7 +731,7 @@ describe('Literal Types', () => {
         return n
       }
     `)
-    expect(getFirstFunc(metadata).params.n.type.kind).toBe('number')
+    expect(getFirstFunc(metadata).params.n.type.kind).toBe('integer')
   })
 
   test('literal union type alias emits TJS Union', () => {

package/src/lang/wasm.test.ts

@@ -45,6 +45,26 @@ describe('WASM Compiler', () => {
       expect(result.success).toBe(true)
     })
 
+    it('should include WAT disassembly in result', () => {
+      const block: WasmBlock = {
+        id: '__tjs_wasm_test_wat',
+        body: 'return a + b',
+        captures: ['a', 'b'],
+        start: 0,
+        end: 0,
+      }
+
+      const result = compileToWasm(block)
+      expect(result.success).toBe(true)
+      expect(result.wat).toBeDefined()
+      expect(result.wat).toContain('(func (export "compute")')
+      expect(result.wat).toContain('(param $a f64)')
+      expect(result.wat).toContain('(param $b f64)')
+      expect(result.wat).toContain('f64.add')
+      expect(result.wat).toContain('local.get $a')
+      expect(result.wat).toContain('local.get $b')
+    })
+
     it('should compile multiplication', () => {
       const block: WasmBlock = {
         id: '__tjs_wasm_test_3',