goscript 0.1.1 → 0.1.2

package/gs/github.com/aperturerobotics/util/conc/index.ts

@@ -0,0 +1,172 @@
+import * as $ from '../../../../builtin/index.js'
+import * as context from '../../../../context/index.js'
+
+type Job = (() => void | globalThis.Promise<void>) | null
+
+// ConcurrentQueue runs jobs with a bounded number of active workers.
+export class ConcurrentQueue {
+  private readonly maxConcurrency: number
+  private running = 0
+  private readonly queue: Job[] = []
+  private waitCh = $.makeChannel<{}>(0, {}, 'both')
+
+  constructor(maxConcurrency: number, initialElems: $.Slice<Job> = null) {
+    this.maxConcurrency = maxConcurrency
+    for (const job of initialElems ?? []) {
+      this.queue.push(job)
+    }
+    this.update()
+  }
+
+  public Enqueue(jobs: $.Slice<Job>): [number, number]
+  public Enqueue(...jobs: Job[]): [number, number]
+  public Enqueue(...args: [$.Slice<Job>] | Job[]): [number, number] {
+    const jobs = normalizeJobs(args)
+    for (const job of jobs) {
+      if (this.maxConcurrency <= 0 || this.running < this.maxConcurrency) {
+        this.running++
+        this.start(job)
+        continue
+      }
+      this.queue.push(job)
+    }
+    if (jobs.length !== 0) {
+      this.notify()
+    }
+    return [this.queue.length, this.running]
+  }
+
+  public async WaitIdle(
+    ctx: context.Context,
+    errCh: $.Channel<$.GoError> | null,
+  ): Promise<$.GoError> {
+    for (;;) {
+      if (this.running === 0 && this.queue.length === 0) {
+        return null
+      }
+      const waitCh = this.waitCh
+      const [hasReturn, err] = await $.selectStatement<unknown, $.GoError>(
+        [
+          {
+            id: 0,
+            isSend: false,
+            channel: ctx?.Done() ?? null,
+            onSelected: async () => context.Canceled,
+          },
+          {
+            id: 1,
+            isSend: false,
+            channel: errCh,
+            onSelected: async (result) => {
+              if (!result.ok) {
+                return context.Canceled
+              }
+              return result.value ?? null
+            },
+          },
+          {
+            id: 2,
+            isSend: false,
+            channel: waitCh,
+            onSelected: async () => null,
+          },
+        ],
+        false,
+      )
+      if (hasReturn && err != null) {
+        return err
+      }
+    }
+  }
+
+  public async WatchState(
+    ctx: context.Context,
+    _errCh: $.Channel<$.GoError> | null,
+    cb: ((queued: number, running: number) => [boolean, $.GoError]) | null,
+  ): Promise<$.GoError> {
+    if (cb == null) {
+      return null
+    }
+    for (;;) {
+      const waitCh = this.waitCh
+      const [cont, err] = cb(this.queue.length, this.running)
+      if (err != null || !cont) {
+        return err
+      }
+      const [hasReturn, waitErr] = await $.selectStatement<unknown, $.GoError>(
+        [
+          {
+            id: 0,
+            isSend: false,
+            channel: ctx?.Done() ?? null,
+            onSelected: async () => context.Canceled,
+          },
+          {
+            id: 1,
+            isSend: false,
+            channel: waitCh,
+            onSelected: async () => null,
+          },
+        ],
+        false,
+      )
+      if (hasReturn && waitErr != null) {
+        return waitErr
+      }
+    }
+  }
+
+  private start(job: Job): void {
+    queueMicrotask(async () => {
+      try {
+        await job?.()
+      } finally {
+        this.running--
+        this.update()
+        this.notify()
+      }
+    })
+  }
+
+  private update(): void {
+    while (
+      this.queue.length !== 0 &&
+      (this.maxConcurrency <= 0 || this.running < this.maxConcurrency)
+    ) {
+      const job = this.queue.shift() ?? null
+      this.running++
+      this.start(job)
+    }
+  }
+
+  private notify(): void {
+    const waitCh = this.waitCh
+    this.waitCh = $.makeChannel<{}>(0, {}, 'both')
+    waitCh.close()
+  }
+}
+
+export function NewConcurrentQueue(
+  maxConcurrency: number,
+  initialElems?: $.Slice<Job>,
+): ConcurrentQueue
+export function NewConcurrentQueue(
+  maxConcurrency: number,
+  ...initialElems: Job[]
+): ConcurrentQueue
+export function NewConcurrentQueue(
+  maxConcurrency: number,
+  ...args: [$.Slice<Job>?] | Job[]
+): ConcurrentQueue {
+  return new ConcurrentQueue(maxConcurrency, normalizeJobs(args))
+}
+
+function normalizeJobs(args: [$.Slice<Job>?] | Job[]): Job[] {
+  if (args.length === 0) {
+    return []
+  }
+  if (args.length === 1 && (Array.isArray(args[0]) || args[0] == null)) {
+    return Array.from((args[0] as $.Slice<Job>) ?? [])
+  }
+  return args as Job[]
+}

package/gs/github.com/aperturerobotics/util/conc/meta.json

@@ -0,0 +1,9 @@
+{
+  "dependencies": [
+    "context"
+  ],
+  "asyncMethods": {
+    "ConcurrentQueue.WaitIdle": true,
+    "ConcurrentQueue.WatchState": true
+  }
+}

package/gs/github.com/aperturerobotics/wasivm/wazero/kernel/runtime/browser/browser.ts

@@ -8,10 +8,7 @@ export class Runtime implements vmruntime.VmRuntime {
   constructor() {}
 
   // Compile calls WebAssembly.compile and returns a Module.
-  async Compile(
-    _ctx: any,
-    wasm: Uint8Array | number[],
-  ): Promise<Module> {
+  async Compile(_ctx: any, wasm: Uint8Array | number[]): Promise<Module> {
     const bytes = wasm instanceof Uint8Array ? wasm : new Uint8Array(wasm)
     const compiled = await WebAssembly.compile(bytes.buffer as ArrayBuffer)
     return new Module(compiled)

package/gs/github.com/hack-pad/safejs/internal/catch/index.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+import * as js from '@goscript/syscall/js/index.js'
+
+import { Try, TrySideEffect } from './index.js'
+
+describe('safejs catch override', () => {
+  test('returns happy path result', async () => {
+    await expect(Try(() => 'ok')).resolves.toEqual(['ok', null])
+  })
+
+  test('converts Go panic payloads to errors', async () => {
+    const [, err] = await Try(() => {
+      $.panic('some error')
+    })
+
+    expect(err?.Error()).toBe('some error')
+  })
+
+  test('converts syscall/js values to js errors', async () => {
+    const err = await TrySideEffect(() => {
+      $.panic(js.ValueOf(new Error('bad js')))
+    })
+
+    expect(err?.Error()).toBe('JavaScript error: bad js')
+  })
+
+  test('converts JavaScript throws to js errors', async () => {
+    const [, err] = await Try(() => {
+      throw new Error('bad throw')
+    })
+
+    expect(err?.Error()).toBe('JavaScript error: bad throw')
+  })
+})

package/gs/github.com/hack-pad/safejs/internal/catch/index.ts

@@ -0,0 +1,65 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as js from '@goscript/syscall/js/index.js'
+
+class CatchError {
+  constructor(private readonly message: string) {}
+
+  Error(): string {
+    return this.message
+  }
+}
+
+export async function Try(
+  fn: (() => unknown | Promise<unknown>) | null,
+): Promise<[unknown, $.GoError]> {
+  try {
+    return [await fn!(), null]
+  } catch (caught) {
+    return [null, recoverValueToError($.panicValue(caught))]
+  }
+}
+
+export async function TrySideEffect(
+  fn: (() => void | Promise<void>) | null,
+): Promise<$.GoError> {
+  try {
+    await fn!()
+    return null
+  } catch (caught) {
+    return recoverValueToError($.panicValue(caught))
+  }
+}
+
+function recoverValueToError(value: unknown): $.GoError {
+  if (value == null) {
+    return null
+  }
+  if (isGoError(value)) {
+    return value
+  }
+  if (value instanceof js.Value) {
+    return $.interfaceValue<$.GoError>(
+      $.markAsStructValue(new js.Error({ Value: value })),
+      'js.Error',
+    )
+  }
+  if (value instanceof Error) {
+    return $.interfaceValue<$.GoError>(
+      $.markAsStructValue(new js.Error({ Value: js.ValueOf(value) })),
+      'js.Error',
+    )
+  }
+  return $.interfaceValue<$.GoError>(
+    new CatchError(String(value)),
+    'catch.catchError',
+  )
+}
+
+function isGoError(value: unknown): value is Exclude<$.GoError, null> {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    'Error' in value &&
+    typeof (value as { Error?: unknown }).Error === 'function'
+  )
+}

package/gs/github.com/hack-pad/safejs/internal/catch/meta.json

@@ -0,0 +1,9 @@
+{
+  "asyncFunctions": {
+    "Try": true,
+    "TrySideEffect": true
+  },
+  "dependencies": [
+    "syscall/js"
+  ]
+}

package/gs/github.com/klauspost/compress/internal/le/index.test.ts

@@ -10,7 +10,8 @@ function bytes(value: string): number[] {
 }
 
 function matchBytes(a: number[], b: number[]): number {
-  const diff = (Load64(undefined, arrayToSlice(a), 0) as unknown as bigint) ^
+  const diff =
+    (Load64(undefined, arrayToSlice(a), 0) as unknown as bigint) ^
     (Load64(undefined, arrayToSlice(b), 0) as unknown as bigint)
   return TrailingZeros64(diff) >> 3
 }

package/gs/github.com/klauspost/compress/internal/le/index.ts

@@ -55,11 +55,12 @@ export function Load32(
 ): number {
   const [b, off] = loadArgs(typeArgsOrB, bOrI, i)
   return (
-    byteAt(b, off) |
-    (byteAt(b, off + 1) << 8) |
-    (byteAt(b, off + 2) << 16) |
-    (byteAt(b, off + 3) << 24)
-  ) >>> 0
+    (byteAt(b, off) |
+      (byteAt(b, off + 1) << 8) |
+      (byteAt(b, off + 2) << 16) |
+      (byteAt(b, off + 3) << 24)) >>>
+    0
+  )
 }
 
 export function Load64(

package/gs/github.com/mr-tron/base58/base58/index.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from 'vitest'
+
+import {
+  Decode,
+  DecodeAlphabet,
+  Encode,
+  EncodeAlphabet,
+  FlickrAlphabet,
+  NewAlphabet,
+} from './index.js'
+
+const roundTrips = [
+  [0],
+  [0, 0, 1, 2, 3],
+  [255, 254, 253, 0, 1, 2, 3],
+  Array.from({ length: 64 }, (_, i) => (i * 37) & 0xff),
+]
+
+describe('base58 override', () => {
+  test('matches known bitcoin alphabet encodings', () => {
+    expect(Encode(new Uint8Array([0]))).toBe('1')
+    expect(Encode(new Uint8Array([0, 0, 1]))).toBe('112')
+    expect(Encode(new Uint8Array([97, 98, 99]))).toBe('ZiCa')
+    expect(
+      Encode(new Uint8Array([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])),
+    ).toBe('jpXCZedGfVQ')
+  })
+
+  test('round trips bytes', () => {
+    for (const input of roundTrips) {
+      const encoded = Encode(new Uint8Array(input))
+      const [decoded, err] = Decode(encoded)
+      expect(err).toBeNull()
+      expect(Array.from(decoded ?? [])).toEqual(input)
+    }
+  })
+
+  test('supports custom alphabets', () => {
+    const input = new Uint8Array([0, 1, 2, 3, 4, 5])
+    const flickr = EncodeAlphabet(input, FlickrAlphabet)
+    const [decoded, err] = DecodeAlphabet(flickr, FlickrAlphabet)
+    expect(err).toBeNull()
+    expect(Array.from(decoded ?? [])).toEqual(Array.from(input))
+
+    const reversed = NewAlphabet(
+      '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+        .split('')
+        .reverse()
+        .join(''),
+    )
+    const encoded = EncodeAlphabet(input, reversed)
+    const [decodedReversed, reversedErr] = DecodeAlphabet(encoded, reversed)
+    expect(reversedErr).toBeNull()
+    expect(Array.from(decodedReversed ?? [])).toEqual(Array.from(input))
+  })
+
+  test('returns Go errors for invalid input', () => {
+    const [empty, emptyErr] = Decode('')
+    expect(empty).toBeNull()
+    expect(emptyErr?.Error()).toBe('zero length string')
+
+    const [invalid, invalidErr] = Decode('0')
+    expect(invalid).toBeNull()
+    expect(invalidErr?.Error()).toContain('Invalid base58 digit')
+
+    const [highBit, highBitErr] = Decode('é')
+    expect(highBit).toBeNull()
+    expect(highBitErr?.Error()).toBe('High-bit set on invalid digit')
+  })
+})

package/gs/github.com/mr-tron/base58/base58/index.ts

@@ -0,0 +1,231 @@
+import * as $ from '@goscript/builtin/index.js'
+
+const btcAlphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+const flickrAlphabet = '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+
+export class Alphabet {
+  decode: Int8Array
+  encode: Uint8Array
+
+  constructor(init?: Partial<{ decode?: Int8Array; encode?: Uint8Array }>) {
+    this.decode = init?.decode?.slice() ?? new Int8Array(128)
+    this.encode = init?.encode?.slice() ?? new Uint8Array(58)
+  }
+
+  clone(): Alphabet {
+    return new Alphabet({ decode: this.decode, encode: this.encode })
+  }
+}
+
+export function NewAlphabet(s: string): Alphabet {
+  const bytes = $.stringToBytes(s)
+  if (bytes.length !== 58) {
+    $.panic('base58 alphabets must be 58 bytes long')
+  }
+
+  const alphabet = new Alphabet()
+  alphabet.decode.fill(-1)
+  for (let i = 0; i < bytes.length; i++) {
+    const code = bytes[i]
+    if (code > 127) {
+      $.panic('base58 alphabets must be valid ASCII')
+    }
+    alphabet.encode[i] = code
+    alphabet.decode[code] = i
+  }
+  return alphabet
+}
+
+export let BTCAlphabet: Alphabet | $.VarRef<Alphabet> | null =
+  NewAlphabet(btcAlphabet)
+
+export function __goscript_set_BTCAlphabet(
+  value: Alphabet | $.VarRef<Alphabet> | null,
+): void {
+  BTCAlphabet = value
+}
+
+export let FlickrAlphabet: Alphabet | $.VarRef<Alphabet> | null =
+  NewAlphabet(flickrAlphabet)
+
+export function __goscript_set_FlickrAlphabet(
+  value: Alphabet | $.VarRef<Alphabet> | null,
+): void {
+  FlickrAlphabet = value
+}
+
+export function Encode(bin: $.Bytes): string {
+  return FastBase58Encoding(bin)
+}
+
+export function EncodeAlphabet(
+  bin: $.Bytes,
+  alphabet: Alphabet | $.VarRef<Alphabet> | null,
+): string {
+  return FastBase58EncodingAlphabet(bin, alphabet)
+}
+
+export function FastBase58Encoding(bin: $.Bytes): string {
+  return FastBase58EncodingAlphabet(bin, BTCAlphabet)
+}
+
+export function FastBase58EncodingAlphabet(
+  bin: $.Bytes,
+  alphabet: Alphabet | $.VarRef<Alphabet> | null,
+): string {
+  const bytes = $.bytesToUint8Array(bin)
+  const alpha = $.pointerValue(alphabet)
+  if (alpha == null) {
+    $.panic('base58 alphabet is nil')
+  }
+
+  const zero = alpha.encode[0]
+  const binsz = bytes.length
+  let zcount = 0
+  while (zcount < binsz && bytes[zcount] === 0) {
+    zcount++
+  }
+
+  const size = Math.trunc(((binsz - zcount) * 138) / 100) + 1
+  let value = 0n
+  for (let i = zcount; i < binsz; i++) {
+    value = (value << 8n) + BigInt(bytes[i])
+  }
+
+  const out = new Uint8Array(size + zcount)
+  let offset = out.length
+  while (value > 0n) {
+    const digit = Number(value % 58n)
+    value /= 58n
+    offset--
+    out[offset] = alpha.encode[digit]
+  }
+  for (let i = 0; i < zcount; i++) {
+    offset--
+    out[offset] = zero
+  }
+
+  return $.bytesToString(out.subarray(offset))
+}
+
+export function TrivialBase58Encoding(a: $.Bytes): string {
+  return FastBase58Encoding(a)
+}
+
+export function TrivialBase58EncodingAlphabet(
+  a: $.Bytes,
+  alphabet: Alphabet | $.VarRef<Alphabet> | null,
+): string {
+  return FastBase58EncodingAlphabet(a, alphabet)
+}
+
+export function Decode(str: string): [Uint8Array | null, $.GoError] {
+  return FastBase58Decoding(str)
+}
+
+export function DecodeAlphabet(
+  str: string,
+  alphabet: Alphabet | $.VarRef<Alphabet> | null,
+): [Uint8Array | null, $.GoError] {
+  return FastBase58DecodingAlphabet(str, alphabet)
+}
+
+export function FastBase58Decoding(str: string): [Uint8Array | null, $.GoError] {
+  return FastBase58DecodingAlphabet(str, BTCAlphabet)
+}
+
+export function FastBase58DecodingAlphabet(
+  str: string,
+  alphabet: Alphabet | $.VarRef<Alphabet> | null,
+): [Uint8Array | null, $.GoError] {
+  if (str.length === 0) {
+    return [null, $.newError('zero length string')]
+  }
+
+  const alpha = $.pointerValue(alphabet)
+  if (alpha == null) {
+    $.panic('base58 alphabet is nil')
+  }
+
+  const b58sz = str.length
+  const outisz = Math.trunc((b58sz + 3) / 4)
+  const binu = new Uint8Array((b58sz + 3) * 3)
+  let bytesleft = b58sz % 4
+  const zero = alpha.encode[0]
+
+  let zmask = 0
+  if (bytesleft > 0) {
+    zmask = (0xffffffff << (bytesleft * 8)) >>> 0
+  } else {
+    bytesleft = 4
+  }
+
+  const outi = new Uint32Array(outisz)
+  let zcount = 0
+  while (zcount < b58sz && str.charCodeAt(zcount) === zero) {
+    zcount++
+  }
+
+  for (let i = 0; i < b58sz; i++) {
+    const r = str.charCodeAt(i)
+    if (r > 127) {
+      return [null, $.newError('High-bit set on invalid digit')]
+    }
+    const decoded = alpha.decode[r]
+    if (decoded === -1) {
+      return [
+        null,
+        $.newError(`Invalid base58 digit ('${String.fromCodePoint(r)}')`),
+      ]
+    }
+
+    let c = decoded >>> 0
+    for (let j = outisz - 1; j >= 0; j--) {
+      const t = outi[j] * 58 + c
+      c = Math.floor(t / 0x100000000)
+      outi[j] = t >>> 0
+    }
+
+    if (c > 0) {
+      return [null, $.newError('Output number too big (carry to the next int32)')]
+    }
+    if ((outi[0] & zmask) !== 0) {
+      return [
+        null,
+        $.newError('Output number too big (last int32 filled too far)'),
+      ]
+    }
+  }
+
+  let cnt = 0
+  for (let j = 0; j < outisz; j++) {
+    for (let mask = (bytesleft - 1) * 8; mask >= 0; mask -= 8) {
+      binu[cnt] = (outi[j] >>> mask) & 0xff
+      cnt++
+    }
+    if (j === 0) {
+      bytesleft = 4
+    }
+  }
+
+  for (let n = 0; n < binu.length; n++) {
+    if (binu[n] > 0) {
+      const start = Math.max(n - zcount, 0)
+      return [binu.subarray(start, cnt), null]
+    }
+  }
+  return [binu.subarray(0, cnt), null]
+}
+
+export function TrivialBase58Decoding(
+  str: string,
+): [Uint8Array | null, $.GoError] {
+  return FastBase58Decoding(str)
+}
+
+export function TrivialBase58DecodingAlphabet(
+  str: string,
+  alphabet: Alphabet | $.VarRef<Alphabet> | null,
+): [Uint8Array | null, $.GoError] {
+  return FastBase58DecodingAlphabet(str, alphabet)
+}

package/gs/github.com/mr-tron/base58/base58/meta.json

@@ -0,0 +1,3 @@
+{
+  "dependencies": []
+}

package/gs/github.com/zeebo/blake3/internal/consts/index.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from 'vitest'
+
+import {
+  BlockLen,
+  ChunkLen,
+  Flag_ChunkEnd,
+  Flag_ChunkStart,
+  Flag_DeriveKeyContext,
+  Flag_DeriveKeyMaterial,
+  Flag_Keyed,
+  Flag_Parent,
+  Flag_Root,
+  HasAVX2,
+  HasSSE41,
+  IV,
+  IV0,
+  OptimizeLittleEndian,
+} from './index.js'
+
+describe('blake3 consts override', () => {
+  test('uses portable constants for GoScript', () => {
+    expect(IV).toEqual([
+      0x6a09e667,
+      0xbb67ae85,
+      0x3c6ef372,
+      0xa54ff53a,
+      0x510e527f,
+      0x9b05688c,
+      0x1f83d9ab,
+      0x5be0cd19,
+    ])
+    expect(IV[0]).toBe(IV0)
+    expect(BlockLen).toBe(64)
+    expect(ChunkLen).toBe(1024)
+    expect(Flag_ChunkStart).toBe(1)
+    expect(Flag_ChunkEnd).toBe(2)
+    expect(Flag_Parent).toBe(4)
+    expect(Flag_Root).toBe(8)
+    expect(Flag_Keyed).toBe(16)
+    expect(Flag_DeriveKeyContext).toBe(32)
+    expect(Flag_DeriveKeyMaterial).toBe(64)
+    expect(HasAVX2).toBe(false)
+    expect(HasSSE41).toBe(false)
+    expect(OptimizeLittleEndian).toBe(false)
+  })
+})