tjs-lang 0.5.2 → 0.5.4

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

@@ -13,7 +13,7 @@
  */
 
 import { describe, test, expect } from 'bun:test'
-import { transpileToJS, fromTS } from './index'
+import { transpileToJS, fromTS, tjs } from './index'
 
 // Helper to get the first function's metadata from the Record
 function getFirstFunc(metadata: Record<string, any>) {
@@ -125,9 +125,9 @@ describe('Basic Types', () => {
 // =============================================================================
 
 describe('Union Types', () => {
-  test('union with || (TJS style)', () => {
+  test('union with | (string or integer)', () => {
     const { metadata } = transpileToJS(`
-      function flexible(id: '' || 0) {
+      function flexible(id: '' | 0) {
         return String(id)
       }
     `)
@@ -135,9 +135,9 @@ describe('Union Types', () => {
     expect(getFirstFunc(metadata).params.id.type.members?.length).toBe(2)
   })
 
-  test('nullable with || null', () => {
+  test('nullable with | null', () => {
     const { metadata } = transpileToJS(`
-      function maybeString(s: '' || null) {
+      function maybeString(s: '' | null) {
         return s ?? 'default'
       }
     `)
@@ -153,18 +153,7 @@ describe('Union Types', () => {
     expect(types?.flexible.params.id.type.kind).toBe('union')
   })
 
-  test('union return type with || (TJS style)', () => {
-    const { metadata } = transpileToJS(`
-      function find(id: 0) -! { name: '' } || null {
-        return null
-      }
-    `)
-    expect(getFirstFunc(metadata).returns?.kind).toBe('object')
-    expect(getFirstFunc(metadata).returns?.nullable).toBe(true)
-  })
-
-  // TODO: Union return types like `{ obj } | null` not yet supported in parser
-  test.skip('union return type with | (TS style)', () => {
+  test('union return type with | (nullable object)', () => {
     const { metadata } = transpileToJS(`
       function find(id: 0) -! { name: '' } | null {
         return null
@@ -858,6 +847,20 @@ describe('Real-World Patterns', () => {
     // Generic T becomes any, but structure is preserved
     expect(types?.chunk.params.array.type.kind).toBe('array')
   })
+
+  test('?: boolean transpiles to required union param with no JS default', () => {
+    const tjsCode = fromTS('function f(excited?: boolean) { return excited }', {
+      emitTJS: true,
+    }).code
+    // TJS should have union annotation
+    expect(tjsCode).toContain('excited: false | undefined')
+    const jsResult = tjs(tjsCode)
+    // JS should not have default or bitwise OR — `:` means required
+    expect(jsResult.code).not.toMatch(/excited = false/)
+    expect(jsResult.code).not.toMatch(/excited = false \| undefined/)
+    // Should have union type check
+    expect(jsResult.code).toContain("typeof excited !== 'boolean'")
+  })
 })
 
 // =============================================================================

package/src/runtime.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'bun:test'
-import { defineAtom } from './runtime'
+import { defineAtom, isAgentError } from './runtime'
 import { AgentVM } from './vm'
 import { s } from 'tosijs-schema'
 import { ajs } from './transpiler'
@@ -611,11 +611,17 @@ describe('Edge Cases', () => {
               right: { $expr: 'literal', value: [1, 2, 3] },
             },
           },
-          { op: 'return', value: { $expr: 'ident', name: 'res' } },
+          {
+            op: 'return',
+            schema: {
+              type: 'object',
+              properties: { res: { type: 'boolean' } },
+            },
+          },
         ],
       } as any
       const result = await vm.run(ast, {})
-      expect(result.result).toBe(true)
+      expect(result.result.res).toBe(true)
     })
 
     it('== compares objects structurally', async () => {
@@ -632,11 +638,17 @@ describe('Edge Cases', () => {
               right: { $expr: 'literal', value: { a: 1, b: 2 } },
             },
           },
-          { op: 'return', value: { $expr: 'ident', name: 'res' } },
+          {
+            op: 'return',
+            schema: {
+              type: 'object',
+              properties: { res: { type: 'boolean' } },
+            },
+          },
         ],
       } as any
       const result = await vm.run(ast, {})
-      expect(result.result).toBe(true)
+      expect(result.result.res).toBe(true)
     })
 
     it('== does not coerce types', async () => {
@@ -653,11 +665,17 @@ describe('Edge Cases', () => {
               right: { $expr: 'literal', value: 1 },
             },
           },
-          { op: 'return', value: { $expr: 'ident', name: 'res' } },
+          {
+            op: 'return',
+            schema: {
+              type: 'object',
+              properties: { res: { type: 'boolean' } },
+            },
+          },
         ],
       } as any
       const result = await vm.run(ast, {})
-      expect(result.result).toBe(false) // no coercion
+      expect(result.result.res).toBe(false) // no coercion
     })
 
     it('!= returns true for structurally different objects', async () => {
@@ -674,11 +692,17 @@ describe('Edge Cases', () => {
               right: { $expr: 'literal', value: { a: 2 } },
             },
           },
-          { op: 'return', value: { $expr: 'ident', name: 'res' } },
+          {
+            op: 'return',
+            schema: {
+              type: 'object',
+              properties: { res: { type: 'boolean' } },
+            },
+          },
         ],
       } as any
       const result = await vm.run(ast, {})
-      expect(result.result).toBe(true)
+      expect(result.result.res).toBe(true)
     })
 
     it('null == undefined is true (nullish equality)', async () => {
@@ -695,11 +719,17 @@ describe('Edge Cases', () => {
               right: { $expr: 'ident', name: 'missing' },
             },
           },
-          { op: 'return', value: { $expr: 'ident', name: 'res' } },
+          {
+            op: 'return',
+            schema: {
+              type: 'object',
+              properties: { res: { type: 'boolean' } },
+            },
+          },
         ],
       } as any
       const result = await vm.run(ast, {})
-      expect(result.result).toBe(true) // null == undefined
+      expect(result.result.res).toBe(true) // null == undefined
     })
 
     it('=== still uses identity comparison', async () => {
@@ -716,11 +746,112 @@ describe('Edge Cases', () => {
               right: { $expr: 'literal', value: [1, 2] },
             },
           },
-          { op: 'return', value: { $expr: 'ident', name: 'res' } },
+          {
+            op: 'return',
+            schema: {
+              type: 'object',
+              properties: { res: { type: 'boolean' } },
+            },
+          },
         ],
       } as any
       const result = await vm.run(ast, {})
-      expect(result.result).toBe(false) // different references
+      expect(result.result.res).toBe(false) // different references
+    })
+  })
+
+  describe('strict object returns', () => {
+    it('should allow object returns', async () => {
+      const ast = ajs(`function test() { return { value: 42 } }`)
+      const result = await vm.run(ast, {})
+      expect(result.result).toEqual({ value: 42 })
+      expect(result.error).toBeUndefined()
+    })
+
+    it('should allow empty object returns', async () => {
+      const ast = ajs(`function test() { return {} }`)
+      const result = await vm.run(ast, {})
+      expect(result.result).toEqual({})
+      expect(result.error).toBeUndefined()
+    })
+
+    it('should allow bare return (no value)', async () => {
+      const ast = {
+        op: 'seq',
+        steps: [{ op: 'return', value: undefined }],
+      } as any
+      const result = await vm.run(ast, {})
+      expect(result.error).toBeUndefined()
+    })
+
+    it('should allow null return', async () => {
+      const ast = {
+        op: 'seq',
+        steps: [{ op: 'return', value: null }],
+      } as any
+      const result = await vm.run(ast, {})
+      expect(result.error).toBeUndefined()
+    })
+
+    it('should reject number return', async () => {
+      const ast = {
+        op: 'seq',
+        steps: [{ op: 'return', value: { $expr: 'literal', value: 42 } }],
+      } as any
+      const result = await vm.run(ast, {})
+      expect(isAgentError(result.result)).toBe(true)
+      expect(result.error?.message).toContain('must return an object')
+      expect(result.error?.message).toContain('number')
+    })
+
+    it('should reject string return', async () => {
+      const ast = {
+        op: 'seq',
+        steps: [{ op: 'return', value: { $expr: 'literal', value: 'hello' } }],
+      } as any
+      const result = await vm.run(ast, {})
+      expect(isAgentError(result.result)).toBe(true)
+      expect(result.error?.message).toContain('must return an object')
+      expect(result.error?.message).toContain('string')
+    })
+
+    it('should reject array return', async () => {
+      const ast = {
+        op: 'seq',
+        steps: [
+          { op: 'return', value: { $expr: 'literal', value: [1, 2, 3] } },
+        ],
+      } as any
+      const result = await vm.run(ast, {})
+      expect(isAgentError(result.result)).toBe(true)
+      expect(result.error?.message).toContain('must return an object')
+      expect(result.error?.message).toContain('array')
+    })
+
+    it('should reject boolean return', async () => {
+      const ast = {
+        op: 'seq',
+        steps: [{ op: 'return', value: { $expr: 'literal', value: true } }],
+      } as any
+      const result = await vm.run(ast, {})
+      expect(isAgentError(result.result)).toBe(true)
+      expect(result.error?.message).toContain('must return an object')
+      expect(result.error?.message).toContain('boolean')
+    })
+
+    it('should allow AgentError to propagate through return', async () => {
+      // Errors are objects but need special handling — must not be blocked
+      const ast = ajs(`
+        function test({ x }) {
+          if (x < 0) {
+            return { error: 'negative' }
+          }
+          return { value: x }
+        }
+      `)
+      const result = await vm.run(ast, { x: -1 })
+      expect(result.result).toEqual({ error: 'negative' })
+      expect(result.error).toBeUndefined()
     })
   })
 })

package/src/test-examples.test.ts

@@ -20,9 +20,7 @@ const ajsExamples = loadExamples(join(ROOT, 'guides/examples/ajs'))
 
 describe('loadExample helper', () => {
   test('extracts metadata, title, language, and code', () => {
-    const ex = loadExample(
-      join(ROOT, 'guides/examples/tjs/hello-tjs.md')
-    )
+    const ex = loadExample(join(ROOT, 'guides/examples/tjs/hello-tjs.md'))
     expect(ex.title).toBeTruthy()
     expect(ex.code).toBeTruthy()
     expect(ex.language).toBe('tjs')
@@ -31,9 +29,7 @@ describe('loadExample helper', () => {
   })
 
   test('extracts description', () => {
-    const ex = loadExample(
-      join(ROOT, 'guides/examples/ajs/hello-world.md')
-    )
+    const ex = loadExample(join(ROOT, 'guides/examples/ajs/hello-world.md'))
     expect(ex.description).toContain('greeting')
   })
 })
@@ -71,13 +67,9 @@ describe('TJS examples with inline tests', () => {
 
     test(`${ex.title} tests pass`, () => {
       const result = tjs(ex.code, { runTests: 'report' })
-      const failures = (result.testResults || []).filter(
-        (t: any) => !t.passed
-      )
+      const failures = (result.testResults || []).filter((t: any) => !t.passed)
       if (failures.length > 0) {
-        const msgs = failures.map(
-          (f: any) => `${f.description}: ${f.error}`
-        )
+        const msgs = failures.map((f: any) => `${f.description}: ${f.error}`)
         throw new Error(`Test failures:\n${msgs.join('\n')}`)
       }
     })

package/src/test-examples.ts

@@ -60,7 +60,9 @@ export function parseExample(content: string, filePath = ''): ExampleFile {
   if (metaMatch) {
     try {
       metadata = JSON.parse(metaMatch[1])
-    } catch {}
+    } catch {
+      /* invalid JSON metadata, ignore */
+    }
   }
 
   // Extract title from first # heading

package/src/vm/runtime.ts

@@ -1554,6 +1554,25 @@ export const ret = defineAtom(
     // New style: return has explicit value
     if ('value' in step) {
       const res = resolveValue(step.value, ctx)
+
+      // Enforce object returns — agents must return objects for composability
+      if (
+        res !== undefined &&
+        res !== null &&
+        !isAgentError(res) &&
+        (typeof res !== 'object' || Array.isArray(res))
+      ) {
+        const err = new AgentError(
+          `Agent must return an object, got ${
+            Array.isArray(res) ? 'array' : typeof res
+          }`,
+          'return'
+        )
+        ctx.error = err
+        ctx.output = err
+        return err
+      }
+
       ctx.output = res
       return res
     }