goscript 0.2.0 → 0.2.1

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

@@ -345,6 +345,7 @@ export function EqualVTMapImplicit<K, V extends EqualVT<V>>(
 }
 
 type BoundMessageType = {
+  typeName?: string
   fields?: { list(): readonly BoundFieldInfo[] }
   clone?: (value: any) => any
   equals?: (a: any, b: any) => boolean
@@ -371,6 +372,8 @@ type BoundMessageCtor<T = any> = {
   __protobufTypeScriptMessage?: BoundMessageType
 }
 
+const protobufScalarTypeBytes = 12
+
 function boundMessageType(ctor: BoundMessageCtor): BoundMessageType {
   const messageType = ctor.__protobufTypeScriptMessage
   if (messageType == null) {
@@ -401,8 +404,16 @@ function boundFieldValue(source: any, field: BoundFieldInfo): any {
   return source[boundFieldGoName(field)]
 }
 
-function toTypeScriptScalarValue(value: any): any {
+function toTypeScriptScalarValue(value: any, field?: BoundFieldInfo): any {
   const unwrapped = $.pointerValueOrNil(value)
+  if (
+    field?.kind === 'scalar' &&
+    field.T === protobufScalarTypeBytes &&
+    unwrapped != null &&
+    !(unwrapped instanceof Uint8Array)
+  ) {
+    return Uint8Array.from($.asArray(unwrapped))
+  }
   if (unwrapped instanceof Uint8Array) {
     return unwrapped
   }
@@ -440,7 +451,7 @@ function toTypeScriptFieldValue(
     const messageType = resolveBoundMessageType(field.T)
     return toTypeScriptMessage(value, messageType, ctor)
   }
-  return toTypeScriptScalarValue(value)
+  return toTypeScriptScalarValue(value, field)
 }
 
 function toTypeScriptMessage(
@@ -520,6 +531,23 @@ function fromTypeScriptFieldValue(
   return fromTypeScriptScalarValue(value)
 }
 
+function fromTypeScriptWellKnownMessage(
+  value: any,
+  ctor: BoundMessageCtor,
+  messageType?: BoundMessageType,
+): any {
+  if (
+    messageType?.typeName === 'google.protobuf.Timestamp' &&
+    value instanceof Date
+  ) {
+    const ms = value.getTime()
+    const seconds = Math.floor(ms / 1000)
+    const nanos = Math.trunc((ms - seconds * 1000) * 1000000)
+    return new ctor({ Seconds: seconds, Nanos: nanos })
+  }
+  return undefined
+}
+
 function fromTypeScriptMessage(
   value: any,
   ctor: BoundMessageCtor,
@@ -528,6 +556,10 @@ function fromTypeScriptMessage(
   if (value == null) {
     return null
   }
+  const wellKnown = fromTypeScriptWellKnownMessage(value, ctor, messageType)
+  if (wellKnown !== undefined) {
+    return wellKnown
+  }
   const out = new ctor()
   const fields = (messageType ?? boundMessageType(ctor)).fields?.list()
   if (fields == null) {
@@ -579,14 +611,17 @@ export function MarshalBoundMessageVT<T>(
   ctor: BoundMessageCtor<T>,
   value: T | $.VarRef<T> | null,
 ): [$.Slice<number>, $.GoError] {
+  let typeName = ctor.name
   try {
     const messageType = boundMessageType(ctor)
+    typeName = messageType.typeName ?? typeName
     return [
       messageType.toBinary(toTypeScriptMessage(value, messageType, ctor)),
       null,
     ]
   } catch (err) {
-    return [null, $.toGoError(err as Error)]
+    const msg = err instanceof Error ? err.message : String(err)
+    return [null, $.toGoError(new Error(`marshal ${typeName}: ${msg}`))]
   }
 }
 
@@ -599,12 +634,13 @@ export function MarshalBoundMessageToSizedBufferVT<T>(
   if (err != null) {
     return [0, err]
   }
-  const offset = $.len(dAtA) - $.len(bytes)
+  const byteCount = $.len(bytes)
+  const offset = $.len(dAtA) - byteCount
   const src = $.asArray(bytes)
   for (let i = 0; i < src.length; i++) {
     ;(dAtA as any)[offset + i] = src[i]
   }
-  return [offset, null]
+  return [byteCount, null]
 }
 
 export function SizeBoundMessageVT<T>(

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/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/reflect/type.ts

@@ -3326,6 +3326,60 @@ function basicTypeFromName(name: string, typeName = ''): BasicType {
   }
 }
 
+function typeFromGoTypeName(typeName: string): Type | null {
+  const trimmed = typeName.trim()
+  if (trimmed === '') return null
+
+  if (trimmed.startsWith('<-chan ')) {
+    return new ChannelType(typeFromGoTypeName(trimmed.slice(7)) ?? anyType(), RecvDir)
+  }
+  if (trimmed.startsWith('chan<- ')) {
+    return new ChannelType(typeFromGoTypeName(trimmed.slice(7)) ?? anyType(), SendDir)
+  }
+  if (trimmed.startsWith('chan ')) {
+    return new ChannelType(typeFromGoTypeName(trimmed.slice(5)) ?? anyType(), BothDir)
+  }
+  if (trimmed.startsWith('[]')) {
+    return new SliceType(typeFromGoTypeName(trimmed.slice(2)) ?? anyType())
+  }
+  if (trimmed.startsWith('*')) {
+    return new PointerType(typeFromGoTypeName(trimmed.slice(1)) ?? anyType())
+  }
+  if (trimmed === 'struct{}' || trimmed === 'struct {}') {
+    return new StructType('', [], '', 'struct {}')
+  }
+  if (trimmed === 'interface{}' || trimmed === 'any') {
+    return anyType()
+  }
+  if (trimmed === 'error') {
+    return new InterfaceType('error', 'error')
+  }
+
+  const registered = builtinGetTypeByName(trimmed)
+  if (registered) {
+    return typeFromTypeInfo(registered)
+  }
+
+  const basic = basicTypeFromName(trimmed)
+  if (basic.Kind() !== Invalid) {
+    return basic
+  }
+
+  return null
+}
+
+function channelTypeFromGoTypeName(typeName: string): Type | null {
+  const typ = typeFromGoTypeName(typeName)
+  if (typ?.Kind() === Chan) {
+    return typ
+  }
+  return null
+}
+
+function anyType(): Type {
+  return new BasicType(Interface, 'interface{}', 16)
+}
+
 function structFieldsFromTypeInfo(
   ti: $.StructTypeInfo,
   seen = new Set<string>(),
@@ -3743,6 +3797,16 @@ function getTypeOf(value: ReflectValue): Type {
         )
       }
 
+      if ('__goType' in value) {
+        const goType = (value as { __goType?: unknown }).__goType
+        if (typeof goType === 'string') {
+          const channelType = channelTypeFromGoTypeName(goType)
+          if (channelType) {
+            return channelType
+          }
+        }
+      }
+
       if (
         'real' in value &&
         'imag' in value &&

package/gs/reflect/typefor.test.ts

@@ -1,5 +1,7 @@
 import { describe, it, expect } from 'vitest'
 import {
+  interfaceValue,
+  makeChannel,
   makeMap,
   mapGet,
   mapSet,
@@ -11,7 +13,9 @@ import {
   varRef,
 } from '../builtin/index.js'
 import { StructField } from './types.js'
+import { SelectCase, SelectRecv } from './types.js'
 import {
+  Chan,
   Int,
   Ptr,
   Struct,
@@ -21,7 +25,7 @@ import {
   Uint64,
   ValueOf,
 } from './type.js'
-import { Indirect, New, Zero } from './value.js'
+import { Indirect, New, Select, Zero } from './value.js'
 
 describe('TypeFor', () => {
   it('exposes StructField PkgPath and exported semantics', () => {
@@ -184,6 +188,22 @@ describe('TypeFor', () => {
     expect(target.value).toBe(15)
   })
 
+  it('preserves channel type metadata on interface boxes', () => {
+    const ch = makeChannel<{}>(0, {}, 'both')
+    const chanValue = ValueOf(interfaceValue(ch, '<-chan struct{}'))
+
+    expect(chanValue.Type().Kind()).toBe(Chan)
+    expect(chanValue.Type().String()).toBe('<-chan struct {}')
+    expect(chanValue.Type().Elem().Kind()).toBe(Struct)
+
+    const [chosen, recv, ok] = Select([
+      new SelectCase({ Dir: SelectRecv, Chan: chanValue }),
+    ])
+    expect(chosen).toBe(0)
+    expect(ok).toBe(true)
+    expect(recv.Type().String()).toBe('struct {}')
+  })
+
   it('formats literal interface methods from type metadata', () => {
     const ifaceType = TypeFor({
       T: {

package/gs/sync/atomic/doc_64.gs.ts

@@ -59,7 +59,7 @@ export function CompareAndSwapUint64(addr: $.VarRef<number> | null, old: number,
 //go:noescape
 export function AddInt64(addr: $.VarRef<number> | null, delta: number): number {
 	if (!addr) return 0;
-	addr.value = addr.value + delta;
+	addr.value = $.int64Add(addr.value, delta);
 	return addr.value;
 }
 
@@ -72,7 +72,7 @@ export function AddInt64(addr: $.VarRef<number> | null, delta: number): number {
 //go:noescape
 export function AddUint64(addr: $.VarRef<number> | null, delta: number): number {
 	if (!addr) return 0;
-	addr.value = addr.value + delta;
+	addr.value = $.uint64Add(addr.value, delta);
 	return addr.value;
 }
 
@@ -84,7 +84,7 @@ export function AddUint64(addr: $.VarRef<number> | null, delta: number): number
 export function AndInt64(addr: $.VarRef<number> | null, mask: number): number {
 	if (!addr) return 0;
 	let old = addr.value;
-	addr.value = addr.value & mask;
+	addr.value = $.int64And(addr.value, mask);
 	return old;
 }
 
@@ -96,7 +96,7 @@ export function AndInt64(addr: $.VarRef<number> | null, mask: number): number {
 export function AndUint64(addr: $.VarRef<number> | null, mask: number): number {
 	if (!addr) return 0;
 	let old = addr.value;
-	addr.value = addr.value & mask;
+	addr.value = $.uint64And(addr.value, mask);
 	return old;
 }
 
@@ -108,7 +108,7 @@ export function AndUint64(addr: $.VarRef<number> | null, mask: number): number {
 export function OrInt64(addr: $.VarRef<number> | null, mask: number): number {
 	if (!addr) return 0;
 	let old = addr.value;
-	addr.value = addr.value | mask;
+	addr.value = $.int64Or(addr.value, mask);
 	return old;
 }
 
@@ -120,7 +120,7 @@ export function OrInt64(addr: $.VarRef<number> | null, mask: number): number {
 export function OrUint64(addr: $.VarRef<number> | null, mask: number): number {
 	if (!addr) return 0;
 	let old = addr.value;
-	addr.value = addr.value | mask;
+	addr.value = $.uint64Or(addr.value, mask);
 	return old;
 }
 
@@ -165,4 +165,3 @@ export function StoreUint64(addr: $.VarRef<number> | null, val: number): void {
 		addr.value = val;
 	}
 }
-

package/gs/sync/atomic/doc_64.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from 'vitest'
+
+import * as $ from '../../builtin/index.js'
+import {
+  AddInt64,
+  AddUint64,
+  AndUint64,
+  OrUint64,
+} from './doc_64.gs.js'
+
+function asBigInt(value: number): bigint {
+  return typeof value === 'bigint' ? value : BigInt(value)
+}
+
+describe('sync/atomic 64-bit operations', () => {
+  test('adds uint64 values without mixing number and bigint arithmetic', () => {
+    const value = $.varRef($.uint('18446744073709551614', 64))
+
+    expect(AddUint64(value, $.uint(2, 64))).toBe(0)
+    expect(value.value).toBe(0)
+  })
+
+  test('preserves high uint64 bits for bitwise operations', () => {
+    const value = $.varRef($.uint('9223372036854775808', 64))
+
+    expect(asBigInt(OrUint64(value, $.uint(1, 64)))).toBe(
+      9223372036854775808n,
+    )
+    expect(asBigInt(value.value)).toBe(9223372036854775809n)
+
+    expect(asBigInt(AndUint64(value, $.uint('18446744073709551614', 64)))).toBe(
+      9223372036854775809n,
+    )
+    expect(asBigInt(value.value)).toBe(9223372036854775808n)
+  })
+
+  test('adds int64 values without number coercion', () => {
+    const value = $.varRef($.int('9223372036854775807', 64))
+
+    expect(AddInt64(value, 1)).toBe(-9223372036854775808)
+    expect(value.value).toBe(-9223372036854775808)
+  })
+})

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",