Fix parser edge cases and release 0.1.1

Author: Atomics-hub

package-lock.json

@@ -7,6 +7,7 @@
   ],
   "scripts": {
     "build": "npm run build --workspaces",
+    "pretest": "npm run build",
     "test": "node --test test/**/*.test.js",
     "bench": "node test/bench/streaming-benchmark.js",
     "demo": "npx serve ."

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a5omic/streamjson",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "O(1) streaming JSON parser for the AI era. Zero dependencies. ~4KB gzipped.",
   "type": "module",
   "main": "dist/index.js",

packages/core/package.json

@@ -49,7 +49,7 @@ export class StreamJSON {
           this.parseEscape(c, chunk[i])
           break
         case State.IN_STRING_UNICODE:
-          this.parseUnicode(chunk[i])
+          this.parseUnicode(c, chunk[i])
           break
         case State.IN_NUMBER:
           this.parseNumber(c, chunk[i])
@@ -162,10 +162,13 @@ export class StreamJSON {
     }
   }
 
-  private parseUnicode(ch: string): void {
+  private parseUnicode(c: number, ch: string): void {
     if (!HEX.test(ch)) {
       this.emitError(`Invalid hex digit in unicode escape: ${ch}`)
+      this.uniAccum = ''
+      this.uniCount = 0
       this.state = State.IN_STRING
+      this.parseString(c, ch)
       return
     }
     this.uniAccum += ch
@@ -193,13 +196,6 @@ export class StreamJSON {
 
   private parseNumber(c: number, ch: string): void {
     if (c >= 0x30 && c <= 0x39) {
-      if ((this.numBuf === '0' || this.numBuf === '-0') && c >= 0x30 && c <= 0x39) {
-        // leading zero followed by another digit — emit error, end the 0, reprocess
-        this.emitError(`Leading zero in number: ${this.numBuf}${ch}`)
-        this.endNumber()
-        this.reprocessAfterNumber(c, ch)
-        return
-      }
       this.numBuf += ch
     } else if (c === 0x2E || c === 0x65 || c === 0x45) {
       this.numBuf += ch
@@ -317,11 +313,15 @@ export class StreamJSON {
       if (this.stack.length > 0 && this.stack[this.stack.length - 1].type === 0) {
         this.endContainer()
         this.afterValue()
+      } else {
+        this.emitError('Unexpected }')
       }
     } else if (c === 0x5D) { // ]
       if (this.stack.length > 0 && this.stack[this.stack.length - 1].type === 1) {
         this.endContainer()
         this.afterValue()
+      } else {
+        this.emitError('Unexpected ]')
       }
     } else if (c === 0x20 || c === 0x09 || c === 0x0A || c === 0x0D) {
       // whitespace
@@ -349,6 +349,8 @@ export class StreamJSON {
           this.parseExpectValue(c, ch)
         }
       }
+    } else {
+      this.emitError(`Unexpected character: ${ch}`)
     }
   }
 
@@ -392,27 +394,30 @@ export class StreamJSON {
   private endNumber(): void {
     const buf = this.numBuf
     this.numBuf = ''
-    const val = Number(buf)
-    if (Number.isNaN(val) || !Number.isFinite(val)) {
-      this.emitError(`Invalid number: ${buf}`)
-      // assign null to preserve position — prevents key drops (objects), index shifts (arrays), and undefined root
-      if (this.stack.length > 0) {
-        const top = this.stack[this.stack.length - 1]
-        if ((top.type === 0 && top.key !== null) || top.type === 1) {
-          this.assignValue(null)
-        }
-      } else {
-        this.assignValue(null)
-      }
+    const analysis = this.analyzeNumber(buf)
+    if (analysis.kind === 'leading_zero') {
+      this.emitError(`Leading zero in number: ${buf}`)
+      this.assignInvalidNumber()
       this.afterValue()
       return
     }
-    if (buf.length > 1 && buf[0] === '0' && buf[1] >= '0' && buf[1] <= '9') {
-      this.emitError(`Leading zero in number: ${buf}`)
+    if (analysis.kind === 'invalid') {
+      this.emitError(`Invalid number: ${buf}`)
+      this.assignInvalidNumber()
+      this.afterValue()
+      return
     }
-    if (buf.endsWith('.')) {
+    const valueText = analysis.kind === 'trailing_dot' ? buf.slice(0, -1) : buf
+    if (analysis.kind === 'trailing_dot') {
       this.emitError(`Trailing dot in number: ${buf}`)
     }
+    const val = Number(valueText)
+    if (Number.isNaN(val) || !Number.isFinite(val)) {
+      this.emitError(`Invalid number: ${buf}`)
+      this.assignInvalidNumber()
+      this.afterValue()
+      return
+    }
     this.assignValue(val)
     this.emit('value', this.currentPath(), val, true)
     this.afterValue()
@@ -477,6 +482,55 @@ export class StreamJSON {
     }
   }
 
+  private analyzeNumber(buf: string): { kind: 'valid' | 'trailing_dot' | 'leading_zero' | 'invalid' } {
+    let i = 0
+    const len = buf.length
+
+    if (len === 0) return { kind: 'invalid' }
+
+    if (buf[i] === '-') i++
+    if (i === len) return { kind: 'invalid' }
+
+    if (buf[i] === '0') {
+      i++
+      if (i < len && buf[i] >= '0' && buf[i] <= '9') return { kind: 'leading_zero' }
+    } else if (buf[i] >= '1' && buf[i] <= '9') {
+      i++
+      while (i < len && buf[i] >= '0' && buf[i] <= '9') i++
+    } else {
+      return { kind: 'invalid' }
+    }
+
+    if (i < len && buf[i] === '.') {
+      i++
+      if (i === len) return { kind: 'trailing_dot' }
+      if (buf[i] < '0' || buf[i] > '9') return { kind: 'invalid' }
+      while (i < len && buf[i] >= '0' && buf[i] <= '9') i++
+    }
+
+    if (i < len && (buf[i] === 'e' || buf[i] === 'E')) {
+      i++
+      if (i < len && (buf[i] === '+' || buf[i] === '-')) i++
+      if (i === len) return { kind: 'invalid' }
+      if (buf[i] < '0' || buf[i] > '9') return { kind: 'invalid' }
+      while (i < len && buf[i] >= '0' && buf[i] <= '9') i++
+    }
+
+    return i === len ? { kind: 'valid' } : { kind: 'invalid' }
+  }
+
+  private assignInvalidNumber(): void {
+    // Preserve object keys and array indexes when a malformed number cannot be recovered.
+    if (this.stack.length > 0) {
+      const top = this.stack[this.stack.length - 1]
+      if ((top.type === 0 && top.key !== null) || top.type === 1) {
+        this.assignValue(null)
+      }
+    } else {
+      this.assignValue(null)
+    }
+  }
+
   private flush(): void {
     if (this.state === State.IN_STRING || this.state === State.IN_STRING_ESCAPE || this.state === State.IN_STRING_UNICODE) {
       this.flushHighSurrogate()

packages/core/src/stream-json.ts

@@ -1,6 +1,6 @@
 {
   "name": "@a5omic/streamjson-react",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "React hooks for StreamJSON — O(1) streaming JSON parser for LLMs",
   "type": "module",
   "main": "dist/index.js",
@@ -43,7 +43,7 @@
   },
   "peerDependencies": {
     "react": ">=18.0.0",
-    "@a5omic/streamjson": ">=0.1.0"
+    "@a5omic/streamjson": ">=0.1.1"
   },
   "devDependencies": {
     "@types/react": "^19.0.0",

packages/react/package.json

@@ -13,16 +13,20 @@ export function StreamJSON<T = unknown>({
   children,
   ...options
 }: StreamJSONProps<T>) {
+  const emitPartial = options.emitPartial ?? false
   const parserRef = useRef<StreamJSONParser | null>(null)
   const prevContentRef = useRef('')
   const contentRef = useRef(content)
+  const completeRef = useRef(complete)
+  const emitPartialRef = useRef(emitPartial)
   const [gen, setGen] = useState(0)
   const [isComplete, setIsComplete] = useState(false)
 
   contentRef.current = content
+  completeRef.current = complete
 
   if (!parserRef.current) {
-    parserRef.current = new StreamJSONParser(options)
+    parserRef.current = new StreamJSONParser({ emitPartial })
   }
 
   useEffect(() => {
@@ -31,6 +35,23 @@ export function StreamJSON<T = unknown>({
     }
   }, [])
 
+  useEffect(() => {
+    if (emitPartialRef.current === emitPartial) return
+
+    parserRef.current?.reset()
+
+    const parser = new StreamJSONParser({ emitPartial })
+    const cur = contentRef.current
+    if (cur.length > 0) parser.push(cur)
+    if (completeRef.current) parser.end()
+
+    parserRef.current = parser
+    prevContentRef.current = cur
+    emitPartialRef.current = emitPartial
+    setIsComplete(completeRef.current)
+    setGen(g => g + 1)
+  }, [emitPartial])
+
   useEffect(() => {
     const parser = parserRef.current
     if (!parser) return

packages/react/src/StreamJSON.tsx

@@ -4,12 +4,14 @@ import { StreamJSON, type StreamJSONOptions } from '@a5omic/streamjson'
 export interface UseStreamJSONOptions extends StreamJSONOptions {}
 
 export function useStreamJSON<T = unknown>(options: UseStreamJSONOptions = {}) {
+  const emitPartial = options.emitPartial ?? false
   const parserRef = useRef<StreamJSON | null>(null)
+  const emitPartialRef = useRef(emitPartial)
   const [gen, setGen] = useState(0)
   const [isComplete, setIsComplete] = useState(false)
 
   if (!parserRef.current) {
-    parserRef.current = new StreamJSON(options)
+    parserRef.current = new StreamJSON({ emitPartial })
   }
 
   useEffect(() => {
@@ -18,6 +20,15 @@ export function useStreamJSON<T = unknown>(options: UseStreamJSONOptions = {}) {
     }
   }, [])
 
+  useEffect(() => {
+    if (emitPartialRef.current === emitPartial) return
+    parserRef.current?.reset()
+    parserRef.current = new StreamJSON({ emitPartial })
+    emitPartialRef.current = emitPartial
+    setIsComplete(false)
+    setGen(g => g + 1)
+  }, [emitPartial])
+
   const push = useCallback((chunk: string) => {
     parserRef.current?.push(chunk)
     setGen(g => g + 1)

packages/react/src/useStreamJSON.ts

@@ -308,6 +308,16 @@ describe('edge cases', () => {
       p.end()
       assert.ok(errors.length > 0)
     })
+
+    it('truncated unicode escape reprocesses the closing quote', () => {
+      const errors = []
+      const p = new StreamJSON()
+      p.on('error', (err) => errors.push(err.message))
+      p.push('{"a":"\\u00"}')
+      p.end()
+      assert.ok(errors.some(e => e.includes('Invalid hex digit')))
+      assert.deepEqual(p.get(), obj({ a: '' }))
+    })
   })
 
   describe('number validation', () => {
@@ -372,6 +382,7 @@ describe('edge cases', () => {
       p.push('[01]')
       p.end()
       assert.ok(errors.some(e => e.includes('Leading zero')))
+      assert.deepEqual(p.get(), [null])
     })
 
     it('trailing dot emits error', () => {
@@ -398,6 +409,37 @@ describe('edge cases', () => {
       p.push('00')
       p.end()
       assert.ok(errors.some(e => e.includes('Leading zero')))
+      assert.equal(p.get(), null)
+    })
+
+    it('leading zero in object preserves the key with null', () => {
+      const errors = []
+      const p = new StreamJSON()
+      p.on('error', (err) => errors.push(err.message))
+      p.push('{"x":01}')
+      p.end()
+      assert.ok(errors.some(e => e.includes('Leading zero')))
+      assert.deepEqual(p.get(), obj({ x: null }))
+    })
+
+    it('invalid exponent after decimal assigns null', () => {
+      const errors = []
+      const p = new StreamJSON()
+      p.on('error', (err) => errors.push(err.message))
+      p.push('1.e2')
+      p.end()
+      assert.ok(errors.some(e => e.includes('Invalid number')))
+      assert.equal(p.get(), null)
+    })
+
+    it('missing integer before decimal assigns null', () => {
+      const errors = []
+      const p = new StreamJSON()
+      p.on('error', (err) => errors.push(err.message))
+      p.push('-.1')
+      p.end()
+      assert.ok(errors.some(e => e.includes('Invalid number')))
+      assert.equal(p.get(), null)
     })
   })
 
@@ -419,6 +461,26 @@ describe('edge cases', () => {
       p.end()
       assert.ok(errors.some(e => e.includes('Unexpected ]')))
     })
+
+    it('mismatched ] after an object value emits error', () => {
+      const errors = []
+      const p = new StreamJSON()
+      p.on('error', (err) => errors.push(err.message))
+      p.push('{"a":1]')
+      p.end()
+      assert.ok(errors.some(e => e.includes('Unexpected ]')))
+      assert.deepEqual(p.get(), obj({ a: 1 }))
+    })
+
+    it('mismatched } after an array value emits error', () => {
+      const errors = []
+      const p = new StreamJSON()
+      p.on('error', (err) => errors.push(err.message))
+      p.push('[1,2}')
+      p.end()
+      assert.ok(errors.some(e => e.includes('Unexpected }')))
+      assert.deepEqual(p.get(), [1, 2])
+    })
   })
 
   describe('truncated key recovery', () => {