goscript 0.0.84 → 0.1.1

package/gs/io/io.ts

@@ -49,6 +49,9 @@ export interface Writer {
   Write(p: $.Bytes): [number, $.GoError]
 }
 
+type ReaderLike = Reader | { Reader: Reader | null } | null
+type WriterLike = Writer | { Writer: Writer | null } | null
+
 // Closer is the interface that wraps the basic Close method
 export interface Closer {
   Close(): $.GoError
@@ -68,6 +71,110 @@ export interface ReadSeeker extends Reader, Seeker {}
 export interface WriteSeeker extends Writer, Seeker {}
 export interface ReadWriteSeeker extends Reader, Writer, Seeker {}
 
+class pipeState {
+  private chunks: Uint8Array[] = []
+  private readOffset = 0
+  private readerClosed = false
+  private writerClosed = false
+  private readerErr: $.GoError = null
+  private writerErr: $.GoError = null
+
+  Read(p: $.Bytes): [number, $.GoError] {
+    if (this.readerClosed) {
+      return [0, this.readerErr ?? ErrClosedPipe]
+    }
+    if ($.len(p) === 0) {
+      return [0, null]
+    }
+    if (this.chunks.length === 0) {
+      if (this.writerClosed) {
+        return [0, this.writerErr ?? EOF]
+      }
+      return [0, EOF]
+    }
+
+    let copied = 0
+    while (copied < $.len(p) && this.chunks.length > 0) {
+      const chunk = this.chunks[0]
+      const available = chunk.length - this.readOffset
+      const want = Math.min($.len(p) - copied, available)
+      const target = $.goSlice(p, copied, copied + want)
+      $.copy(target, chunk.subarray(this.readOffset, this.readOffset + want))
+      copied += want
+      this.readOffset += want
+      if (this.readOffset === chunk.length) {
+        this.chunks.shift()
+        this.readOffset = 0
+      }
+    }
+    return [copied, null]
+  }
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    if (this.writerClosed || this.readerClosed) {
+      return [0, this.readerErr ?? ErrClosedPipe]
+    }
+    const data = new Uint8Array($.len(p))
+    $.copy(data, p)
+    this.chunks.push(data)
+    return [$.len(p), null]
+  }
+
+  CloseReader(err: $.GoError): $.GoError {
+    this.readerClosed = true
+    this.readerErr = err
+    this.chunks = []
+    this.readOffset = 0
+    return null
+  }
+
+  CloseWriter(err: $.GoError): $.GoError {
+    this.writerClosed = true
+    this.writerErr = err
+    return null
+  }
+}
+
+// PipeReader is the read half of a pipe.
+export class PipeReader implements Reader, Closer {
+  constructor(private pipe: pipeState) {}
+
+  Read(data: $.Bytes): [number, $.GoError] {
+    return this.pipe.Read(data)
+  }
+
+  Close(): $.GoError {
+    return this.CloseWithError(null)
+  }
+
+  CloseWithError(err: $.GoError): $.GoError {
+    return this.pipe.CloseReader(err ?? ErrClosedPipe)
+  }
+}
+
+// PipeWriter is the write half of a pipe.
+export class PipeWriter implements Writer, Closer {
+  constructor(private pipe: pipeState) {}
+
+  Write(data: $.Bytes): [number, $.GoError] {
+    return this.pipe.Write(data)
+  }
+
+  Close(): $.GoError {
+    return this.CloseWithError(null)
+  }
+
+  CloseWithError(err: $.GoError): $.GoError {
+    return this.pipe.CloseWriter(err ?? EOF)
+  }
+}
+
+// Pipe creates a synchronous in-memory pipe.
+export function Pipe(): [PipeReader, PipeWriter] {
+  const pipe = new pipeState()
+  return [new PipeReader(pipe), new PipeWriter(pipe)]
+}
+
 // ReaderAt is the interface that wraps the basic ReadAt method
 export interface ReaderAt {
   ReadAt(p: $.Bytes, off: number): [number, $.GoError]
@@ -150,18 +257,20 @@ export class LimitedReader implements Reader {
   }
 
   Read(p: $.Bytes): [number, $.GoError] {
-    if (this.N <= 0) {
-      return [0, EOF]
-    }
+    return (async (): Promise<[number, $.GoError]> => {
+      if (this.N <= 0) {
+        return [0, EOF]
+      }
 
-    let readBuf = p
-    if ($.len(p) > this.N) {
-      readBuf = $.goSlice(p, 0, this.N)
-    }
+      let readBuf = p
+      if ($.len(p) > this.N) {
+        readBuf = $.goSlice(p, 0, this.N)
+      }
 
-    const [n, err] = this.R.Read(readBuf)
-    this.N -= n
-    return [n, err]
+      const [n, err] = await (this.R.Read(readBuf) as any)
+      this.N -= n
+      return [n, err]
+    })() as any
   }
 }
 
@@ -308,24 +417,33 @@ export function NewOffsetWriter(w: WriterAt, off: number): OffsetWriter {
 }
 
 // Copy copies from src to dst until either EOF is reached on src or an error occurs
-export function Copy(dst: Writer, src: Reader): [number, $.GoError] {
-  return CopyBuffer(dst, src, null)
+export async function Copy(
+  dst: WriterLike,
+  src: ReaderLike,
+): Promise<[number, $.GoError]> {
+  return await CopyBuffer(dst, src, null)
 }
 
 // CopyBuffer is identical to Copy except that it stages through the provided buffer
-export function CopyBuffer(
-  dst: Writer,
-  src: Reader,
+export async function CopyBuffer(
+  dst: WriterLike,
+  src: ReaderLike,
   buf: $.Bytes | null,
-): [number, $.GoError] {
+): Promise<[number, $.GoError]> {
+  dst = unwrapWriter(dst)
+  src = unwrapReader(src)
+  if (dst === null || src === null) {
+    return [0, newError('io: copy with nil reader or writer')]
+  }
+
   // If src implements WriterTo, use it
   if ('WriteTo' in src && typeof (src as any).WriteTo === 'function') {
-    return (src as WriterTo).WriteTo(dst)
+    return await ((src as WriterTo).WriteTo(dst) as any)
   }
 
   // If dst implements ReaderFrom, use it
   if ('ReadFrom' in dst && typeof (dst as any).ReadFrom === 'function') {
-    return (dst as ReaderFrom).ReadFrom(src)
+    return await ((dst as ReaderFrom).ReadFrom(src) as any)
   }
 
   if (buf === null) {
@@ -334,9 +452,9 @@ export function CopyBuffer(
 
   let written = 0
   while (true) {
-    const [nr, er] = src.Read(buf)
+    const [nr, er] = await (src.Read(buf) as any)
     if (nr > 0) {
-      const [nw, ew] = dst.Write($.goSlice(buf, 0, nr))
+      const [nw, ew] = await (dst.Write($.goSlice(buf, 0, nr)) as any)
       if (nw < 0 || nr < nw) {
         if (ew === null) {
           return [written, ErrShortWrite]
@@ -361,13 +479,33 @@ export function CopyBuffer(
   return [written, null]
 }
 
+function unwrapReader(src: ReaderLike): Reader | null {
+  if (src == null) {
+    return null
+  }
+  if ('Read' in src && typeof (src as any).Read === 'function') {
+    return src as Reader
+  }
+  return (src as { Reader: Reader | null }).Reader
+}
+
+function unwrapWriter(dst: WriterLike): Writer | null {
+  if (dst == null) {
+    return null
+  }
+  if ('Write' in dst && typeof (dst as any).Write === 'function') {
+    return dst as Writer
+  }
+  return (dst as { Writer: Writer | null }).Writer
+}
+
 // CopyN copies n bytes (or until an error) from src to dst
-export function CopyN(
+export async function CopyN(
   dst: Writer,
   src: Reader,
   n: number,
-): [number, $.GoError] {
-  const [written, err] = Copy(dst, LimitReader(src, n))
+): Promise<[number, $.GoError]> {
+  const [written, err] = await Copy(dst, LimitReader(src, n))
   if (written === n) {
     return [written, null]
   }
@@ -379,23 +517,26 @@ export function CopyN(
 }
 
 // ReadAtLeast reads from r into buf until it has read at least min bytes
-export function ReadAtLeast(
+export async function ReadAtLeast(
   r: Reader,
   buf: $.Bytes,
   min: number,
-): [number, $.GoError] {
+): Promise<[number, $.GoError]> {
   if ($.len(buf) < min) {
     return [0, ErrShortBuffer]
   }
 
   let n = 0
   while (n < min) {
-    const [nn, err] = r.Read($.goSlice(buf, n))
+    const [nn, err] = await (r.Read($.goSlice(buf, n)) as any)
     n += nn
     if (err !== null) {
       if (err === EOF && n >= min) {
         return [n, null]
       }
+      if (err === EOF && n === 0) {
+        return [n, EOF]
+      }
       if (err === EOF && n < min) {
         return [n, ErrUnexpectedEOF]
       }
@@ -406,20 +547,22 @@ export function ReadAtLeast(
 }
 
 // ReadFull reads exactly len(buf) bytes from r into buf
-export function ReadFull(r: Reader, buf: $.Bytes): [number, $.GoError] {
-  return ReadAtLeast(r, buf, $.len(buf))
+export async function ReadFull(r: Reader, buf: $.Bytes): Promise<[number, $.GoError]> {
+  return await ReadAtLeast(r, buf, $.len(buf))
 }
 
 // ReadAll reads from r until an error or EOF and returns the data it read
-export function ReadAll(r: Reader): [$.Bytes, $.GoError] {
+export async function ReadAll(r: Reader): Promise<[$.Bytes, $.GoError]> {
   const chunks: $.Bytes[] = []
   let totalLength = 0
   const buf = $.makeSlice<number>(512, undefined, 'byte')
 
   while (true) {
-    const [n, err] = r.Read(buf)
+    const [n, err] = await (r.Read(buf) as any)
     if (n > 0) {
-      chunks.push($.goSlice(buf, 0, n))
+      const chunk = $.makeSlice<number>(n, undefined, 'byte')
+      $.copy(chunk, $.goSlice(buf, 0, n))
+      chunks.push(chunk)
       totalLength += n
     }
     if (err !== null) {

package/gs/io/meta.json

@@ -5,5 +5,13 @@
     "path",
     "time",
     "unicode/utf8"
-  ]
-} 
+  ],
+  "asyncFunctions": {
+    "Copy": true,
+    "CopyBuffer": true,
+    "CopyN": true,
+    "ReadAtLeast": true,
+    "ReadFull": true,
+    "ReadAll": true
+  }
+}

package/gs/maps/iter.ts

@@ -5,9 +5,11 @@ import * as iter from '@goscript/iter/index.js'
 // All returns an iterator over key-value pairs from m.
 // The iteration order is not specified and is not guaranteed
 // to be the same from one call to the next.
-export function All<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq2<K, V> {
+export function All<K extends $.Comparable, V>(
+  m: Map<K, V> | null,
+): iter.Seq2<K, V> {
   return (_yield: ((p0: K, p1: V) => boolean) | null): void => {
-    for (const [k, v] of m.entries()) {
+    for (const [k, v] of m?.entries() ?? []) {
       if (!_yield!(k, v)) {
         return
       }
@@ -18,9 +20,11 @@ export function All<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq2<K, V> {
 // Keys returns an iterator over keys in m.
 // The iteration order is not specified and is not guaranteed
 // to be the same from one call to the next.
-export function Keys<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq<K> {
+export function Keys<K extends $.Comparable, V>(
+  m: Map<K, V> | null,
+): iter.Seq<K> {
   return (_yield: ((p0: K) => boolean) | null): void => {
-    for (const [k, _v] of m.entries()) {
+    for (const [k, _v] of m?.entries() ?? []) {
       if (!_yield!(k)) {
         return
       }
@@ -31,9 +35,11 @@ export function Keys<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq<K> {
 // Values returns an iterator over values in m.
 // The iteration order is not specified and is not guaranteed
 // to be the same from one call to the next.
-export function Values<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq<V> {
+export function Values<K extends $.Comparable, V>(
+  m: Map<K, V> | null,
+): iter.Seq<V> {
   return (_yield: ((p0: V) => boolean) | null): void => {
-    for (const [_k, v] of m.entries()) {
+    for (const [_k, v] of m?.entries() ?? []) {
       if (!_yield!(v)) {
         return
       }

package/gs/maps/maps.ts

@@ -55,12 +55,14 @@ export function clone<K extends $.Comparable, V>(
 
 // Clone returns a copy of m.  This is a shallow clone:
 // the new keys and values are set using ordinary assignment.
-export function Clone<K extends $.Comparable, V>(m: Map<K, V>): Map<K, V> {
+export function Clone<K extends $.Comparable, V>(
+  m: Map<K, V> | null,
+): Map<K, V> | null {
   // Preserve nil in case it matters.
   if (m == null) {
-    return null as unknown as Map<K, V>
+    return null
   }
-  return clone(m)!
+  return clone(m)
 }
 
 // Copy copies all key/value pairs in src adding them to dst.
@@ -68,10 +70,10 @@ export function Clone<K extends $.Comparable, V>(m: Map<K, V>): Map<K, V> {
 // the value in dst will be overwritten by the value associated
 // with the key in src.
 export function Copy<K extends $.Comparable, V>(
-  dst: Map<K, V>,
-  src: Map<K, V>,
+  dst: Map<K, V> | null,
+  src: Map<K, V> | null,
 ): void {
-  for (const [k, v] of src.entries()) {
+  for (const [k, v] of src?.entries() ?? []) {
     $.mapSet(dst, k, v)
   }
 }

package/gs/math/bits/index.ts

@@ -4,6 +4,22 @@
 // UintSize is the size of a uint in bits
 export const UintSize = 32 // Assuming 32-bit for JavaScript numbers
 
+type Word64 = number | bigint
+
+const uint64Mask = (1n << 64n) - 1n
+
+function toUint64(x: Word64): bigint {
+  return BigInt(x) & uint64Mask
+}
+
+function useBigIntResult(...values: Word64[]): boolean {
+  return values.some((value) => typeof value === 'bigint')
+}
+
+function word64Result(value: bigint, useBigInt: boolean): Word64 {
+  return useBigInt ? value : Number(value)
+}
+
 // --- Leading zeros ---
 export function LeadingZeros(x: number): number {
   return Math.clz32(x >>> 0)
@@ -21,8 +37,9 @@ export function LeadingZeros32(x: number): number {
   return Math.clz32(x >>> 0)
 }
 
-export function LeadingZeros64(x: bigint): number {
+export function LeadingZeros64(x: Word64): number {
   // For 64-bit, we need to handle it differently
+  x = toUint64(x)
   if (x === 0n) return 64
   let count = 0
   let mask = 1n << 63n
@@ -59,7 +76,8 @@ export function TrailingZeros32(x: number): number {
   return count
 }
 
-export function TrailingZeros64(x: bigint): number {
+export function TrailingZeros64(x: Word64): number {
+  x = toUint64(x)
   if (x === 0n) return 64
   let count = 0
   while ((x & 1n) === 0n && count < 64) {
@@ -93,7 +111,8 @@ export function OnesCount32(x: number): number {
   return count
 }
 
-export function OnesCount64(x: bigint): number {
+export function OnesCount64(x: Word64): number {
+  x = toUint64(x)
   let count = 0
   while (x > 0n) {
     count++
@@ -128,12 +147,17 @@ export function RotateLeft32(x: number, k: number): number {
   return ((x << k) | (x >>> (n - k))) >>> 0
 }
 
-export function RotateLeft64(x: bigint, k: number): bigint {
+export function RotateLeft64(x: number, k: number): number
+export function RotateLeft64(x: bigint, k: number): bigint
+export function RotateLeft64(x: Word64, k: number): Word64 {
   const n = 64
   k = k % n
-  const mask = (1n << 64n) - 1n
-  x = x & mask
-  return ((x << BigInt(k)) | (x >> BigInt(n - k))) & mask
+  const useBigInt = useBigIntResult(x)
+  const word = toUint64(x)
+  return word64Result(
+    ((word << BigInt(k)) | (word >> BigInt(n - k))) & uint64Mask,
+    useBigInt,
+  )
 }
 
 // --- Reverse ---
@@ -168,25 +192,39 @@ export function Reverse32(x: number): number {
   return x >>> 0
 }
 
-export function Reverse64(x: bigint): bigint {
+export function Reverse64(x: number): number
+export function Reverse64(x: bigint): bigint
+export function Reverse64(x: Word64): Word64 {
   // Implement 64-bit reverse using similar bit manipulation
-  const mask = (1n << 64n) - 1n
-  x = x & mask
+  const useBigInt = useBigIntResult(x)
+  let word = toUint64(x)
 
   // Swap 32-bit halves
-  x = ((x & 0xffffffff00000000n) >> 32n) | ((x & 0x00000000ffffffffn) << 32n)
+  word =
+    ((word & 0xffffffff00000000n) >> 32n) |
+    ((word & 0x00000000ffffffffn) << 32n)
   // Swap 16-bit chunks
-  x = ((x & 0xffff0000ffff0000n) >> 16n) | ((x & 0x0000ffff0000ffffn) << 16n)
+  word =
+    ((word & 0xffff0000ffff0000n) >> 16n) |
+    ((word & 0x0000ffff0000ffffn) << 16n)
   // Swap 8-bit chunks
-  x = ((x & 0xff00ff00ff00ff00n) >> 8n) | ((x & 0x00ff00ff00ff00ffn) << 8n)
+  word =
+    ((word & 0xff00ff00ff00ff00n) >> 8n) |
+    ((word & 0x00ff00ff00ff00ffn) << 8n)
   // Swap 4-bit chunks
-  x = ((x & 0xf0f0f0f0f0f0f0f0n) >> 4n) | ((x & 0x0f0f0f0f0f0f0f0fn) << 4n)
+  word =
+    ((word & 0xf0f0f0f0f0f0f0f0n) >> 4n) |
+    ((word & 0x0f0f0f0f0f0f0f0fn) << 4n)
   // Swap 2-bit chunks
-  x = ((x & 0xccccccccccccccccn) >> 2n) | ((x & 0x3333333333333333n) << 2n)
+  word =
+    ((word & 0xccccccccccccccccn) >> 2n) |
+    ((word & 0x3333333333333333n) << 2n)
   // Swap 1-bit chunks
-  x = ((x & 0xaaaaaaaaaaaaaaaan) >> 1n) | ((x & 0x5555555555555555n) << 1n)
+  word =
+    ((word & 0xaaaaaaaaaaaaaaaan) >> 1n) |
+    ((word & 0x5555555555555555n) << 1n)
 
-  return x & mask
+  return word64Result(word & uint64Mask, useBigInt)
 }
 
 // --- ReverseBytes ---
@@ -209,20 +247,23 @@ export function ReverseBytes32(x: number): number {
   )
 }
 
-export function ReverseBytes64(x: bigint): bigint {
-  const mask = (1n << 64n) - 1n
-  x = x & mask
-
-  return (
-    (((x & 0xffn) << 56n) |
-      ((x & 0xff00n) << 40n) |
-      ((x & 0xff0000n) << 24n) |
-      ((x & 0xff000000n) << 8n) |
-      ((x & 0xff00000000n) >> 8n) |
-      ((x & 0xff0000000000n) >> 24n) |
-      ((x & 0xff000000000000n) >> 40n) |
-      ((x & 0xff00000000000000n) >> 56n)) &
-    mask
+export function ReverseBytes64(x: number): number
+export function ReverseBytes64(x: bigint): bigint
+export function ReverseBytes64(x: Word64): Word64 {
+  const useBigInt = useBigIntResult(x)
+  const word = toUint64(x)
+
+  return word64Result(
+    (((word & 0xffn) << 56n) |
+      ((word & 0xff00n) << 40n) |
+      ((word & 0xff0000n) << 24n) |
+      ((word & 0xff000000n) << 8n) |
+      ((word & 0xff00000000n) >> 8n) |
+      ((word & 0xff0000000000n) >> 24n) |
+      ((word & 0xff000000000000n) >> 40n) |
+      ((word & 0xff00000000000000n) >> 56n)) &
+      uint64Mask,
+    useBigInt,
   )
 }
 
@@ -243,7 +284,7 @@ export function Len32(x: number): number {
   return 32 - LeadingZeros32(x)
 }
 
-export function Len64(x: bigint): number {
+export function Len64(x: Word64): number {
   return 64 - LeadingZeros64(x)
 }
 
@@ -260,7 +301,12 @@ export function Mul32(x: number, y: number): [number, number] {
   return [hi, lo]
 }
 
-export function Mul64(x: bigint, y: bigint): [bigint, bigint] {
+export function Mul64(x: number, y: number): [number, number]
+export function Mul64(x: bigint, y: bigint): [bigint, bigint]
+export function Mul64(x: Word64, y: Word64): [Word64, Word64] {
+  const useBigInt = useBigIntResult(x, y)
+  x = toUint64(x)
+  y = toUint64(y)
   const mask32 = 0xffffffffn
 
   // Split into 32-bit parts
@@ -279,7 +325,7 @@ export function Mul64(x: bigint, y: bigint): [bigint, bigint] {
   const lo = p00 + ((p01 + p10) << 32n)
   const hi = p11 + ((p01 + p10) >> 32n) + (lo < p00 ? 1n : 0n)
 
-  return [hi, lo]
+  return [word64Result(hi & uint64Mask, useBigInt), word64Result(lo & uint64Mask, useBigInt)]
 }
 
 // --- Division functions ---
@@ -302,7 +348,13 @@ export function Div32(hi: number, lo: number, y: number): [number, number] {
   return [Number(quotient), Number(remainder)]
 }
 
-export function Div64(hi: bigint, lo: bigint, y: bigint): [bigint, bigint] {
+export function Div64(hi: number, lo: number, y: number): [number, number]
+export function Div64(hi: bigint, lo: bigint, y: bigint): [bigint, bigint]
+export function Div64(hi: Word64, lo: Word64, y: Word64): [Word64, Word64] {
+  const useBigInt = useBigIntResult(hi, lo, y)
+  hi = toUint64(hi)
+  lo = toUint64(lo)
+  y = toUint64(y)
   if (y === 0n) {
     throw new Error('division by zero')
   }
@@ -313,7 +365,7 @@ export function Div64(hi: bigint, lo: bigint, y: bigint): [bigint, bigint] {
   const quotient = dividend / y
   const remainder = dividend % y
 
-  return [quotient, remainder]
+  return [word64Result(quotient, useBigInt), word64Result(remainder, useBigInt)]
 }
 
 // --- Add and Sub with carry ---
@@ -328,12 +380,14 @@ export function Add32(x: number, y: number, carry: number): [number, number] {
   return [result, carryOut]
 }
 
-export function Add64(x: bigint, y: bigint, carry: bigint): [bigint, bigint] {
-  const mask = (1n << 64n) - 1n
-  const sum = (x & mask) + (y & mask) + (carry & mask)
-  const result = sum & mask
-  const carryOut = sum > mask ? 1n : 0n
-  return [result, carryOut]
+export function Add64(x: number, y: number, carry: number): [number, number]
+export function Add64(x: bigint, y: bigint, carry: bigint): [bigint, bigint]
+export function Add64(x: Word64, y: Word64, carry: Word64): [Word64, Word64] {
+  const useBigInt = useBigIntResult(x, y, carry)
+  const sum = toUint64(x) + toUint64(y) + toUint64(carry)
+  const result = sum & uint64Mask
+  const carryOut = sum > uint64Mask ? 1n : 0n
+  return [word64Result(result, useBigInt), word64Result(carryOut, useBigInt)]
 }
 
 export function Sub(x: number, y: number, borrow: number): [number, number] {
@@ -347,10 +401,12 @@ export function Sub32(x: number, y: number, borrow: number): [number, number] {
   return [result, borrowOut]
 }
 
-export function Sub64(x: bigint, y: bigint, borrow: bigint): [bigint, bigint] {
-  const mask = (1n << 64n) - 1n
-  const diff = (x & mask) - (y & mask) - (borrow & mask)
-  const result = diff & mask
+export function Sub64(x: number, y: number, borrow: number): [number, number]
+export function Sub64(x: bigint, y: bigint, borrow: bigint): [bigint, bigint]
+export function Sub64(x: Word64, y: Word64, borrow: Word64): [Word64, Word64] {
+  const useBigInt = useBigIntResult(x, y, borrow)
+  const diff = toUint64(x) - toUint64(y) - toUint64(borrow)
+  const result = diff & uint64Mask
   const borrowOut = diff < 0n ? 1n : 0n
-  return [result, borrowOut]
+  return [word64Result(result, useBigInt), word64Result(borrowOut, useBigInt)]
 }

package/gs/math/const.gs.test.ts

@@ -69,12 +69,18 @@ describe('Mathematical Constants', () => {
     expect(MaxUint32).toBe(4294967295)
   })
 
-  it('should have correct bigint limits', () => {
-    expect(MaxInt).toBe(9223372036854775807n)
-    expect(MinInt).toBe(-9223372036854775808n)
-    expect(MaxInt64).toBe(9223372036854775807n)
-    expect(MinInt64).toBe(-9223372036854775808n)
+  it('should have correct wide integer limits', () => {
+    expect(MaxInt).toBe(Number(9223372036854775807n))
+    expect(MinInt).toBe(Number(-9223372036854775808n))
+    expect(MaxInt64).toBe(Number(9223372036854775807n))
+    expect(MinInt64).toBe(Number(-9223372036854775808n))
     expect(MaxUint).toBe(0xffffffffffffffffn)
     expect(MaxUint64).toBe(0xffffffffffffffffn)
   })
+
+  it('should typecheck current number-based uint64 comparisons', () => {
+    const counter: number = 0
+    const atLimit: boolean = counter === MaxUint64
+    expect(atLimit).toBe(false)
+  })
 })