goscript 0.0.23 → 0.0.25

package/compiler/stmt.go

@@ -28,6 +28,8 @@ import (
 //   - Go statements (`ast.GoStmt`): `WriteStmtGo`.
 //   - Select statements (`ast.SelectStmt`): `WriteStmtSelect`.
 //   - Branch statements (`ast.BranchStmt`): `WriteStmtBranch`.
+//   - Type switch statements (`ast.TypeSwitchStmt`): `WriteStmtTypeSwitch`.
+//   - Labeled statements (`ast.LabeledStmt`): `WriteStmtLabeled`.
 //
 // If an unknown statement type is encountered, it returns an error.
 func (c *GoToTSCompiler) WriteStmt(a ast.Stmt) error {
@@ -109,6 +111,10 @@ func (c *GoToTSCompiler) WriteStmt(a ast.Stmt) error {
 		if err := c.WriteStmtTypeSwitch(exp); err != nil {
 			return fmt.Errorf("failed to write type switch statement: %w", err)
 		}
+	case *ast.LabeledStmt:
+		if err := c.WriteStmtLabeled(exp); err != nil {
+			return fmt.Errorf("failed to write labeled statement: %w", err)
+		}
 	default:
 		return errors.Errorf("unknown statement: %#v\n", a)
 	}
@@ -292,6 +298,37 @@ func (c *GoToTSCompiler) WriteStmtGo(exp *ast.GoStmt) error {
 		c.tsw.WriteLiterally(")")
 		c.tsw.WriteLine("")
 
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("})") // Close the queueMicrotask callback and the statement
+	case *ast.TypeAssertExpr:
+		// Handle type assertion expressions: go x.(func())()
+		// We assume this is always synchronous (no async function returned by type assertion)
+		c.tsw.WriteLiterally("queueMicrotask(() => {")
+
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+
+		// Write the type assertion call
+		if err := c.WriteTypeAssertExpr(fun); err != nil {
+			return fmt.Errorf("failed to write type assertion expression in goroutine: %w", err)
+		}
+
+		// Add non-null assertion since mustTypeAssert throws on failure rather than returning null
+		c.tsw.WriteLiterally("!")
+
+		// Write the function arguments
+		c.tsw.WriteLiterally("(")
+		for i, arg := range callExpr.Args {
+			if i != 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			if err := c.WriteValueExpr(arg); err != nil {
+				return fmt.Errorf("failed to write argument %d in goroutine type assertion function call: %w", i, err)
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		c.tsw.WriteLine("")
+
 		c.tsw.Indent(-1)
 		c.tsw.WriteLine("})") // Close the queueMicrotask callback and the statement
 	default:
@@ -790,3 +827,18 @@ func (c *GoToTSCompiler) WriteStmtDefer(exp *ast.DeferStmt) error {
 
 	return nil
 }
+
+// WriteStmtLabeled handles labeled statements (ast.LabeledStmt), such as "label: statement".
+// In TypeScript, this translates to "label: statement" directly.
+func (c *GoToTSCompiler) WriteStmtLabeled(stmt *ast.LabeledStmt) error {
+	// Write the label name followed by a colon
+	c.tsw.WriteLiterally(stmt.Label.Name)
+	c.tsw.WriteLiterally(": ")
+
+	// Write the labeled statement
+	if err := c.WriteStmt(stmt.Stmt); err != nil {
+		return fmt.Errorf("failed to write labeled statement: %w", err)
+	}
+
+	return nil
+}

package/compiler/type.go

@@ -16,7 +16,7 @@ const (
 	GoTypeContextGeneral GoTypeContext = iota
 	// GoTypeContextFunctionReturn is used when translating types for function return values.
 	// In this context, pointer-to-struct types become `ClassName | null` instead of
-	// `$.Box<ClassName> | null` because function return values cannot be addressed.
+	// `$.VarRef<ClassName> | null` because function return values cannot be addressed.
 	GoTypeContextFunctionReturn
 )
 
@@ -27,7 +27,7 @@ const (
 // The context parameter controls how certain types (especially pointers) are handled:
 //   - GoTypeContextGeneral: Standard type translation
 //   - GoTypeContextFunctionReturn: Special handling for function return types where
-//     pointer-to-struct types become `ClassName | null` instead of `$.Box<ClassName> | null`
+//     pointer-to-struct types become `ClassName | null` instead of `$.VarRef<ClassName> | null`
 //
 // It handles nil types as 'any' with a comment, and dispatches to appropriate
 // type-specific writers for all other recognized Go types.
@@ -47,7 +47,7 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type, context GoTypeContext) {
 		if context == GoTypeContextFunctionReturn {
 			c.writePointerTypeForFunctionReturn(t)
 		} else {
-			c.WritePointerType(t)
+			c.WritePointerType(t, context)
 		}
 	case *types.Slice:
 		c.WriteSliceType(t)
@@ -68,6 +68,15 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type, context GoTypeContext) {
 	case *types.TypeParam:
 		// For type parameters, write the type parameter name (e.g., "T", "K", etc.)
 		c.tsw.WriteLiterally(t.Obj().Name())
+	case *types.Union:
+		// Handle union types (e.g., string | []byte)
+		for i := 0; i < t.Len(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(" | ")
+			}
+			term := t.Term(i)
+			c.WriteGoType(term.Type(), context)
+		}
 	default:
 		// For other types, just write "any" and add a comment
 		c.tsw.WriteLiterally("any")
@@ -78,7 +87,7 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type, context GoTypeContext) {
 // writePointerTypeForFunctionReturn translates a Go pointer type (*T) to its TypeScript
 // equivalent for function return types. Unlike WritePointerType, this function
 // handles pointer-to-struct types specially: they become `ClassName | null` instead
-// of `$.Box<ClassName> | null` because function return values cannot be addressed.
+// of `$.VarRef<ClassName> | null` because function return values cannot be addressed.
 func (c *GoToTSCompiler) writePointerTypeForFunctionReturn(t *types.Pointer) {
 	elemType := t.Elem()
 
@@ -93,8 +102,8 @@ func (c *GoToTSCompiler) writePointerTypeForFunctionReturn(t *types.Pointer) {
 		c.WriteGoType(elemType, GoTypeContextFunctionReturn)
 		c.tsw.WriteLiterally(" | null")
 	} else {
-		// For pointer-to-primitive in function returns, still use boxing
-		c.tsw.WriteLiterally("$.Box<")
+		// For pointer-to-primitive in function returns, still use varRefing
+		c.tsw.WriteLiterally("$.VarRef<")
 		c.WriteGoType(elemType, GoTypeContextFunctionReturn)
 		c.tsw.WriteLiterally("> | null")
 	}
@@ -202,7 +211,8 @@ func (c *GoToTSCompiler) WriteBasicType(t *types.Basic) {
 
 // WriteNamedType translates a Go named type to its TypeScript equivalent.
 // It specially handles the error interface as $.GoError, and uses the original
-// type name for other named types. For generic types, it includes type arguments.
+// type name for other named types. For imported types, it writes the qualified
+// name using the import alias found from the analysis imports. For generic types, it includes type arguments.
 func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 	// Check if the named type is the error interface
 	if iface, ok := t.Underlying().(*types.Interface); ok && iface.String() == "interface{Error() string}" {
@@ -210,7 +220,40 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 		return
 	}
 
-	// Use Obj().Name() for the original defined name
+	// Check if this type is from an imported package
+	typePkg := t.Obj().Pkg()
+	if typePkg != nil && typePkg != c.pkg.Types {
+		// This type is from an imported package, find the import alias
+		typePkgPath := typePkg.Path()
+
+		// Try to find the import alias by matching the package path
+		for importAlias, _ := range c.analysis.Imports {
+			// The importAlias could be either the explicit alias or the default package name
+			// If it's the default package name, it should match the last segment of the path
+			defaultPkgName := packageNameFromGoPath(typePkgPath)
+			if importAlias == defaultPkgName || importAlias == typePkgPath {
+				// Write the qualified name: importAlias.TypeName
+				c.tsw.WriteLiterally(importAlias)
+				c.tsw.WriteLiterally(".")
+				c.tsw.WriteLiterally(t.Obj().Name())
+
+				// For generic types, include type arguments
+				if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {
+					c.tsw.WriteLiterally("<")
+					for i := 0; i < t.TypeArgs().Len(); i++ {
+						if i > 0 {
+							c.tsw.WriteLiterally(", ")
+						}
+						c.WriteGoType(t.TypeArgs().At(i), GoTypeContextGeneral)
+					}
+					c.tsw.WriteLiterally(">")
+				}
+				return
+			}
+		}
+	}
+
+	// Use Obj().Name() for the original defined name (local types or unmatched imports)
 	c.tsw.WriteLiterally(t.Obj().Name())
 
 	// For generic types, include type arguments
@@ -227,11 +270,36 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 }
 
 // WritePointerType translates a Go pointer type (*T) to its TypeScript equivalent.
-// It generates $.Box<T_ts> | null, where T_ts is the translated element type.
-func (c *GoToTSCompiler) WritePointerType(t *types.Pointer) {
-	c.tsw.WriteLiterally("$.Box<")
-	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
-	c.tsw.WriteLiterally("> | null") // Pointers are always nullable
+func (c *GoToTSCompiler) WritePointerType(t *types.Pointer, context GoTypeContext) {
+	elemGoType := t.Elem()
+	underlyingElemGoType := elemGoType.Underlying()
+
+	// Handle pointers to functions: *func(...) -> func(...) | null
+	if _, isSignature := underlyingElemGoType.(*types.Signature); isSignature {
+		c.WriteGoType(elemGoType, context) // Write the function signature itself, pass context
+		c.tsw.WriteLiterally(" | null")    // Function pointers are nullable
+		return
+	}
+
+	// Handle pointers to structs or interfaces: *MyStruct -> MyStruct | null
+	_, isStruct := underlyingElemGoType.(*types.Struct)
+	_, isInterface := underlyingElemGoType.(*types.Interface)
+
+	if isStruct || isInterface {
+		// For pointers to structs or interfaces, the TS type is StructName | null or InterfaceName | null.
+		// This aligns with VAR_REFS.md and JS/TS object reference semantics.
+		// TODO If the target variable is boxed, we have to wrap with VarRef as well?
+		c.WriteGoType(elemGoType, context) // Write the struct/interface type directly, pass context
+		c.tsw.WriteLiterally(" | null")
+	} else {
+		// For pointers to other types (primitives, slices, maps, other pointers like **MyStruct),
+		// they are generally represented as $.VarRef<T_ts> | null.
+		// Example: *int -> $.VarRef<number> | null
+		// Example: **MyStruct -> $.VarRef<MyStruct | null> | null (recursive call handles inner part)
+		c.tsw.WriteLiterally("$.VarRef<")
+		c.WriteGoType(elemGoType, context) // Translate element type, pass context
+		c.tsw.WriteLiterally("> | null")   // Pointers are always nullable
+	}
 }
 
 // WriteSliceType translates a Go slice type ([]T) to its TypeScript equivalent.
@@ -363,7 +431,7 @@ func (c *GoToTSCompiler) WriteSignatureType(t *types.Signature) {
 
 		// Use parameter name if available, otherwise use p0, p1, etc.
 		if param.Name() != "" {
-			c.tsw.WriteLiterally(param.Name())
+			c.tsw.WriteLiterally(c.sanitizeIdentifier(param.Name()))
 		} else {
 			c.tsw.WriteLiterallyf("p%d", i)
 		}
@@ -458,7 +526,7 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 				if paramName == "" || paramName == "_" {
 					paramName = fmt.Sprintf("_p%d", j)
 				}
-				c.tsw.WriteLiterally(paramName)
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(paramName))
 				c.tsw.WriteLiterally(": ")
 				c.WriteGoType(paramVar.Type(), GoTypeContextGeneral) // Recursive call for param type
 			}

package/dist/gs/builtin/builtin.d.ts

@@ -0,0 +1,9 @@
+export * from './varRef.js';
+export * from './channel.js';
+export * from './defer.js';
+export * from './io.js';
+export * from './map.js';
+export * from './slice.js';
+export * from './type.js';
+export declare function copy<T>(dst: T[], src: T[]): number;
+export declare function multiplyDuration(duration: any, multiplier: number): any;

package/dist/gs/builtin/builtin.js

@@ -0,0 +1,46 @@
+export * from './varRef.js';
+export * from './channel.js';
+export * from './defer.js';
+export * from './io.js';
+export * from './map.js';
+export * from './slice.js';
+export * from './type.js';
+// Copy is the Go builtin function that copies the contents of one slice to another.
+// It returns the number of elements copied.
+export function copy(dst, src) {
+    const n = Math.min(dst.length, src.length);
+    for (let i = 0; i < n; i++) {
+        dst[i] = src[i];
+    }
+    return n;
+}
+// Duration multiplication helper for time package operations
+// Handles expressions like time.Hour * 24
+export function multiplyDuration(duration, multiplier) {
+    // Check if duration has a multiply method (like our Duration class)
+    if (duration && typeof duration.multiply === 'function') {
+        return duration.multiply(multiplier);
+    }
+    // Check if duration has a valueOf method for numeric operations
+    if (duration && typeof duration.valueOf === 'function') {
+        const numValue = duration.valueOf();
+        // Return an object with the same structure but multiplied value
+        if (typeof numValue === 'number') {
+            // Try to create a new instance of the same type
+            if (duration.constructor) {
+                return new duration.constructor(numValue * multiplier);
+            }
+            // Fallback: return a simple object with valueOf
+            return {
+                valueOf: () => numValue * multiplier,
+                toString: () => (numValue * multiplier).toString() + "ns"
+            };
+        }
+    }
+    // Fallback for simple numeric values
+    if (typeof duration === 'number') {
+        return duration * multiplier;
+    }
+    throw new Error(`Cannot multiply duration of type ${typeof duration}`);
+}
+//# sourceMappingURL=builtin.js.map

package/dist/gs/builtin/builtin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.js","sourceRoot":"","sources":["../../../gs/builtin/builtin.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AAEzB,oFAAoF;AACpF,4CAA4C;AAC5C,MAAM,UAAU,IAAI,CAAI,GAAQ,EAAE,GAAQ;IACxC,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED,6DAA6D;AAC7D,0CAA0C;AAC1C,MAAM,UAAU,gBAAgB,CAAC,QAAa,EAAE,UAAkB;IAChE,oEAAoE;IACpE,IAAI,QAAQ,IAAI,OAAO,QAAQ,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;QACxD,OAAO,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IACvC,CAAC;IAED,gEAAgE;IAChE,IAAI,QAAQ,IAAI,OAAO,QAAQ,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QACvD,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,EAAE,CAAC;QACpC,gEAAgE;QAChE,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;YACjC,gDAAgD;YAChD,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;gBACzB,OAAO,IAAI,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC;YACzD,CAAC;YACD,gDAAgD;YAChD,OAAO;gBACL,OAAO,EAAE,GAAG,EAAE,CAAC,QAAQ,GAAG,UAAU;gBACpC,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,QAAQ,EAAE,GAAG,IAAI;aAC1D,CAAC;QACJ,CAAC;IACH,CAAC;IAED,qCAAqC;IACrC,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjC,OAAO,QAAQ,GAAG,UAAU,CAAC;IAC/B,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,oCAAoC,OAAO,QAAQ,EAAE,CAAC,CAAC;AACzE,CAAC"}

package/dist/gs/builtin/channel.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Represents the result of a channel receive operation with 'ok' value
+ */
+export interface ChannelReceiveResult<T> {
+    value: T;
+    ok: boolean;
+}
+/**
+ * Represents a result from a select operation
+ */
+export interface SelectResult<T> {
+    value: T;
+    ok: boolean;
+    id: number;
+}
+/**
+ * Represents a Go channel in TypeScript.
+ * Supports asynchronous sending and receiving of values.
+ */
+export interface Channel<T> {
+    /**
+     * Sends a value to the channel.
+     * Returns a promise that resolves when the value is accepted by the channel.
+     * @param value The value to send.
+     */
+    send(value: T): Promise<void>;
+    /**
+     * Receives a value from the channel.
+     * Returns a promise that resolves with the received value.
+     * If the channel is closed, it throws an error.
+     */
+    receive(): Promise<T>;
+    /**
+     * Receives a value from the channel along with a boolean indicating
+     * whether the channel is still open.
+     * Returns a promise that resolves with {value, ok}.
+     * - If channel is open and has data: {value: <data>, ok: true}
+     * - If channel is closed and empty: {value: <zero value>, ok: false}
+     * - If channel is closed but has remaining buffered data: {value: <data>, ok: true}
+     */
+    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
+    /**
+     * Closes the channel.
+     * No more values can be sent to a closed channel.
+     * Receive operations on a closed channel return the zero value and ok=false.
+     */
+    close(): void;
+    /**
+     * Used in select statements to create a receive operation promise.
+     * @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>>;
+    /**
+     * Used in select statements to create a send operation promise.
+     * @param value The value to send
+     * @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>>;
+    /**
+     * Checks if the channel has data ready to be received without blocking.
+     * Used for non-blocking select operations.
+     */
+    canReceiveNonBlocking(): boolean;
+    /**
+     * Checks if the channel can accept a send operation without blocking.
+     * Used for non-blocking select operations.
+     */
+    canSendNonBlocking(): boolean;
+}
+/**
+ * Represents a case in a select statement.
+ */
+export interface SelectCase<T> {
+    id: number;
+    isSend: boolean;
+    channel: Channel<any> | ChannelRef<any> | null;
+    value?: any;
+    onSelected?: (result: SelectResult<T>) => Promise<void>;
+}
+/**
+ * Helper for 'select' statements. Takes an array of select cases
+ * and resolves when one of them completes, following Go's select rules.
+ *
+ * @param cases Array of SelectCase objects
+ * @param hasDefault Whether there is a default case
+ * @returns A promise that resolves with the result of the selected case
+ */
+export declare function selectStatement<T>(cases: SelectCase<T>[], hasDefault?: boolean): Promise<void>;
+/**
+ * Helper function for channel send operations that handles nil channels correctly.
+ * In Go, sending to a nil channel blocks forever.
+ * @param channel The channel to send to (can be null)
+ * @param value The value to send
+ * @returns Promise that never resolves if channel is null, otherwise delegates to channel.send()
+ */
+export declare function chanSend<T>(channel: Channel<T> | ChannelRef<T> | null, value: T): Promise<void>;
+/**
+ * Helper function for channel receive operations that handles nil channels correctly.
+ * In Go, receiving from a nil channel blocks forever.
+ * @param channel The channel to receive from (can be null)
+ * @returns Promise that never resolves if channel is null, otherwise delegates to channel.receive()
+ */
+export declare function chanRecv<T>(channel: Channel<T> | ChannelRef<T> | null): Promise<T>;
+/**
+ * Helper function for channel receive operations with ok value that handles nil channels correctly.
+ * In Go, receiving from a nil channel blocks forever.
+ * @param channel The channel to receive from (can be null)
+ * @returns Promise that never resolves if channel is null, otherwise delegates to channel.receiveWithOk()
+ */
+export declare function chanRecvWithOk<T>(channel: Channel<T> | ChannelRef<T> | null): Promise<ChannelReceiveResult<T>>;
+/**
+ * Creates a new channel with the specified buffer size and zero value.
+ * @param bufferSize The size of the channel buffer. If 0, creates an unbuffered channel.
+ * @param zeroValue The zero value for the channel's element type.
+ * @param direction Optional direction for the channel. Default is 'both' (bidirectional).
+ * @returns A new channel instance or channel reference.
+ */
+export declare const makeChannel: <T>(bufferSize: number, zeroValue: T, direction?: "send" | "receive" | "both") => Channel<T> | ChannelRef<T>;
+/**
+ * Represents a reference to a channel with a specific direction.
+ */
+export interface ChannelRef<T> {
+    /**
+     * The underlying channel
+     */
+    channel: Channel<T>;
+    /**
+     * The direction of this channel reference
+     */
+    direction: 'send' | 'receive' | 'both';
+    send(value: T): Promise<void>;
+    receive(): Promise<T>;
+    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
+    close(): void;
+    canSendNonBlocking(): boolean;
+    canReceiveNonBlocking(): boolean;
+    selectSend(value: T, id: number): Promise<SelectResult<boolean>>;
+    selectReceive(id: number): Promise<SelectResult<T>>;
+}
+/**
+ * A bidirectional channel reference.
+ */
+export declare class BidirectionalChannelRef<T> implements ChannelRef<T> {
+    channel: Channel<T>;
+    direction: 'both';
+    constructor(channel: Channel<T>);
+    send(value: T): Promise<void>;
+    receive(): Promise<T>;
+    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
+    close(): void;
+    canSendNonBlocking(): boolean;
+    canReceiveNonBlocking(): boolean;
+    selectSend(value: T, id: number): Promise<SelectResult<boolean>>;
+    selectReceive(id: number): Promise<SelectResult<T>>;
+}
+/**
+ * A send-only channel reference.
+ */
+export declare class SendOnlyChannelRef<T> implements ChannelRef<T> {
+    channel: Channel<T>;
+    direction: 'send';
+    constructor(channel: Channel<T>);
+    send(value: T): Promise<void>;
+    close(): void;
+    canSendNonBlocking(): boolean;
+    selectSend(value: T, id: number): Promise<SelectResult<boolean>>;
+    receive(): Promise<T>;
+    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
+    canReceiveNonBlocking(): boolean;
+    selectReceive(id: number): Promise<SelectResult<T>>;
+}
+/**
+ * A receive-only channel reference.
+ */
+export declare class ReceiveOnlyChannelRef<T> implements ChannelRef<T> {
+    channel: Channel<T>;
+    direction: 'receive';
+    constructor(channel: Channel<T>);
+    receive(): Promise<T>;
+    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
+    canReceiveNonBlocking(): boolean;
+    selectReceive(id: number): Promise<SelectResult<T>>;
+    send(value: T): Promise<void>;
+    close(): void;
+    canSendNonBlocking(): boolean;
+    selectSend(value: T, id: number): Promise<SelectResult<boolean>>;
+}
+/**
+ * Creates a new channel reference with the specified direction.
+ */
+export declare function makeChannelRef<T>(channel: Channel<T>, direction: 'send' | 'receive' | 'both'): ChannelRef<T>;