goscript 0.1.4 → 0.2.1

package/gs/github.com/aperturerobotics/protobuf-go-lite/json/index.test.ts

@@ -113,6 +113,24 @@ describe('protobuf-go-lite/json override', () => {
     ])
   })
 
+  it('matches jsoniter value types while reading object fields', () => {
+    const state = NewUnmarshalState(
+      jsonBytes('{"id":"step","config":{"kind":"inline"}}'),
+      DefaultUnmarshalerConfig,
+    )
+
+    expect(state?.ReadObjectField()).toBe('id')
+    expect(state?.WhatIsNext()).toBe(1)
+    expect(state?.ReadString()).toBe('step')
+    expect(state?.ReadObjectField()).toBe('config')
+    expect(state?.WhatIsNext()).toBe(6)
+    expect(
+      new TextDecoder().decode(new Uint8Array(state?.SkipAndReturnBytes())),
+    ).toBe('{"kind":"inline"}')
+    expect(state?.ReadObjectField()).toBe('')
+    expect(state?.Err()).toBeNull()
+  })
+
   it('tracks unmarshaled field masks through nested fields', () => {
     const state = NewUnmarshalState(jsonBytes('{}'), DefaultUnmarshalerConfig)
     state?.AddField('top')

package/gs/github.com/aperturerobotics/protobuf-go-lite/json/index.ts

@@ -423,6 +423,7 @@ export class UnmarshalState {
   private path: string[]
   private objectEntries: Array<[string, unknown]> | null = null
   private objectIndex = 0
+  private objectValue: unknown = undefined
 
   constructor(
     init?: Partial<{
@@ -612,16 +613,21 @@ export class UnmarshalState {
   }
 
   public ReadObjectField(): string {
-    const record = recordValue(this.value)
-    if (record == null) {
-      this.SetErrorf('expected JSON object')
-      return ''
-    }
     if (this.objectEntries == null) {
+      const record = recordValue(this.value)
+      if (record == null) {
+        this.SetErrorf('expected JSON object')
+        return ''
+      }
       this.objectEntries = Object.entries(record)
       this.objectIndex = 0
+      this.objectValue = this.value
     }
     if (this.objectIndex >= this.objectEntries.length) {
+      this.value = this.objectValue
+      this.objectEntries = null
+      this.objectIndex = 0
+      this.objectValue = undefined
       return ''
     }
     const [key, value] = this.objectEntries[this.objectIndex]
@@ -747,22 +753,22 @@ export class UnmarshalState {
 
   public WhatIsNext(): number {
     if (this.value === null) {
-      return 0
+      return 3
     }
     if (Array.isArray(this.value)) {
-      return 1
+      return 5
     }
     if (typeof this.value === 'object') {
-      return 2
+      return 6
     }
     if (typeof this.value === 'string') {
-      return 3
+      return 1
     }
     if (typeof this.value === 'number') {
-      return 4
+      return 2
     }
     if (typeof this.value === 'boolean') {
-      return 5
+      return 4
     }
     return 0
   }

package/gs/github.com/pkg/errors/errors.ts

@@ -109,10 +109,18 @@ class fundamental {
       },
     ],
     fundamental,
-    {
-      msg: { kind: $.TypeKind.Basic, name: 'string' },
-      stack: { kind: $.TypeKind.Pointer, elemType: 'stack' },
-    },
+    [
+      {
+        name: 'msg',
+        key: 'msg',
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+      },
+      {
+        name: 'stack',
+        key: 'stack',
+        type: { kind: $.TypeKind.Pointer, elemType: 'stack' },
+      },
+    ],
   )
 }
 
@@ -231,20 +239,28 @@ class withStack {
       },
     ],
     withStack,
-    {
-      error: {
-        kind: $.TypeKind.Interface,
-        name: 'GoError',
-        methods: [
-          {
-            name: 'Error',
-            args: [],
-            returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
-          },
-        ],
+    [
+      {
+        name: 'error',
+        key: 'error',
+        type: {
+          kind: $.TypeKind.Interface,
+          name: 'GoError',
+          methods: [
+            {
+              name: 'Error',
+              args: [],
+              returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+            },
+          ],
+        },
       },
-      stack: { kind: $.TypeKind.Pointer, elemType: 'stack' },
-    },
+      {
+        name: 'stack',
+        key: 'stack',
+        type: { kind: $.TypeKind.Pointer, elemType: 'stack' },
+      },
+    ],
   )
 }
 
@@ -405,20 +421,28 @@ class withMessage {
       },
     ],
     withMessage,
-    {
-      cause: {
-        kind: $.TypeKind.Interface,
-        name: 'GoError',
-        methods: [
-          {
-            name: 'Error',
-            args: [],
-            returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
-          },
-        ],
+    [
+      {
+        name: 'cause',
+        key: 'cause',
+        type: {
+          kind: $.TypeKind.Interface,
+          name: 'GoError',
+          methods: [
+            {
+              name: 'Error',
+              args: [],
+              returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+            },
+          ],
+        },
       },
-      msg: { kind: $.TypeKind.Basic, name: 'string' },
-    },
+      {
+        name: 'msg',
+        key: 'msg',
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+      },
+    ],
   )
 }
 

package/gs/go/scanner/index.test.ts

@@ -3,70 +3,53 @@ import { describe, expect, it } from 'vitest'
 import * as $ from '@goscript/builtin/index.js'
 import * as token from '@goscript/go/token/index.js'
 
-import {
-  ErrorList_Add,
-  ErrorList_Err,
-  ErrorList_Error,
-  ErrorList_Len,
-  ErrorList_RemoveMultiples,
-  Scanner,
-  type ErrorList,
-} from './index.js'
+import { Error as ScannerError, ErrorList_Err, PrintError } from './index.js'
 
 describe('go/scanner override', () => {
-  it('adds and formats scanner errors', () => {
-    const list: $.VarRef<ErrorList> = $.varRef(null)
-
-    ErrorList_Add(
-      list,
-      $.markAsStructValue(
-        new token.Position({
-          Filename: 'test.go',
-          Line: 1,
-          Column: 1,
-        }),
-      ),
-      'test error',
-    )
-
-    expect(ErrorList_Len(list.value)).toBe(1)
-    expect(ErrorList_Error(list.value)).toBe('test.go:1:1: test error')
+  it('prints errors to an io.Writer', () => {
+    const chunks: string[] = []
+    const writer = {
+      Write(p: $.Bytes): [number, $.GoError] {
+        chunks.push($.bytesToString(p))
+        return [$.len(p), null]
+      },
+    }
+
+    PrintError(writer, $.newError('scan failed'))
+
+    expect(chunks).toEqual(['scan failed\n'])
   })
 
-  it('removes repeated line errors', () => {
-    const list: $.VarRef<ErrorList> = $.varRef(null)
-    const pos = $.markAsStructValue(
-      new token.Position({
-        Filename: 'test.go',
-        Line: 1,
-        Column: 1,
+  it('prints every ErrorList entry', () => {
+    const chunks: string[] = []
+    const writer = {
+      Write(p: $.Bytes): [number, $.GoError] {
+        chunks.push($.bytesToString(p))
+        return [$.len(p), null]
+      },
+    }
+
+    const errors = [
+      new ScannerError({
+        Pos: new token.Position({ Filename: 'a.go', Line: 1, Column: 2 }),
+        Msg: 'first',
       }),
-    )
-
-    ErrorList_Add(list, pos, 'first')
-    ErrorList_Add(list, pos, 'second')
-    ErrorList_RemoveMultiples(list)
-
-    expect(ErrorList_Len(list.value)).toBe(1)
-  })
-
-  it('returns nil Err for an empty list and an error for non-empty lists', () => {
-    const empty: ErrorList = null
-    expect(ErrorList_Err(empty)).toBeNull()
+      new ScannerError({
+        Pos: new token.Position({ Filename: 'a.go', Line: 3, Column: 4 }),
+        Msg: 'second',
+      }),
+    ]
 
-    const list: $.VarRef<ErrorList> = $.varRef(null)
-    ErrorList_Add(list, new token.Position({ Line: 1 }), 'first')
-    expect(ErrorList_Err(list.value)?.Error()).toBe('1: first')
-  })
+    PrintError(writer, errors as $.GoError)
 
-  it('provides a Scanner surface for generated go/parser code', () => {
-    const fset = token.NewFileSet()
-    const file = fset.AddFile('test.go', -1, 0)
-    const scanner = new Scanner()
+    expect(chunks).toEqual(['a.go:1:2: first\n', 'a.go:3:4: second\n'])
 
-    scanner.Init(file, null, null, 0)
+    chunks.length = 0
+    const err = ErrorList_Err(errors)
+    expect(Array.isArray(err)).toBe(true)
+    expect(err?.Error()).toBe('a.go:1:2: first (and 1 more errors)')
+    PrintError(writer, err)
 
-    expect(scanner.Scan()).toEqual([file.Pos(0), token.EOF, ''])
-    expect(scanner.Scan()).toEqual([file.Pos(0), token.EOF, ''])
+    expect(chunks).toEqual(['a.go:1:2: first\n', 'a.go:3:4: second\n'])
   })
 })

package/gs/go/scanner/index.ts

@@ -1,5 +1,6 @@
 import * as $ from '@goscript/builtin/index.js'
 import * as token from '@goscript/go/token/index.js'
+import type * as io from '@goscript/io/index.js'
 
 export class Error {
   public get Pos(): token.Position {
@@ -54,10 +55,14 @@ export class Error {
       },
     ],
     Error,
-    {
-      Pos: { type: 'go/token.Position' },
-      Msg: { kind: $.TypeKind.Basic, name: 'string' },
-    },
+    [
+      { name: 'Pos', key: 'Pos', type: 'go/token.Position' },
+      {
+        name: 'Msg',
+        key: 'Msg',
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+      },
+    ],
   )
 }
 
@@ -196,9 +201,32 @@ export function ErrorList_Error(list: ErrorList): string {
   return `${errors[0]!.Error()} (and ${errors.length - 1} more errors)`
 }
 
+type errorListWithError = ErrorList & { Error?: () => string }
+
 export function ErrorList_Err(list: ErrorList): $.GoError {
   if ($.len(list) === 0) {
     return null
   }
-  return $.newError(ErrorList_Error(list))
+  const err = list as errorListWithError
+  err.Error = () => ErrorList_Error(list)
+  return err as unknown as $.GoError
+}
+
+export function PrintError(w: io.Writer, err: $.GoError): void {
+  if (err === null) {
+    return
+  }
+  if (Array.isArray(err)) {
+    for (const entry of Array.from((err as ErrorList) ?? [])) {
+      if (entry == null) {
+        continue
+      }
+      w.Write($.stringToBytes(`${entry.Error()}\n`))
+    }
+    return
+  }
+  const text = err.Error()
+  for (const line of text.split('\n')) {
+    w.Write($.stringToBytes(line + '\n'))
+  }
 }

package/gs/go/scanner/parity.json

@@ -0,0 +1,27 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "Error": {
+      "status": "real"
+    },
+    "ErrorHandler": {
+      "status": "real"
+    },
+    "ErrorList": {
+      "status": "real"
+    },
+    "Mode": {
+      "status": "real"
+    },
+    "PrintError": {
+      "status": "real"
+    },
+    "ScanComments": {
+      "status": "real"
+    },
+    "Scanner": {
+      "status": "real"
+    }
+  }
+}

package/gs/go/token/index.ts

@@ -285,12 +285,28 @@ export class Position {
       },
     ],
     Position,
-    {
-      Filename: { kind: $.TypeKind.Basic, name: 'string' },
-      Offset: { kind: $.TypeKind.Basic, name: 'int' },
-      Line: { kind: $.TypeKind.Basic, name: 'int' },
-      Column: { kind: $.TypeKind.Basic, name: 'int' },
-    },
+    [
+      {
+        name: 'Filename',
+        key: 'Filename',
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+      },
+      {
+        name: 'Offset',
+        key: 'Offset',
+        type: { kind: $.TypeKind.Basic, name: 'int' },
+      },
+      {
+        name: 'Line',
+        key: 'Line',
+        type: { kind: $.TypeKind.Basic, name: 'int' },
+      },
+      {
+        name: 'Column',
+        key: 'Column',
+        type: { kind: $.TypeKind.Basic, name: 'int' },
+      },
+    ],
   )
 }
 

package/gs/hash/index.test.ts

@@ -1,37 +1,24 @@
 import { describe, expect, it } from 'vitest'
 
-import * as $ from '../builtin/index.js'
-
-import './index.js'
-
-class FakeHash {
-  Write(p: $.Bytes): [number, $.GoError] {
-    return [$.len(p), null]
-  }
-
-  Sum(b: $.Bytes): $.Bytes {
-    return b
-  }
-
-  Reset(): void {}
-
-  Size(): number {
-    return 20
-  }
-
-  BlockSize(): number {
-    return 64
-  }
-}
-
-describe('hash runtime contracts', () => {
-  it('registers Hash for runtime type assertions', () => {
-    const [value, ok] = $.typeAssertTuple<FakeHash>(
-      new FakeHash(),
-      'hash.Hash',
-    )
-
-    expect(ok).toBe(true)
-    expect(value).toBeInstanceOf(FakeHash)
+import * as $ from '@goscript/builtin/index.js'
+
+import type { XOF } from './index.js'
+
+describe('hash override', () => {
+  it('exports the XOF interface shape', () => {
+    const xof: XOF = {
+      Write(p: $.Bytes): [number, $.GoError] {
+        return [$.len(p), null]
+      },
+      Read(p: $.Bytes): [number, $.GoError] {
+        return [$.len(p), null]
+      },
+      Reset(): void {},
+      BlockSize(): number {
+        return 1
+      },
+    }
+
+    expect(xof.BlockSize()).toBe(1)
   })
 })

package/gs/hash/index.ts

@@ -16,6 +16,13 @@ export interface Hash64 extends Hash {
   Sum64(): bigint
 }
 
+export interface XOF {
+  Write(p: $.Bytes): [number, $.GoError]
+  Read(p: $.Bytes): [number, $.GoError]
+  Reset(): void
+  BlockSize(): number
+}
+
 export interface Cloner {
   Clone(): [Hash, $.GoError]
 }
@@ -116,3 +123,24 @@ $.registerInterfaceType('hash.Cloner', null, [
     ],
   },
 ])
+
+$.registerInterfaceType('hash.XOF', null, [
+  {
+    name: 'Write',
+    args: [{ name: 'p', type: bytesType }],
+    returns: [
+      { name: 'n', type: intType },
+      { name: 'err', type: errorType },
+    ],
+  },
+  {
+    name: 'Read',
+    args: [{ name: 'p', type: bytesType }],
+    returns: [
+      { name: 'n', type: intType },
+      { name: 'err', type: errorType },
+    ],
+  },
+  { name: 'Reset', args: [], returns: [] },
+  { name: 'BlockSize', args: [], returns: [{ name: '_r0', type: intType }] },
+])

package/gs/hash/parity.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "Cloner": {
+      "status": "real"
+    },
+    "Hash": {
+      "status": "real"
+    },
+    "Hash32": {
+      "status": "real"
+    },
+    "Hash64": {
+      "status": "real"
+    },
+    "XOF": {
+      "status": "real"
+    }
+  }
+}

package/gs/internal/byteorder/index.test.ts

@@ -16,7 +16,7 @@ describe('internal/byteorder uint64', () => {
     BEPutUint64(bytes, 0x0102030405060708n)
 
     expect(Array.from(bytes)).toEqual([1, 2, 3, 4, 5, 6, 7, 8])
-    expect(BEUint64(bytes)).toBe(Number(0x0102030405060708n))
+    expect(BEUint64(bytes)).toBe(0x0102030405060708n)
   })
 
   test('reads and writes little-endian bigint values', () => {
@@ -25,7 +25,7 @@ describe('internal/byteorder uint64', () => {
     LEPutUint64(bytes, 0x0102030405060708n)
 
     expect(Array.from(bytes)).toEqual([8, 7, 6, 5, 4, 3, 2, 1])
-    expect(LEUint64(bytes)).toBe(Number(0x0102030405060708n))
+    expect(LEUint64(bytes)).toBe(0x0102030405060708n)
   })
 
   test('appends uint64 values', () => {

package/gs/internal/byteorder/index.ts

@@ -13,7 +13,7 @@ export function BEUint32(b: $.Bytes): number {
 }
 
 export function BEUint64(b: $.Bytes): number {
-  return Number(
+  return $.uint(
     (BigInt(b![0]) << 56n) |
       (BigInt(b![1]) << 48n) |
       (BigInt(b![2]) << 40n) |
@@ -34,7 +34,7 @@ export function LEUint32(b: $.Bytes): number {
 }
 
 export function LEUint64(b: $.Bytes): number {
-  return Number(
+  return $.uint(
     BigInt(b![0]) |
       (BigInt(b![1]) << 8n) |
       (BigInt(b![2]) << 16n) |

package/gs/internal/goarch/index.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  ArchFamily,
+  BigEndian,
+  DefaultPhysPageSize,
+  GOARCH,
+  Int64Align,
+  IsAmd64,
+  IsWasm,
+  PCQuantum,
+  PtrBits,
+  PtrSize,
+  StackAlign,
+  WASM,
+} from './index.js'
+
+describe('internal/goarch override', () => {
+  it('matches JS/WASM Go architecture constants', () => {
+    expect(GOARCH).toBe('wasm')
+    expect(IsWasm).toBe(1)
+    expect(IsAmd64).toBe(0)
+    expect(PtrSize).toBe(8)
+    expect(PtrBits).toBe(64)
+    expect(Int64Align).toBe(PtrSize)
+    expect(StackAlign).toBe(PtrSize)
+    expect(BigEndian).toBe(false)
+    expect(DefaultPhysPageSize).toBe(65536)
+    expect(PCQuantum).toBe(1)
+    expect(ArchFamily).toBe(WASM)
+  })
+})

package/gs/internal/goarch/index.ts

@@ -1,18 +1,50 @@
-// Architecture constants for JavaScript/WebAssembly target
-// This replaces the auto-generated version with appropriate values for JS
+export type ArchFamilyType = number
 
-// Pointer size in bytes (64-bit in modern JavaScript environments)
-export const PtrSize = 8
+export const AMD64: ArchFamilyType = 0
+export const ARM: ArchFamilyType = 1
+export const ARM64: ArchFamilyType = 2
+export const I386: ArchFamilyType = 3
+export const LOONG64: ArchFamilyType = 4
+export const MIPS: ArchFamilyType = 5
+export const MIPS64: ArchFamilyType = 6
+export const PPC64: ArchFamilyType = 7
+export const RISCV64: ArchFamilyType = 8
+export const S390X: ArchFamilyType = 9
+export const WASM: ArchFamilyType = 10
 
-// JavaScript is little-endian
-export const BigEndian = false
+export const GOARCH = 'wasm'
 
-// Architecture family
-export const ArchFamily = 'wasm'
+export const Is386 = 0
+export const IsAmd64 = 0
+export const IsAmd64p32 = 0
+export const IsArm = 0
+export const IsArmbe = 0
+export const IsArm64 = 0
+export const IsArm64be = 0
+export const IsLoong64 = 0
+export const IsMips = 0
+export const IsMipsle = 0
+export const IsMips64 = 0
+export const IsMips64le = 0
+export const IsMips64p32 = 0
+export const IsMips64p32le = 0
+export const IsPpc = 0
+export const IsPpc64 = 0
+export const IsPpc64le = 0
+export const IsRiscv = 0
+export const IsRiscv64 = 0
+export const IsS390 = 0
+export const IsS390x = 0
+export const IsSparc = 0
+export const IsSparc64 = 0
+export const IsWasm = 1
 
-// Other common architecture constants
-export const Int64Align = 8
+export const PtrSize = 8
+export const PtrBits = PtrSize * 8
+export const Int64Align = PtrSize
+export const BigEndian = false
+export const ArchFamily: ArchFamilyType = WASM
+export const DefaultPhysPageSize = 65536
+export const PCQuantum = 1
 export const MinFrameSize = 0
-
-// CPU cache line size (not really applicable in JS, but some code might reference it)
-export const CacheLineSize = 64
+export const StackAlign = PtrSize