goscript 0.1.0 → 0.1.2

package/gs/builtin/channel.ts

@@ -56,7 +56,7 @@ export interface Channel<T> {
    * @param id An identifier for this case in the select statement
    * @returns Promise that resolves when this case is selected
    */
-  selectReceive(id: number): Promise<SelectResult<T>>
+  selectReceive(id: number, signal?: AbortSignal): Promise<SelectResult<T>>
 
   /**
    * Used in select statements to create a send operation promise.
@@ -64,7 +64,11 @@ export interface Channel<T> {
    * @param id An identifier for this case in the select statement
    * @returns Promise that resolves when this case is selected
    */
-  selectSend(value: T, id: number): Promise<SelectResult<boolean>>
+  selectSend(
+    value: T,
+    id: number,
+    signal?: AbortSignal,
+  ): Promise<SelectResult<boolean>>
 
   /**
    * Checks if the channel has data ready to be received without blocking.
@@ -77,6 +81,16 @@ export interface Channel<T> {
    * Used for non-blocking select operations.
    */
   canSendNonBlocking(): boolean
+
+  /**
+   * Reports the number of buffered values currently queued in the channel.
+   */
+  len(): number
+
+  /**
+   * Reports the channel buffer capacity.
+   */
+  cap(): number
 }
 
 /**
@@ -91,6 +105,27 @@ export interface SelectCase<T> {
   onSelected?: (result: SelectResult<T>) => Promise<any>
 }
 
+const selectVoidReturnMarker = '__goscriptSelectVoidReturn'
+
+export interface SelectVoidReturn {
+  readonly [selectVoidReturnMarker]: true
+}
+
+export function selectVoidReturn(): SelectVoidReturn {
+  return { [selectVoidReturnMarker]: true }
+}
+
+function selectHandlerResult<V>(handlerResult: any): [boolean, V] {
+  if (
+    handlerResult &&
+    typeof handlerResult === 'object' &&
+    handlerResult[selectVoidReturnMarker] === true
+  ) {
+    return [true, undefined as V]
+  }
+  return [handlerResult !== undefined, handlerResult as V]
+}
+
 /**
  * Helper for 'select' statements. Takes an array of select cases
  * and resolves when one of them completes, following Go's select rules.
@@ -146,13 +181,13 @@ export async function selectStatement<T, V = void>(
           const handlerResult = await selectedCase.onSelected(
             result as SelectResult<T>,
           )
-          return [handlerResult !== undefined, handlerResult as V]
+          return selectHandlerResult<V>(handlerResult)
         }
       } else {
         const result = await selectedCase.channel.selectReceive(selectedCase.id)
         if (selectedCase.onSelected) {
           const handlerResult = await selectedCase.onSelected(result)
-          return [handlerResult !== undefined, handlerResult as V]
+          return selectHandlerResult<V>(handlerResult)
         }
       }
     } else {
@@ -173,22 +208,27 @@ export async function selectStatement<T, V = void>(
         ok: false,
         id: -1,
       } as SelectResult<T>)
-      return [handlerResult !== undefined, handlerResult as V]
+      return selectHandlerResult<V>(handlerResult)
     }
     return [false, undefined as V] // Return after executing the default case
   }
 
   // 3. If no operations are ready and no default case, block until one is ready
   // Use Promise.race on the blocking promises
+  const abort = new AbortController()
   const blockingPromises = cases
     .filter((c) => c.id !== -1) // Exclude default case
     .filter((c) => c.channel !== null) // Exclude nil channels (they would block forever)
     .map((caseObj) => {
       // At this point caseObj.channel is guaranteed to be non-null
       if (caseObj.isSend) {
-        return caseObj.channel!.selectSend(caseObj.value, caseObj.id)
+        return caseObj.channel!.selectSend(
+          caseObj.value,
+          caseObj.id,
+          abort.signal,
+        )
       } else {
-        return caseObj.channel!.selectReceive(caseObj.id)
+        return caseObj.channel!.selectReceive(caseObj.id, abort.signal)
       }
     })
 
@@ -199,11 +239,12 @@ export async function selectStatement<T, V = void>(
   }
 
   const result = await Promise.race(blockingPromises)
+  abort.abort()
   // Execute onSelected handler for the selected case
   const selectedCase = cases.find((c) => c.id === result.id)
   if (selectedCase && selectedCase.onSelected) {
     const handlerResult = await selectedCase.onSelected(result)
-    return [handlerResult !== undefined, handlerResult as V]
+    return selectHandlerResult<V>(handlerResult)
   }
 
   // No explicit return needed here, as the function will implicitly return after the await
@@ -425,7 +466,10 @@ class BufferedChannel<T> implements Channel<T> {
     })
   }
 
-  async selectReceive(id: number): Promise<SelectResult<T>> {
+  async selectReceive(
+    id: number,
+    signal?: AbortSignal,
+  ): Promise<SelectResult<T>> {
     if (this.buffer.length > 0) {
       const value = this.buffer.shift()!
       if (this.senders.length > 0) {
@@ -447,15 +491,43 @@ class BufferedChannel<T> implements Channel<T> {
     }
 
     return new Promise<SelectResult<T>>((resolve) => {
-      this.receiversWithOk.push({
+      const state = { done: false }
+      const receiversWithOk = this.receiversWithOk
+      const task = {
         resolveReceive: (result: ChannelReceiveResult<T>) => {
-          resolve({ ...result, id })
+          if (!state.done) {
+            state.done = true
+            cleanup()
+            resolve({ ...result, id })
+          }
         },
-      })
+      }
+      function cleanup() {
+        signal?.removeEventListener('abort', onAbort)
+        const idx = receiversWithOk.indexOf(task)
+        if (idx >= 0) {
+          receiversWithOk.splice(idx, 1)
+        }
+      }
+      function onAbort() {
+        if (!state.done) {
+          state.done = true
+          cleanup()
+        }
+      }
+      if (signal?.aborted) {
+        return
+      }
+      signal?.addEventListener('abort', onAbort, { once: true })
+      this.receiversWithOk.push(task)
     })
   }
 
-  async selectSend(value: T, id: number): Promise<SelectResult<boolean>> {
+  async selectSend(
+    value: T,
+    id: number,
+    signal?: AbortSignal,
+  ): Promise<SelectResult<boolean>> {
     if (this.closed) {
       // A select case sending on a closed channel panics in Go.
       // This will cause Promise.race in selectStatement to reject.
@@ -479,11 +551,43 @@ class BufferedChannel<T> implements Channel<T> {
     }
 
     return new Promise<SelectResult<boolean>>((resolve, reject) => {
-      this.senders.push({
+      const state = { done: false }
+      const senders = this.senders
+      const task = {
         value,
-        resolveSend: () => resolve({ value: true, ok: true, id }),
-        rejectSend: (e) => reject(e), // Propagate error if channel closes
-      })
+        resolveSend: () => {
+          if (!state.done) {
+            state.done = true
+            cleanup()
+            resolve({ value: true, ok: true, id })
+          }
+        },
+        rejectSend: (e: Error) => {
+          if (!state.done) {
+            state.done = true
+            cleanup()
+            reject(e)
+          }
+        },
+      }
+      function cleanup() {
+        signal?.removeEventListener('abort', onAbort)
+        const idx = senders.indexOf(task)
+        if (idx >= 0) {
+          senders.splice(idx, 1)
+        }
+      }
+      function onAbort() {
+        if (!state.done) {
+          state.done = true
+          cleanup()
+        }
+      }
+      if (signal?.aborted) {
+        return
+      }
+      signal?.addEventListener('abort', onAbort, { once: true })
+      this.senders.push(task)
     })
   }
 
@@ -530,6 +634,14 @@ class BufferedChannel<T> implements Channel<T> {
       this.receiversWithOk.length > 0
     )
   }
+
+  len(): number {
+    return this.buffer.length
+  }
+
+  cap(): number {
+    return this.capacity
+  }
 }
 
 /**
@@ -553,8 +665,14 @@ export interface ChannelRef<T> {
   close(): void
   canSendNonBlocking(): boolean
   canReceiveNonBlocking(): boolean
-  selectSend(value: T, id: number): Promise<SelectResult<boolean>>
-  selectReceive(id: number): Promise<SelectResult<T>>
+  selectSend(
+    value: T,
+    id: number,
+    signal?: AbortSignal,
+  ): Promise<SelectResult<boolean>>
+  selectReceive(id: number, signal?: AbortSignal): Promise<SelectResult<T>>
+  len(): number
+  cap(): number
 }
 
 /**
@@ -590,12 +708,24 @@ export class BidirectionalChannelRef<T> implements ChannelRef<T> {
     return this.channel.canReceiveNonBlocking()
   }
 
-  selectSend(value: T, id: number): Promise<SelectResult<boolean>> {
-    return this.channel.selectSend(value, id)
+  selectSend(
+    value: T,
+    id: number,
+    signal?: AbortSignal,
+  ): Promise<SelectResult<boolean>> {
+    return this.channel.selectSend(value, id, signal)
+  }
+
+  selectReceive(id: number, signal?: AbortSignal): Promise<SelectResult<T>> {
+    return this.channel.selectReceive(id, signal)
+  }
+
+  len(): number {
+    return this.channel.len()
   }
 
-  selectReceive(id: number): Promise<SelectResult<T>> {
-    return this.channel.selectReceive(id)
+  cap(): number {
+    return this.channel.cap()
   }
 }
 
@@ -621,8 +751,12 @@ export class SendOnlyChannelRef<T> implements ChannelRef<T> {
     return this.channel.canSendNonBlocking()
   }
 
-  selectSend(value: T, id: number): Promise<SelectResult<boolean>> {
-    return this.channel.selectSend(value, id)
+  selectSend(
+    value: T,
+    id: number,
+    signal?: AbortSignal,
+  ): Promise<SelectResult<boolean>> {
+    return this.channel.selectSend(value, id, signal)
   }
 
   // Disallow receive operations
@@ -638,9 +772,17 @@ export class SendOnlyChannelRef<T> implements ChannelRef<T> {
     return false
   }
 
-  selectReceive(_id: number): Promise<SelectResult<T>> {
+  selectReceive(_id: number, _signal?: AbortSignal): Promise<SelectResult<T>> {
     throw new Error('Cannot receive from send-only channel')
   }
+
+  len(): number {
+    return this.channel.len()
+  }
+
+  cap(): number {
+    return this.channel.cap()
+  }
 }
 
 /**
@@ -664,8 +806,8 @@ export class ReceiveOnlyChannelRef<T> implements ChannelRef<T> {
     return this.channel.canReceiveNonBlocking()
   }
 
-  selectReceive(id: number): Promise<SelectResult<T>> {
-    return this.channel.selectReceive(id)
+  selectReceive(id: number, signal?: AbortSignal): Promise<SelectResult<T>> {
+    return this.channel.selectReceive(id, signal)
   }
 
   // Disallow send operations
@@ -682,9 +824,21 @@ export class ReceiveOnlyChannelRef<T> implements ChannelRef<T> {
     return false
   }
 
-  selectSend(_value: T, _id: number): Promise<SelectResult<boolean>> {
+  selectSend(
+    _value: T,
+    _id: number,
+    _signal?: AbortSignal,
+  ): Promise<SelectResult<boolean>> {
     throw new Error('Cannot send to receive-only channel')
   }
+
+  len(): number {
+    return this.channel.len()
+  }
+
+  cap(): number {
+    return this.channel.cap()
+  }
 }
 
 /**

package/gs/builtin/defer.ts

@@ -51,8 +51,19 @@ export class AsyncDisposableStack implements AsyncDisposable {
    */
   async [Symbol.asyncDispose](): Promise<void> {
     // Execute in LIFO order, awaiting each potentially async function
-    for (let i = this.stack.length - 1; i >= 0; --i) {
-      await this.stack[i]()
+    while (this.stack.length) {
+      const fn = this.stack.pop()!
+      await fn()
+    }
+  }
+
+  [Symbol.dispose](): void {
+    while (this.stack.length) {
+      const fn = this.stack.pop()!
+      const result = fn()
+      if (result && typeof (result as Promise<void>).then === "function") {
+        throw new Error("async deferred function disposed synchronously")
+      }
     }
   }
 }

package/gs/builtin/hostio.test.ts

@@ -36,6 +36,7 @@ function runtimeFixture(platform: string): HostRuntime {
     deno: null,
     getEnv: () => '',
     getStdioHandle: () => null,
+    nodeCrypto: null,
     nodeFS: null,
     platform,
     processObj: null,

package/gs/builtin/hostio.ts

@@ -54,6 +54,16 @@ export type NodeFSModule = {
   ): void
 }
 
+export type NodeCryptoHash = {
+  copy?(): NodeCryptoHash
+  update(data: Uint8Array): NodeCryptoHash
+  digest(): Uint8Array
+}
+
+export type NodeCryptoModule = {
+  createHash(algorithm: string): NodeCryptoHash
+}
+
 export type DenoStream = {
   readSync?(buffer: Uint8Array): number | null
   writeSync?(buffer: Uint8Array): number
@@ -74,6 +84,7 @@ type HostTextWrite = (data: string) => void
 
 export type HostRuntime = {
   deno: any | null
+  nodeCrypto: NodeCryptoModule | null
   nodeFS: NodeFSModule | null
   platform: string
   processObj: any | null
@@ -166,6 +177,31 @@ function detectNodeFS(processObj: any | null): NodeFSModule | null {
   return null
 }
 
+function detectNodeCrypto(processObj: any | null): NodeCryptoModule | null {
+  if (processObj && typeof processObj.getBuiltinModule === 'function') {
+    const module = processObj.getBuiltinModule('crypto')
+    if (module && typeof module.createHash === 'function') {
+      return module as NodeCryptoModule
+    }
+  }
+
+  const requireFn = getDynamicRequire()
+  if (requireFn) {
+    for (const specifier of ['node:crypto', 'crypto']) {
+      try {
+        const module = requireFn(specifier) as NodeCryptoModule | null
+        if (module && typeof module.createHash === 'function') {
+          return module
+        }
+      } catch {
+        // Try the next fallback.
+      }
+    }
+  }
+
+  return null
+}
+
 function hasURLScheme(path: string): boolean {
   return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(path)
 }
@@ -247,6 +283,7 @@ function detectHostRuntime(): HostRuntime {
   const deno = globalObj.Deno ?? null
   const processObj = globalObj.process ?? null
   const nodeFS = detectNodeFS(processObj)
+  const nodeCrypto = detectNodeCrypto(processObj)
 
   const getStdioHandle = (fd: number): DenoFileLike | null => {
     if (!deno) {
@@ -344,6 +381,7 @@ function detectHostRuntime(): HostRuntime {
     deno,
     getEnv,
     getStdioHandle,
+    nodeCrypto,
     nodeFS,
     platform,
     processObj,

package/gs/builtin/map.ts

@@ -1,3 +1,6 @@
+import { comparableEqual } from './builtin.js'
+import { GoBinaryString, stringEqual } from './slice.js'
+
 /**
  * Creates a new map (TypeScript Map).
  * @returns A new TypeScript Map.
@@ -18,9 +21,9 @@ export function mapGet<K, V, D>(
   key: K,
   defaultValue: D,
 ): [V, true] | [D, false] {
-  const exists = map?.has(key)
-  if (exists) {
-    return [map!.get(key)!, true]
+  const entry = findMapEntry(map, key)
+  if (entry.found) {
+    return [entry.value, true]
   } else {
     return [defaultValue, false]
   }
@@ -36,7 +39,8 @@ export const mapSet = <K, V>(map: Map<K, V> | null, key: K, value: V): void => {
   if (!map) {
     throw new Error('assign to nil map')
   }
-  map.set(key, value)
+  const entry = findMapEntry(map, key)
+  map.set(entry.found ? entry.key : key, value)
 }
 
 /**
@@ -45,7 +49,10 @@ export const mapSet = <K, V>(map: Map<K, V> | null, key: K, value: V): void => {
  * @param key The key to delete.
  */
 export const deleteMapEntry = <K, V>(map: Map<K, V> | null, key: K): void => {
-  map?.delete(key)
+  const entry = findMapEntry(map, key)
+  if (entry.found) {
+    map!.delete(entry.key)
+  }
 }
 
 /**
@@ -55,5 +62,38 @@ export const deleteMapEntry = <K, V>(map: Map<K, V> | null, key: K): void => {
  * @returns True if the key exists, false otherwise.
  */
 export const mapHas = <K, V>(map: Map<K, V> | null, key: K): boolean => {
-  return map?.has(key) ?? false
+  return findMapEntry(map, key).found
+}
+
+function findMapEntry<K, V>(
+  map: Map<K, V> | null,
+  key: K,
+): { found: false } | { found: true; key: K; value: V } {
+  if (!map) {
+    return { found: false }
+  }
+  if (map.has(key)) {
+    return { found: true, key, value: map.get(key)! }
+  }
+  if (isGoStringKey(key)) {
+    for (const [candidate, value] of map.entries()) {
+      if (isGoStringKey(candidate) && stringEqual(candidate as string, key as string)) {
+        return { found: true, key: candidate, value }
+      }
+    }
+    return { found: false }
+  }
+  if (key === null || (typeof key !== 'object' && typeof key !== 'function')) {
+    return { found: false }
+  }
+  for (const [candidate, value] of map.entries()) {
+    if (candidate !== key && comparableEqual(candidate, key)) {
+      return { found: true, key: candidate, value }
+    }
+  }
+  return { found: false }
+}
+
+function isGoStringKey(value: unknown): value is string | GoBinaryString {
+  return typeof value === 'string' || value instanceof GoBinaryString
 }

package/gs/builtin/print.ts

@@ -68,7 +68,10 @@ function formatValue(
   try {
     if (value instanceof Map) {
       return formatArray(
-        Array.from(value.entries()).map(([k, v]) => `${formatValue(k, depth + 1, true, seen)} => ${formatValue(v, depth + 1, true, seen)}`),
+        Array.from(value.entries()).map(
+          ([k, v]) =>
+            `${formatValue(k, depth + 1, true, seen)} => ${formatValue(v, depth + 1, true, seen)}`,
+        ),
         depth,
         seen,
       )
@@ -113,7 +116,11 @@ function formatUint8Array(value: Uint8Array): string {
   return `Uint8Array(${value.length}) [ ${Array.from(value).join(', ')} ]`
 }
 
-function formatArray(value: readonly any[], depth: number, seen: WeakSet<object>): string {
+function formatArray(
+  value: readonly any[],
+  depth: number,
+  seen: WeakSet<object>,
+): string {
   if (value.length === 0) {
     return '[]'
   }
@@ -150,5 +157,7 @@ function getObjectEntries(value: Record<string, any>): [string, any][] {
     })
   }
 
-  return Object.entries(value).filter(([, entry]) => typeof entry !== 'function')
+  return Object.entries(value).filter(
+    ([, entry]) => typeof entry !== 'function',
+  )
 }