goscript 0.0.50 → 0.0.52

package/gs/builtin/channel.ts

@@ -88,7 +88,7 @@ export interface SelectCase<T> {
   channel: Channel<any> | ChannelRef<any> | null // Allow null and ChannelRef
   value?: any // Value to send for send cases
   // Optional handlers for when this case is selected
-  onSelected?: (result: SelectResult<T>) => Promise<void>
+  onSelected?: (result: SelectResult<T>) => Promise<any>
 }
 
 /**
@@ -99,14 +99,14 @@ export interface SelectCase<T> {
  * @param hasDefault Whether there is a default case
  * @returns A promise that resolves with the result of the selected case
  */
-export async function selectStatement<T>(
+export async function selectStatement<T, V = void>(
   cases: SelectCase<T>[],
   hasDefault: boolean = false,
-): Promise<void> {
+): Promise<[boolean, V]> {
   if (cases.length === 0 && !hasDefault) {
     // Go spec: If there are no cases, the select statement blocks forever.
     // Emulate blocking forever with a promise that never resolves.
-    return new Promise<void>(() => {}) // Promise never resolves
+    return new Promise<[boolean, V]>(() => {}) // Promise never resolves
   }
 
   // 1. Check for ready (non-blocking) operations
@@ -143,19 +143,23 @@ export async function selectStatement<T>(
           selectedCase.id,
         )
         if (selectedCase.onSelected) {
-          await selectedCase.onSelected(result as SelectResult<T>) // Await the handler
+          const handlerResult = await selectedCase.onSelected(
+            result as SelectResult<T>,
+          )
+          return [handlerResult !== undefined, handlerResult as V]
         }
       } else {
         const result = await selectedCase.channel.selectReceive(selectedCase.id)
         if (selectedCase.onSelected) {
-          await selectedCase.onSelected(result) // Await the handler
+          const handlerResult = await selectedCase.onSelected(result)
+          return [handlerResult !== undefined, handlerResult as V]
         }
       }
     } else {
       // This case should ideally not happen if channel is required for non-default cases
       console.error('Selected case without a channel:', selectedCase)
     }
-    return // Return after executing a ready case
+    return [false, undefined as V] // Return after executing a ready case
   }
 
   // 2. If no operations are ready and there's a default case, select default
@@ -164,13 +168,14 @@ export async function selectStatement<T>(
     const defaultCase = cases.find((c) => c.id === -1)
     if (defaultCase && defaultCase.onSelected) {
       // Execute the onSelected handler for the default case
-      await defaultCase.onSelected({
+      const handlerResult = await defaultCase.onSelected({
         value: undefined,
         ok: false,
         id: -1,
-      } as SelectResult<T>) // Await the handler
+      } as SelectResult<T>)
+      return [handlerResult !== undefined, handlerResult as V]
     }
-    return // Return after executing the default case
+    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
@@ -190,16 +195,19 @@ export async function selectStatement<T>(
   // If all non-default cases have nil channels, we effectively block forever
   if (blockingPromises.length === 0) {
     // No valid channels to operate on, block forever (unless there's a default)
-    return new Promise<void>(() => {}) // Promise never resolves
+    return new Promise<[boolean, V]>(() => {}) // Promise never resolves
   }
 
   const result = await Promise.race(blockingPromises)
   // Execute onSelected handler for the selected case
   const selectedCase = cases.find((c) => c.id === result.id)
   if (selectedCase && selectedCase.onSelected) {
-    await selectedCase.onSelected(result) // Await the handler
+    const handlerResult = await selectedCase.onSelected(result)
+    return [handlerResult !== undefined, handlerResult as V]
   }
+
   // No explicit return needed here, as the function will implicitly return after the await
+  return [false, undefined as V]
 }
 
 /**
@@ -259,18 +267,32 @@ export async function chanRecvWithOk<T>(
  * @param direction Optional direction for the channel. Default is 'both' (bidirectional).
  * @returns A new channel instance or channel reference.
  */
-export const makeChannel = <T>(
+export function makeChannel<T>(
+  bufferSize: number,
+  zeroValue: T,
+  direction: 'send',
+): SendOnlyChannelRef<T>
+export function makeChannel<T>(
+  bufferSize: number,
+  zeroValue: T,
+  direction: 'receive',
+): ReceiveOnlyChannelRef<T>
+export function makeChannel<T>(
+  bufferSize: number,
+  zeroValue: T,
+  direction?: 'both',
+): Channel<T>
+export function makeChannel<T>(
   bufferSize: number,
   zeroValue: T,
   direction: 'send' | 'receive' | 'both' = 'both',
-): Channel<T> | ChannelRef<T> => {
+): Channel<T> | ChannelRef<T> {
   const channel = new BufferedChannel<T>(bufferSize, zeroValue)
 
-  // Wrap the channel with the appropriate ChannelRef based on direction
   if (direction === 'send') {
-    return new SendOnlyChannelRef<T>(channel) as ChannelRef<T>
+    return new SendOnlyChannelRef<T>(channel)
   } else if (direction === 'receive') {
-    return new ReceiveOnlyChannelRef<T>(channel) as ChannelRef<T>
+    return new ReceiveOnlyChannelRef<T>(channel)
   } else {
     return channel
   }

package/gs/context/context.ts

@@ -343,7 +343,7 @@ export function WithTimeout(
   parent: Context,
   timeout: number,
 ): [ContextNonNil, CancelFunc] {
-  return WithDeadline(parent, new Date(Date.now() + timeout))
+  return WithDeadline(parent, new Date(Date.now() + timeout / 1000000))
 }
 
 // WithTimeoutCause is like WithTimeout but also sets the cause
@@ -352,7 +352,11 @@ export function WithTimeoutCause(
   timeout: number,
   cause: $.GoError,
 ): [ContextNonNil, CancelFunc] {
-  return WithDeadlineCause(parent, new Date(Date.now() + timeout), cause)
+  return WithDeadlineCause(
+    parent,
+    new Date(Date.now() + timeout / 1000000),
+    cause,
+  )
 }
 
 // WithValue returns a copy of parent with the value associated with key

package/gs/context/meta.json

@@ -0,0 +1,16 @@
+{
+  "asyncMethods": {
+    "Background": false,
+    "TODO": false,
+    "WithCancel": false,
+    "WithCancelCause": false,
+    "WithDeadline": false,
+    "WithDeadlineCause": false,
+    "WithTimeout": false,
+    "WithTimeoutCause": false,
+    "WithValue": false,
+    "WithoutCancel": false,
+    "Cause": false,
+    "AfterFunc": false
+  }
+} 

package/gs/runtime/runtime.ts

@@ -3,7 +3,7 @@ export const GOOS = 'js'
 export const GOARCH = 'wasm'
 
 // Version returns the Go version as a string
-export const GOVERSION = 'go1.24.3'
+export const GOVERSION = 'go1.24.4'
 export function Version(): string {
   return GOVERSION
 }

package/gs/syscall/constants.ts

@@ -0,0 +1,29 @@
+// Essential syscall constants
+export const O_RDONLY = 0
+export const O_WRONLY = 1
+export const O_RDWR = 2
+export const O_APPEND = 8
+export const O_CREATE = 64
+export const O_EXCL = 128
+export const O_SYNC = 256
+export const O_TRUNC = 512
+
+export const Stdin = 0
+export const Stdout = 1
+export const Stderr = 2
+
+export const SIGINT = 2
+export const SIGTERM = 15
+
+// File mode constants
+export const S_IFMT = 0o170000
+export const S_IFREG = 0o100000
+export const S_IFDIR = 0o040000
+export const S_IFLNK = 0o120000
+export const S_IFBLK = 0o060000
+export const S_IFCHR = 0o020000
+export const S_IFIFO = 0o010000
+export const S_IFSOCK = 0o140000
+export const S_ISUID = 0o004000
+export const S_ISGID = 0o002000
+export const S_ISVTX = 0o001000

package/gs/syscall/env.ts

@@ -0,0 +1,47 @@
+import * as $ from '@goscript/builtin/index.js'
+
+// Environment variable functions using Node.js/browser APIs
+export function Getenv(key: string): [string, boolean] {
+  if (typeof process !== 'undefined' && process.env) {
+    const value = process.env[key]
+    return value !== undefined ? [value, true] : ['', false]
+  }
+  return ['', false]
+}
+
+export function Setenv(key: string, value: string): $.GoError {
+  if (typeof process !== 'undefined' && process.env) {
+    process.env[key] = value
+    return null
+  }
+  return { Error: () => 'setenv not supported' }
+}
+
+export function Unsetenv(key: string): $.GoError {
+  if (typeof process !== 'undefined' && process.env) {
+    delete process.env[key]
+    return null
+  }
+  return { Error: () => 'unsetenv not supported' }
+}
+
+export function Clearenv(): void {
+  if (typeof process !== 'undefined' && process.env) {
+    for (const key in process.env) {
+      delete process.env[key]
+    }
+  }
+}
+
+export function Environ(): $.Slice<string> {
+  if (typeof process !== 'undefined' && process.env) {
+    const env: string[] = []
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== undefined) {
+        env.push(`${key}=${value}`)
+      }
+    }
+    return $.arrayToSlice(env)
+  }
+  return $.arrayToSlice([])
+}