goscript 0.1.0 → 0.1.2

package/gs/github.com/aperturerobotics/starpc/srpc/meta.json

@@ -0,0 +1,46 @@
+{
+  "dependencies": [
+    "context",
+    "errors",
+    "io",
+    "github.com/aperturerobotics/protobuf-go-lite"
+  ],
+  "asyncMethods": {
+    "Client.ExecCall": true,
+    "Client.NewStream": true,
+    "ClientSet.ExecCall": true,
+    "ClientSet.NewStream": true,
+    "PacketWriter.WritePacket": true,
+    "PacketWriter.Close": true,
+    "PrefixClient.ExecCall": true,
+    "PrefixClient.NewStream": true,
+    "Stream.MsgSend": true,
+    "Stream.MsgRecv": true,
+    "Stream.CloseSend": true,
+    "Stream.Close": true,
+    "StreamRecv.MsgRecv": true,
+    "StreamRecv.CloseSend": true,
+    "StreamRecv.Close": true,
+    "StreamRecv.Recv": true,
+    "StreamRecv.RecvTo": true,
+    "StreamSend.MsgSend": true,
+    "StreamSend.CloseSend": true,
+    "StreamSend.Close": true,
+    "StreamSend.Send": true,
+    "StreamSendAndClose.MsgSend": true,
+    "StreamSendAndClose.CloseSend": true,
+    "StreamSendAndClose.Close": true,
+    "StreamSendAndClose.Send": true,
+    "StreamSendAndClose.SendAndClose": true,
+    "ServerRPC.HandlePacketData": true,
+    "ServerRPC.HandlePacket": true,
+    "ServerRPC.HandleCallStart": true,
+    "clientInvoker.InvokeMethod": true,
+    "InvokerFunc.InvokeMethod": true,
+    "InvokerSlice.InvokeMethod": true,
+    "Invoker.InvokeMethod": true,
+    "PrefixInvoker.InvokeMethod": true,
+    "Handler.InvokeMethod": true,
+    "Mux.InvokeMethod": true
+  }
+}

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

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'vitest'
+import { makeChannel } from '../../../../builtin/index.js'
+import { Background } from '../../../../context/index.js'
+import { NewConcurrentQueue } from './index.js'
+
+const tick = () => new Promise<void>((resolve) => queueMicrotask(resolve))
+
+describe('util/conc override', () => {
+  test('runs queued jobs within the concurrency limit', async () => {
+    const release = makeChannel<{}>(0, {}, 'both')
+    const started: number[] = []
+    const done: number[] = []
+    const job = (idx: number) => async () => {
+      started.push(idx)
+      await release.receive()
+      done.push(idx)
+    }
+
+    const q = NewConcurrentQueue(2, job(0), job(1))
+    const [queued, running] = q.Enqueue([job(2), job(3), job(4)])
+    expect([queued, running]).toEqual([3, 2])
+
+    await tick()
+    expect(started).toEqual([0, 1])
+
+    release.close()
+    expect(await q.WaitIdle(Background(), null)).toBeNull()
+    expect(done).toEqual([0, 1, 2, 3, 4])
+  })
+})

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

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+
+import { arrayToSlice } from '@goscript/builtin/index.js'
+import { TrailingZeros64 } from '@goscript/math/bits/index.js'
+
+import { Load32, Load64, Store64 } from './index.js'
+
+function bytes(value: string): number[] {
+  return Array.from(value, (char) => char.charCodeAt(0))
+}
+
+function matchBytes(a: number[], b: number[]): number {
+  const diff =
+    (Load64(undefined, arrayToSlice(a), 0) as unknown as bigint) ^
+    (Load64(undefined, arrayToSlice(b), 0) as unknown as bigint)
+  return TrailingZeros64(diff) >> 3
+}
+
+describe('klauspost internal le override', () => {
+  it('loads 32-bit little-endian values as unsigned numbers', () => {
+    expect(Load32(undefined, arrayToSlice([0x78, 0x78, 0x78, 0x78]), 0)).toBe(
+      2021161080,
+    )
+  })
+
+  it('keeps high-byte 64-bit differences exact for S2 match length', () => {
+    const base = bytes('xxxxxxxx')
+    expect(matchBytes(base, bytes('yxxxxxxx'))).toBe(0)
+    expect(matchBytes(base, bytes('xxxxyxxx'))).toBe(4)
+  })
+
+  it('stores 64-bit little-endian values at the requested offset', () => {
+    const out = arrayToSlice<number>([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    Store64(undefined, out, 1, 0x0102030405060708n)
+    expect(Array.from(out!)).toEqual([0, 8, 7, 6, 5, 4, 3, 2, 1, 0])
+  })
+})

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

@@ -0,0 +1,115 @@
+import * as $ from '@goscript/builtin/index.js'
+
+export type Indexer = number
+
+function index(value: unknown): number {
+  return Number(value)
+}
+
+function byteAt(b: $.Slice<number>, i: number): number {
+  return b![i] ?? 0
+}
+
+function isSlice(value: unknown): value is $.Slice<number> {
+  return (
+    Array.isArray(value) ||
+    value === null ||
+    value instanceof Uint8Array ||
+    (typeof value === 'object' && value !== undefined && '__meta__' in value)
+  )
+}
+
+function loadArgs(
+  typeArgsOrB: $.GenericTypeArgs | $.Slice<number> | undefined,
+  bOrI?: $.Slice<number> | unknown,
+  i?: unknown,
+): [$.Slice<number>, number] {
+  if (isSlice(typeArgsOrB)) {
+    return [typeArgsOrB, index(bOrI)]
+  }
+  return [bOrI as $.Slice<number>, index(i)]
+}
+
+export function Load8(
+  typeArgsOrB: $.GenericTypeArgs | $.Slice<number> | undefined,
+  bOrI?: $.Slice<number> | unknown,
+  i?: unknown,
+): number {
+  const [b, off] = loadArgs(typeArgsOrB, bOrI, i)
+  return byteAt(b, off)
+}
+
+export function Load16(
+  typeArgsOrB: $.GenericTypeArgs | $.Slice<number> | undefined,
+  bOrI?: $.Slice<number> | unknown,
+  i?: unknown,
+): number {
+  const [b, off] = loadArgs(typeArgsOrB, bOrI, i)
+  return byteAt(b, off) | (byteAt(b, off + 1) << 8)
+}
+
+export function Load32(
+  typeArgsOrB: $.GenericTypeArgs | $.Slice<number> | undefined,
+  bOrI?: $.Slice<number> | unknown,
+  i?: unknown,
+): 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
+  )
+}
+
+export function Load64(
+  typeArgsOrB: $.GenericTypeArgs | $.Slice<number> | undefined,
+  bOrI?: $.Slice<number> | unknown,
+  i?: unknown,
+): number {
+  const [b, off] = loadArgs(typeArgsOrB, bOrI, i)
+  const value =
+    BigInt(byteAt(b, off)) |
+    (BigInt(byteAt(b, off + 1)) << 8n) |
+    (BigInt(byteAt(b, off + 2)) << 16n) |
+    (BigInt(byteAt(b, off + 3)) << 24n) |
+    (BigInt(byteAt(b, off + 4)) << 32n) |
+    (BigInt(byteAt(b, off + 5)) << 40n) |
+    (BigInt(byteAt(b, off + 6)) << 48n) |
+    (BigInt(byteAt(b, off + 7)) << 56n)
+  return value as unknown as number
+}
+
+export function Store16(b: $.Slice<number>, v: number): void {
+  b![0] = v & 0xff
+  b![1] = (v >> 8) & 0xff
+}
+
+export function Store32(b: $.Slice<number>, v: number): void {
+  b![0] = v & 0xff
+  b![1] = (v >> 8) & 0xff
+  b![2] = (v >> 16) & 0xff
+  b![3] = (v >> 24) & 0xff
+}
+
+export function Store64(
+  typeArgsOrB: $.GenericTypeArgs | $.Slice<number> | undefined,
+  bOrI?: $.Slice<number> | unknown,
+  iOrV?: unknown,
+  maybeV?: number | bigint,
+): void {
+  const genericCall = !isSlice(typeArgsOrB)
+  const b = (genericCall ? bOrI : typeArgsOrB) as $.Slice<number>
+  const off = genericCall ? index(iOrV) : index(bOrI)
+  const v = genericCall ? maybeV : iOrV
+  const value = BigInt(v as number | bigint) & ((1n << 64n) - 1n)
+  b![off] = Number(value & 0xffn)
+  b![off + 1] = Number((value >> 8n) & 0xffn)
+  b![off + 2] = Number((value >> 16n) & 0xffn)
+  b![off + 3] = Number((value >> 24n) & 0xffn)
+  b![off + 4] = Number((value >> 32n) & 0xffn)
+  b![off + 5] = Number((value >> 40n) & 0xffn)
+  b![off + 6] = Number((value >> 48n) & 0xffn)
+  b![off + 7] = Number((value >> 56n) & 0xffn)
+}

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')
+  })
+})