tjs-lang 0.2.8 → 0.3.0

package/editors/codemirror/ajs-language.ts

@@ -1353,6 +1353,17 @@ function getPlaceholderForParam(name: string, info: any): string {
     return String(ex)
   }
 
+  // Then check for examples from schema metadata (use first as placeholder)
+  const examples = info.type?.examples || info.examples
+  if (Array.isArray(examples) && examples.length > 0) {
+    const ex = examples[0]
+    if (typeof ex === 'string') return `'${ex}'`
+    if (typeof ex === 'number' || typeof ex === 'boolean') return String(ex)
+    if (Array.isArray(ex)) return JSON.stringify(ex)
+    if (typeof ex === 'object') return JSON.stringify(ex)
+    return String(ex)
+  }
+
   // Then check for explicit default value
   if (info.default !== undefined && info.default !== null) {
     const def = info.default
@@ -1481,12 +1492,27 @@ function tjsCompletionSource(config: AutocompleteConfig = {}) {
             // Handle both { type: 'string' } and { kind: 'string' } formats
             const returnType =
               meta.returns?.type || meta.returns?.kind || 'void'
+
+            // Build info string with description and parameter examples
+            let infoText = meta.description || ''
+            for (const [pName, pInfo] of paramEntries as [string, any][]) {
+              const pExamples = pInfo.type?.examples || pInfo.examples
+              if (Array.isArray(pExamples) && pExamples.length > 0) {
+                const formatted = pExamples
+                  .map((ex: any) =>
+                    typeof ex === 'string' ? `'${ex}'` : String(ex)
+                  )
+                  .join(', ')
+                infoText += `${infoText ? '\n' : ''}${pName}: e.g. ${formatted}`
+              }
+            }
+
             options.push(
               snippetCompletion(`${name}(${snippetParams})`, {
                 label: name,
                 type: 'function',
                 detail: `(${paramList}) -> ${returnType}`,
-                info: meta.description,
+                info: infoText || undefined,
                 boost: 2, // Boost user-defined functions above globals
               })
             )

package/editors/codemirror/autocomplete.test.ts

@@ -432,8 +432,8 @@ const after = 2
 
       expect(metadata).toBeDefined()
       // metadata is now keyed by function name
-      expect(metadata?.add?.params?.a?.type?.kind).toBe('number')
-      expect(metadata?.add?.params?.b?.type?.kind).toBe('number')
+      expect(metadata?.add?.params?.a?.type?.kind).toBe('integer')
+      expect(metadata?.add?.params?.b?.type?.kind).toBe('integer')
     })
 
     it('extracts example-based types', () => {
@@ -445,7 +445,7 @@ const after = 2
       expect(metadata).toBeDefined()
       // metadata is now keyed by function name
       expect(metadata?.greet?.params?.name?.type?.kind).toBe('string')
-      expect(metadata?.greet?.params?.times?.type?.kind).toBe('number')
+      expect(metadata?.greet?.params?.times?.type?.kind).toBe('integer')
       expect(metadata?.greet?.params?.times?.default).toBe(1)
     })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tjs-lang",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "Type-safe JavaScript dialect with runtime validation, sandboxed VM execution, and AI agent orchestration. Transpiles TypeScript to validated JS with fuel-metered execution for untrusted code.",
   "keywords": [
     "typescript",

package/src/lang/codegen.test.ts

@@ -54,7 +54,7 @@ describe('TS → TJS conversion quality', () => {
       const ts = `function sum(nums: number[]): number { return nums.reduce((a, b) => a + b, 0) }`
       const { code } = fromTS(ts, { emitTJS: true })
 
-      expect(code).toContain('nums: [0]')
+      expect(code).toContain('nums: [0.0]')
     })
 
     it('converts object param correctly', () => {
@@ -62,7 +62,7 @@ describe('TS → TJS conversion quality', () => {
       const { code } = fromTS(ts, { emitTJS: true })
 
       expect(code).toContain("name: ''")
-      expect(code).toContain('age: 0')
+      expect(code).toContain('age: 0.0')
     })
 
     it('handles multiple params in order', () => {
@@ -70,7 +70,7 @@ describe('TS → TJS conversion quality', () => {
       const { code } = fromTS(ts, { emitTJS: true })
 
       // Should have both params with colon syntax
-      expect(code).toMatch(/add\(a: 0, b: 0\)/)
+      expect(code).toMatch(/add\(a: 0\.0, b: 0\.0\)/)
     })
 
     it('handles mixed required and optional params', () => {
@@ -228,7 +228,7 @@ class Calculator {
 `
       const { code } = fromTS(ts, { emitTJS: true })
 
-      expect(code).toContain('add(a: 0, b: 0) -! 0')
+      expect(code).toContain('add(a: 0.0, b: 0.0) -! 0.0')
     })
 
     it('converts getters and setters', () => {
@@ -269,7 +269,7 @@ class MathUtils {
 `
       const { code } = fromTS(ts, { emitTJS: true })
 
-      expect(code).toContain('static double(x: 0) -! 0')
+      expect(code).toContain('static double(x: 0.0) -! 0.0')
     })
 
     it('converts async methods', () => {
@@ -396,7 +396,7 @@ describe('TJS → JS transpilation quality', () => {
 
       expect(code).toContain('__tjs')
       // types is now keyed by function name
-      expect(types?.double?.returns?.kind).toBe('number')
+      expect(types?.double?.returns?.kind).toBe('integer')
     })
 
     it('marks required params correctly', () => {
@@ -561,8 +561,8 @@ function greet(name: string): string {
       const { code } = fromTS(ts, { emitTJS: true })
 
       // All functions should be present (TS transpiler uses -! to skip signature tests)
-      expect(code).toContain('function add(a: 0, b: 0) -! 0')
-      expect(code).toContain('function multiply(a: 0, b: 0) -! 0')
+      expect(code).toContain('function add(a: 0.0, b: 0.0) -! 0.0')
+      expect(code).toContain('function multiply(a: 0.0, b: 0.0) -! 0.0')
       expect(code).toContain("function greet(name: '') -! ''")
 
       // Should be valid TJS (no TypeScript syntax remaining)
@@ -738,7 +738,7 @@ function greet(name: '', excited = false) -! '' {
       // add function
       expect(types?.add?.params?.a?.required).toBe(true)
       expect(types?.add?.params?.b?.required).toBe(true)
-      expect(types?.add?.returns?.kind).toBe('number')
+      expect(types?.add?.returns?.kind).toBe('integer')
 
       // greet function
       expect(types?.greet?.params?.name?.required).toBe(true)
@@ -1146,7 +1146,7 @@ function processUser(user: { name: string; age: number }): string {
       // TS → TJS
       const { code: tjsCode } = fromTS(ts, { emitTJS: true })
       expect(tjsCode).toContain("name: ''")
-      expect(tjsCode).toContain('age: 0')
+      expect(tjsCode).toContain('age: 0.0')
 
       // TJS → JS (already has -! from TS transpiler)
       const { code: jsCode, types } = tjs(tjsCode)
@@ -1386,7 +1386,7 @@ function getData(id: 0) -! { value: 0 } {
       expect(result.value).toBeUndefined()
 
       // But error properties are accessible
-      expect(result.message).toContain('Expected number')
+      expect(result.message).toContain('Expected integer')
     })
   })
 

package/src/lang/emitters/from-ts.ts

@@ -137,7 +137,7 @@ function typeToExample(
     case ts.SyntaxKind.StringKeyword:
       return "''"
     case ts.SyntaxKind.NumberKeyword:
-      return '0'
+      return '0.0'
     case ts.SyntaxKind.BooleanKeyword:
       return 'true'
     case ts.SyntaxKind.NullKeyword:

package/src/lang/emitters/js.ts

@@ -868,6 +868,10 @@ function generateTypeCheckExpr(
       return `typeof ${fieldPath} !== 'string'`
     case 'number':
       return `typeof ${fieldPath} !== 'number'`
+    case 'integer':
+      return `(typeof ${fieldPath} !== 'number' || !Number.isInteger(${fieldPath}))`
+    case 'non-negative-integer':
+      return `(typeof ${fieldPath} !== 'number' || !Number.isInteger(${fieldPath}) || ${fieldPath} < 0)`
     case 'boolean':
       return `typeof ${fieldPath} !== 'boolean'`
     case 'null':
@@ -1493,6 +1497,41 @@ function runAllTests(
             if (!__deepEqual(actual, expected)) {
               throw new Error('Expected ' + __format(expected) + ' but got ' + __format(actual))
             }
+          },
+          toContain(item) {
+            if (!Array.isArray(actual) || !actual.some(function(v) { return __deepEqual(v, item) })) {
+              throw new Error('Expected ' + __format(actual) + ' to contain ' + __format(item))
+            }
+          },
+          toBeTruthy() {
+            if (!actual) {
+              throw new Error('Expected ' + __format(actual) + ' to be truthy')
+            }
+          },
+          toBeFalsy() {
+            if (actual) {
+              throw new Error('Expected ' + __format(actual) + ' to be falsy')
+            }
+          },
+          toBeNull() {
+            if (actual !== null) {
+              throw new Error('Expected null but got ' + __format(actual))
+            }
+          },
+          toBeUndefined() {
+            if (actual !== undefined) {
+              throw new Error('Expected undefined but got ' + __format(actual))
+            }
+          },
+          toBeGreaterThan(n) {
+            if (!(actual > n)) {
+              throw new Error('Expected ' + __format(actual) + ' to be greater than ' + n)
+            }
+          },
+          toBeLessThan(n) {
+            if (!(actual < n)) {
+              throw new Error('Expected ' + __format(actual) + ' to be less than ' + n)
+            }
           }
         }
       }
@@ -1634,6 +1673,41 @@ function runTestBlocks(
                 if (!__deepEqual(actual, expected)) {
                   throw new Error('Expected ' + __format(expected) + ' but got ' + __format(actual))
                 }
+              },
+              toContain(item) {
+                if (!Array.isArray(actual) || !actual.some(function(v) { return __deepEqual(v, item) })) {
+                  throw new Error('Expected ' + __format(actual) + ' to contain ' + __format(item))
+                }
+              },
+              toBeTruthy() {
+                if (!actual) {
+                  throw new Error('Expected ' + __format(actual) + ' to be truthy')
+                }
+              },
+              toBeFalsy() {
+                if (actual) {
+                  throw new Error('Expected ' + __format(actual) + ' to be falsy')
+                }
+              },
+              toBeNull() {
+                if (actual !== null) {
+                  throw new Error('Expected null but got ' + __format(actual))
+                }
+              },
+              toBeUndefined() {
+                if (actual !== undefined) {
+                  throw new Error('Expected undefined but got ' + __format(actual))
+                }
+              },
+              toBeGreaterThan(n) {
+                if (!(actual > n)) {
+                  throw new Error('Expected ' + __format(actual) + ' to be greater than ' + n)
+                }
+              },
+              toBeLessThan(n) {
+                if (!(actual < n)) {
+                  throw new Error('Expected ' + __format(actual) + ' to be less than ' + n)
+                }
               }
             }
           }

package/src/lang/inference.ts

@@ -29,7 +29,13 @@ export function inferTypeFromValue(node: Expression): TypeDescriptor {
         return { kind: 'string' }
       }
       if (typeof value === 'number') {
-        return { kind: 'number' }
+        // Distinguish float vs integer by checking if source contains '.'
+        // 2.0 -> number (float), 42 -> integer
+        const raw = (node as any).raw as string | undefined
+        if (raw && raw.includes('.')) {
+          return { kind: 'number' }
+        }
+        return { kind: 'integer' }
       }
       if (typeof value === 'boolean') {
         return { kind: 'boolean' }
@@ -110,14 +116,26 @@ export function inferTypeFromValue(node: Expression): TypeDescriptor {
     }
 
     case 'UnaryExpression': {
-      // Handle negative numbers: -1
-      if (
-        (node as any).operator === '-' &&
-        (node as any).argument.type === 'Literal'
-      ) {
-        const value = (node as any).argument.value
+      const op = (node as any).operator
+      const arg = (node as any).argument
+
+      // +N means non-negative integer (e.g., +1, +3)
+      if (op === '+' && arg.type === 'Literal') {
+        const value = arg.value
         if (typeof value === 'number') {
-          return { kind: 'number' }
+          return { kind: 'non-negative-integer' }
+        }
+      }
+
+      // -N means integer or float depending on source
+      if (op === '-' && arg.type === 'Literal') {
+        const value = arg.value
+        if (typeof value === 'number') {
+          const raw = arg.raw as string | undefined
+          if (raw && raw.includes('.')) {
+            return { kind: 'number' }
+          }
+          return { kind: 'integer' }
         }
       }
       return { kind: 'any' }
@@ -258,6 +276,10 @@ export function extractLiteralValue(node: Expression): any {
         const arg = extractLiteralValue((node as any).argument)
         return typeof arg === 'number' ? -arg : undefined
       }
+      if ((node as any).operator === '+') {
+        const arg = extractLiteralValue((node as any).argument)
+        return typeof arg === 'number' ? +arg : undefined
+      }
       return undefined
 
     case 'LogicalExpression': {
@@ -310,6 +332,12 @@ export function typeToString(type: TypeDescriptor): string {
       return type.nullable ? 'string | null' : 'string'
     case 'number':
       return type.nullable ? 'number | null' : 'number'
+    case 'integer':
+      return type.nullable ? 'integer | null' : 'integer'
+    case 'non-negative-integer':
+      return type.nullable
+        ? 'non-negative integer | null'
+        : 'non-negative integer'
     case 'boolean':
       return type.nullable ? 'boolean | null' : 'boolean'
     case 'null':
@@ -354,6 +382,10 @@ export function checkType(value: any, type: TypeDescriptor): boolean {
       return typeof value === 'string'
     case 'number':
       return typeof value === 'number'
+    case 'integer':
+      return typeof value === 'number' && Number.isInteger(value)
+    case 'non-negative-integer':
+      return typeof value === 'number' && Number.isInteger(value) && value >= 0
     case 'boolean':
       return typeof value === 'boolean'
     case 'array':

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', () => {

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'