goscript 0.0.13 → 0.0.16

package/builtin/builtin.ts

@@ -1,44 +1,235 @@
 /**
- * Creates a new slice (TypeScript array) with the specified length and capacity.
- * @param len The length of the slice.
- * @param cap The capacity of the slice (optional).
- * @returns A new TypeScript array representing the slice.
+ * GoSliceObject contains metadata for complex slice views
  */
-export const makeSlice = <T>(
-  len: number,
-  cap?: number,
-): Array<T> & { __capacity?: number } => {
-  const slice = new Array<T>(len) as Array<T> & { __capacity?: number }
-  slice.__capacity = cap !== undefined ? cap : len
-  return slice
+interface GoSliceObject<T> {
+  backing: T[] // The backing array
+  offset: number // Offset into the backing array
+  length: number // Length of the slice
+  capacity: number // Capacity of the slice
 }
 
 /**
- * Creates a new slice header that shares the backing array.
+ * SliceProxy is a proxy object for complex slices
+ */
+export type SliceProxy<T> = T[] & {
+  __meta__: GoSliceObject<T>
+}
+
+/**
+ * Slice<T> is a union type that is either a plain array or a proxy
+ * null represents the nil state.
+ */
+export type Slice<T> = T[] | SliceProxy<T> | null
+
+export function asArray<T>(slice: Slice<T>): T[] {
+  return slice as T[]
+}
+
+/**
+ * isComplexSlice checks if a slice is a complex slice (has __meta__ property)
+ */
+function isComplexSlice<T>(slice: Slice<T>): slice is SliceProxy<T> {
+  return (
+    slice !== null &&
+    slice !== undefined &&
+    '__meta__' in slice &&
+    slice.__meta__ !== undefined
+  )
+}
+
+/**
+ * Creates a new slice with the specified length and capacity.
+ * @param length The length of the slice.
+ * @param capacity The capacity of the slice (optional).
+ * @returns A new slice.
+ */
+export const makeSlice = <T>(length: number, capacity?: number): Slice<T> => {
+  if (capacity === undefined) {
+    capacity = length
+  }
+
+  if (length < 0 || capacity < 0 || length > capacity) {
+    throw new Error(
+      `Invalid slice length (${length}) or capacity (${capacity})`,
+    )
+  }
+
+  const arr = new Array<T>(length)
+
+  // Always create a complex slice with metadata to preserve capacity information
+  const proxy = arr as SliceProxy<T>
+  proxy.__meta__ = {
+    backing: new Array<T>(capacity),
+    offset: 0,
+    length: length,
+    capacity: capacity,
+  }
+
+  for (let i = 0; i < length; i++) {
+    proxy.__meta__.backing[i] = arr[i]
+  }
+
+  return proxy
+}
+
+/**
+ * goSlice creates a slice from s[low:high:max]
  * Arguments mirror Go semantics; omitted indices are undefined.
  *
- * @param arr  The original slice/array produced by makeSlice or another slice
- * @param low  Starting index (defaults to 0)
- * @param high Ending index (defaults to arr.length)
- * @param max  Capacity limit (defaults to original capacity)
+ * @param s The original slice
+ * @param low Starting index (defaults to 0)
+ * @param high Ending index (defaults to s.length)
+ * @param max Capacity limit (defaults to original capacity)
  */
-export const slice = <T>(
-  arr: Array<T> & { __capacity?: number },
+export const goSlice = <T>(
+  s: Slice<T>,
   low?: number,
   high?: number,
   max?: number,
-): Array<T> & { __capacity?: number } => {
-  const start = low ?? 0
-  const origLen = arr.length
-  const origCap = arr.__capacity !== undefined ? arr.__capacity : origLen
-  const end = high !== undefined ? high : origLen
-  const newCap = max !== undefined ? max - start : origCap - start
+): Slice<T> => {
+  if (s === null || s === undefined) {
+    throw new Error('Cannot slice nil')
+  }
+
+  const slen = len(s)
+  low = low ?? 0
+  high = high ?? slen
+
+  if (low < 0 || high < low) {
+    throw new Error(`Invalid slice indices: ${low}:${high}`)
+  }
+
+  // In Go, high can be up to capacity, not just length
+  const scap = cap(s)
+  if (high > scap) {
+    throw new Error(`Slice index out of range: ${high} > ${scap}`)
+  }
+
+  if (
+    Array.isArray(s) &&
+    !isComplexSlice(s) &&
+    low === 0 &&
+    high === s.length &&
+    max === undefined
+  ) {
+    return s
+  }
 
-  const newArr = arr.slice(start, end) as Array<T> & {
-    __capacity?: number
+  let backing: T[]
+  let oldOffset = 0
+  let oldCap = scap
+
+  // Get the backing array and offset
+  if (isComplexSlice(s)) {
+    backing = s.__meta__.backing
+    oldOffset = s.__meta__.offset
+    oldCap = s.__meta__.capacity
+  } else {
+    backing = s as T[]
   }
-  newArr.__capacity = newCap
-  return newArr
+
+  let newCap
+  if (max !== undefined) {
+    if (max < high) {
+      throw new Error(`Invalid slice indices: ${low}:${high}:${max}`)
+    }
+    if (isComplexSlice(s) && max > oldOffset + oldCap) {
+      throw new Error(
+        `Slice index out of range: ${max} > ${oldOffset + oldCap}`,
+      )
+    }
+    if (!isComplexSlice(s) && max > s.length) {
+      throw new Error(`Slice index out of range: ${max} > ${s.length}`)
+    }
+    newCap = max - low
+  } else {
+    // For slices of slices, capacity should be the capacity of the original slice minus the low index
+    if (isComplexSlice(s)) {
+      newCap = oldCap - low
+    } else {
+      newCap = s.length - low
+    }
+  }
+
+  const newLength = high - low
+  const newOffset = oldOffset + low
+
+  const target = {
+    __meta__: {
+      backing: backing,
+      offset: newOffset,
+      length: newLength,
+      capacity: newCap,
+    },
+  }
+
+  const handler = {
+    get(target: any, prop: string | symbol): any {
+      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+        const index = Number(prop)
+        if (index >= 0 && index < target.__meta__.length) {
+          return target.__meta__.backing[target.__meta__.offset + index]
+        }
+        throw new Error(
+          `Slice index out of range: ${index} >= ${target.__meta__.length}`,
+        )
+      }
+
+      if (prop === 'length') {
+        return target.__meta__.length
+      }
+
+      if (prop === '__meta__') {
+        return target.__meta__
+      }
+
+      if (
+        prop === 'slice' ||
+        prop === 'map' ||
+        prop === 'filter' ||
+        prop === 'reduce' ||
+        prop === 'forEach' ||
+        prop === Symbol.iterator
+      ) {
+        const backingSlice = target.__meta__.backing.slice(
+          target.__meta__.offset,
+          target.__meta__.offset + target.__meta__.length,
+        )
+        return backingSlice[prop].bind(backingSlice)
+      }
+
+      return Reflect.get(target, prop)
+    },
+
+    set(target: any, prop: string | symbol, value: any): boolean {
+      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+        const index = Number(prop)
+        if (index >= 0 && index < target.__meta__.length) {
+          target.__meta__.backing[target.__meta__.offset + index] = value
+          return true
+        }
+        if (
+          index === target.__meta__.length &&
+          target.__meta__.length < target.__meta__.capacity
+        ) {
+          target.__meta__.backing[target.__meta__.offset + index] = value
+          target.__meta__.length++
+          return true
+        }
+        throw new Error(
+          `Slice index out of range: ${index} >= ${target.__meta__.length}`,
+        )
+      }
+
+      if (prop === 'length' || prop === '__meta__') {
+        return false
+      }
+
+      return Reflect.set(target, prop, value)
+    },
+  }
+
+  return new Proxy(target, handler) as unknown as SliceProxy<T>
 }
 
 /**
@@ -50,28 +241,353 @@ export const makeMap = <K, V>(): Map<K, V> => {
 }
 
 /**
- * Returns the length of a collection (string, array, or map).
- * @param collection The collection to get the length of.
+ * Converts a JavaScript array to a Go slice.
+ * For multi-dimensional arrays, recursively converts nested arrays to slices.
+ * @param arr The JavaScript array to convert
+ * @param depth How many levels of nesting to convert (default: 1, use Infinity for all levels)
+ * @returns A Go slice containing the same elements
+ */
+export const arrayToSlice = <T>(
+  arr: T[] | null | undefined,
+  depth: number = 1,
+): T[] => {
+  if (arr == null) return [] as T[]
+
+  if (arr.length === 0) return arr
+
+  const target = {
+    __meta__: {
+      backing: arr,
+      offset: 0,
+      length: arr.length,
+      capacity: arr.length,
+    },
+  }
+
+  const handler = {
+    get(target: any, prop: string | symbol): any {
+      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+        const index = Number(prop)
+        if (index >= 0 && index < target.__meta__.length) {
+          return target.__meta__.backing[target.__meta__.offset + index]
+        }
+        throw new Error(
+          `Slice index out of range: ${index} >= ${target.__meta__.length}`,
+        )
+      }
+
+      if (prop === 'length') {
+        return target.__meta__.length
+      }
+
+      if (prop === '__meta__') {
+        return target.__meta__
+      }
+
+      if (
+        prop === 'slice' ||
+        prop === 'map' ||
+        prop === 'filter' ||
+        prop === 'reduce' ||
+        prop === 'forEach' ||
+        prop === Symbol.iterator
+      ) {
+        const backingSlice = target.__meta__.backing.slice(
+          target.__meta__.offset,
+          target.__meta__.offset + target.__meta__.length,
+        )
+        return backingSlice[prop].bind(backingSlice)
+      }
+
+      return Reflect.get(target, prop)
+    },
+
+    set(target: any, prop: string | symbol, value: any): boolean {
+      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+        const index = Number(prop)
+        if (index >= 0 && index < target.__meta__.length) {
+          target.__meta__.backing[target.__meta__.offset + index] = value
+          return true
+        }
+        if (
+          index === target.__meta__.length &&
+          target.__meta__.length < target.__meta__.capacity
+        ) {
+          target.__meta__.backing[target.__meta__.offset + index] = value
+          target.__meta__.length++
+          return true
+        }
+        throw new Error(
+          `Slice index out of range: ${index} >= ${target.__meta__.length}`,
+        )
+      }
+
+      if (prop === 'length' || prop === '__meta__') {
+        return false
+      }
+
+      return Reflect.set(target, prop, value)
+    },
+  }
+
+  // Recursively convert nested arrays if depth > 1
+  if (depth > 1 && arr.length > 0) {
+    for (let i = 0; i < arr.length; i++) {
+      const item = arr[i]
+      if (isComplexSlice(item as any)) {
+      } else if (Array.isArray(item)) {
+        arr[i] = arrayToSlice(item as any[], depth - 1) as any
+      } else if (
+        item &&
+        typeof item === 'object' &&
+        isComplexSlice(item as any)
+      ) {
+        // Preserve capacity information for complex slices
+      }
+    }
+  }
+
+  return new Proxy(target, handler) as unknown as SliceProxy<T>
+}
+
+/**
+ * Returns the length of a collection (string, array, slice, map, or set).
+ * @param obj The collection to get the length of.
  * @returns The length of the collection.
  */
-export const len = <T>(
-  collection: string | Array<T> | Map<unknown, unknown>,
+export const len = <T = unknown, V = unknown>(
+  obj: string | Array<T> | Slice<T> | Map<T, V> | Set<T> | null | undefined,
 ): number => {
-  if (typeof collection === 'string' || Array.isArray(collection)) {
-    return collection.length
-  } else if (collection instanceof Map) {
-    return collection.size
+  if (obj === null || obj === undefined) {
+    return 0
+  }
+
+  if (typeof obj === 'string') {
+    return obj.length
+  }
+
+  if (obj instanceof Map || obj instanceof Set) {
+    return obj.size
+  }
+
+  if (isComplexSlice(obj)) {
+    return obj.__meta__.length
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.length
   }
+
   return 0 // Default fallback
 }
 
 /**
- * Returns the capacity of a slice (TypeScript array).
- * @param slice The slice (TypeScript array).
+ * Returns the capacity of a slice.
+ * @param obj The slice.
  * @returns The capacity of the slice.
  */
-export const cap = <T>(slice: Array<T> & { __capacity?: number }): number => {
-  return slice.__capacity !== undefined ? slice.__capacity : slice.length
+export const cap = <T>(obj: Slice<T>): number => {
+  if (obj === null || obj === undefined) {
+    return 0
+  }
+
+  if (isComplexSlice(obj)) {
+    return obj.__meta__.capacity
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.length
+  }
+
+  return 0
+}
+
+/**
+ * Appends elements to a slice.
+ * Note: In Go, append can return a new slice if the underlying array is reallocated.
+ * This helper emulates that by returning the modified or new slice.
+ * @param slice The slice to append to.
+ * @param elements The elements to append.
+ * @returns The modified or new slice.
+ */
+export const append = <T>(slice: Slice<T>, ...elements: T[]): T[] => {
+  if (slice === null || slice === undefined) {
+    if (elements.length === 0) {
+      return [] as T[]
+    } else {
+      return elements.slice(0) as T[]
+    }
+  }
+
+  if (elements.length === 0) {
+    return slice
+  }
+
+  const oldLen = len(slice)
+  const oldCap = cap(slice)
+  const newLen = oldLen + elements.length
+
+  if (newLen <= oldCap) {
+    if (isComplexSlice(slice)) {
+      const offset = slice.__meta__.offset
+      const backing = slice.__meta__.backing
+
+      for (let i = 0; i < elements.length; i++) {
+        backing[offset + oldLen + i] = elements[i]
+      }
+
+      const result = new Array(newLen) as SliceProxy<T>
+
+      for (let i = 0; i < oldLen; i++) {
+        result[i] = backing[offset + i]
+      }
+      for (let i = 0; i < elements.length; i++) {
+        result[oldLen + i] = elements[i]
+      }
+
+      result.__meta__ = {
+        backing: backing,
+        offset: offset,
+        length: newLen,
+        capacity: oldCap,
+      }
+
+      return result
+    } else {
+      const result = new Array(newLen) as SliceProxy<T>
+
+      for (let i = 0; i < oldLen; i++) {
+        result[i] = slice[i]
+      }
+
+      for (let i = 0; i < elements.length; i++) {
+        result[i + oldLen] = elements[i]
+
+        if (i + oldLen < oldCap && Array.isArray(slice)) {
+          slice[i + oldLen] = elements[i]
+        }
+      }
+
+      result.__meta__ = {
+        backing: slice as any,
+        offset: 0,
+        length: newLen,
+        capacity: oldCap,
+      }
+
+      return result
+    }
+  } else {
+    let newCap = oldCap
+    if (newCap == 0) {
+      newCap = elements.length
+    } else {
+      if (newCap < 1024) {
+        newCap *= 2
+      } else {
+        newCap += newCap / 4
+      }
+
+      // Ensure the new capacity fits all the elements
+      if (newCap < newLen) {
+        newCap = newLen
+      }
+    }
+
+    const newBacking = new Array<T>(newCap)
+
+    if (isComplexSlice(slice)) {
+      const offset = slice.__meta__.offset
+      const backing = slice.__meta__.backing
+
+      for (let i = 0; i < oldLen; i++) {
+        newBacking[i] = backing[offset + i]
+      }
+    } else {
+      for (let i = 0; i < oldLen; i++) {
+        newBacking[i] = slice[i]
+      }
+    }
+
+    for (let i = 0; i < elements.length; i++) {
+      newBacking[oldLen + i] = elements[i]
+    }
+
+    if (newLen === newCap) {
+      return newBacking.slice(0, newLen) as T[]
+    }
+
+    const result = new Array(newLen) as SliceProxy<T>
+
+    for (let i = 0; i < newLen; i++) {
+      result[i] = newBacking[i]
+    }
+
+    result.__meta__ = {
+      backing: newBacking,
+      offset: 0,
+      length: newLen,
+      capacity: newCap,
+    }
+
+    return result
+  }
+}
+
+/**
+ * Copies elements from src to dst.
+ * @param dst The destination slice.
+ * @param src The source slice.
+ * @returns The number of elements copied.
+ */
+export const copy = <T>(dst: Slice<T>, src: Slice<T>): number => {
+  if (dst === null || src === null) {
+    return 0
+  }
+
+  const dstLen = len(dst)
+  const srcLen = len(src)
+
+  const count = Math.min(dstLen, srcLen)
+
+  if (count === 0) {
+    return 0
+  }
+
+  if (isComplexSlice(dst)) {
+    const dstOffset = dst.__meta__.offset
+    const dstBacking = dst.__meta__.backing
+
+    if (isComplexSlice(src)) {
+      const srcOffset = src.__meta__.offset
+      const srcBacking = src.__meta__.backing
+
+      for (let i = 0; i < count; i++) {
+        dstBacking[dstOffset + i] = srcBacking[srcOffset + i]
+        dst[i] = srcBacking[srcOffset + i] // Update the proxy array
+      }
+    } else {
+      for (let i = 0; i < count; i++) {
+        dstBacking[dstOffset + i] = src[i]
+        dst[i] = src[i] // Update the proxy array
+      }
+    }
+  } else {
+    if (isComplexSlice(src)) {
+      const srcOffset = src.__meta__.offset
+      const srcBacking = src.__meta__.backing
+
+      for (let i = 0; i < count; i++) {
+        dst[i] = srcBacking[srcOffset + i]
+      }
+    } else {
+      for (let i = 0; i < count; i++) {
+        dst[i] = src[i]
+      }
+    }
+  }
+
+  return count
 }
 
 /**
@@ -95,9 +611,44 @@ export const stringToRunes = (str: string): number[] => {
  * @param runes The input array of numbers representing Unicode code points.
  * @returns The resulting string.
  */
-export const runesToString = (runes: number[]): string => {
-  return String.fromCharCode(...runes);
-};
+export const runesToString = (runes: Slice<number>): string => {
+  return runes?.length ? String.fromCharCode(...runes) : ''
+}
+
+/**
+ * Converts a number to a byte (uint8) by truncating to the range 0-255.
+ * Equivalent to Go's byte() conversion.
+ * @param n The number to convert to a byte.
+ * @returns The byte value (0-255).
+ */
+export const byte = (n: number): number => {
+  return n & 0xff // Bitwise AND with 255 ensures we get a value in the range 0-255
+}
+
+/** Box represents a Go variable which can be referred to by other variables.
+ *
+ * For example:
+ *   var myVariable int
+ *
+ */
+export type Box<T> = { value: T }
+
+/** Wrap a non-null T in a pointer‐box. */
+export function box<T>(v: T): Box<T> {
+  // We create a new object wrapper for every box call to ensure
+  // distinct pointer identity, crucial for pointer comparisons (p1 == p2).
+  return { value: v }
+}
+
+/** Dereference a pointer‐box, throws on null → simulates Go panic. */
+export function unbox<T>(b: Box<T>): T {
+  if (b === null) {
+    throw new Error(
+      'runtime error: invalid memory address or nil pointer dereference',
+    )
+  }
+  return b.value
+}
 
 /**
  * Gets a value from a map, with a default value if the key doesn't exist.
@@ -142,78 +693,213 @@ export const deleteMapEntry = <K, V>(map: Map<K, V>, key: K): void => {
 export const mapHas = <K, V>(map: Map<K, V>, key: K): boolean => {
   return map.has(key)
 }
-/**
- * Appends elements to a slice (TypeScript array).
- * Note: In Go, append can return a new slice if the underlying array is reallocated.
- * This helper emulates that by returning the modified array.
- * @param slice The slice (TypeScript array) to append to.
- * @param elements The elements to append.
- * @returns The modified slice (TypeScript array).
- */
-export const append = <T>(
-  slice: Array<T> & { __capacity?: number },
-  ...elements: T[]
-): Array<T> & { __capacity?: number } => {
-  slice.push(...elements)
-  if (slice.__capacity !== undefined && slice.length > slice.__capacity) {
-    slice.__capacity = slice.length
-  }
-  return slice
-}
 
 /**
  * Represents the kinds of Go types that can be registered at runtime.
  */
 export enum TypeKind {
-  Struct = 'struct',
-  Interface = 'interface',
   Basic = 'basic',
-  Pointer = 'pointer',
-  Slice = 'slice',
+  Interface = 'interface',
+  Struct = 'struct',
   Map = 'map',
-  Channel = 'channel',
+  Slice = 'slice',
+  Array = 'array',
+  Pointer = 'pointer',
   Function = 'function',
+  Channel = 'channel',
 }
 
 /**
- * Represents type information for a Go type in the runtime.
+ * TypeInfo is used for runtime type checking.
+ * Can be a registered type (from typeRegistry) or an ad-hoc type description.
+ * When used as input to typeAssert, it can be a string (type name) or a structured description.
  */
-export interface TypeInfo {
-  name: string
+
+/**
+ * Base type information shared by all type kinds
+ */
+export interface BaseTypeInfo {
+  name?: string
   kind: TypeKind
-  zeroValue: any
-  // For interfaces, the set of methods
-  methods?: Set<string>
-  // For structs, the constructor
-  constructor?: new (...args: any[]) => any
+  zeroValue?: any
+}
+
+/**
+ * Type information for struct types
+ */
+export interface StructTypeInfo extends BaseTypeInfo {
+  kind: TypeKind.Struct
+  methods: Set<string>
+  ctor?: new (...args: any[]) => any
+  fields?: Set<string> // Field names for struct types
+  fieldTypes?: Record<string, TypeInfo | string> // Types for struct fields
+}
+
+/**
+ * Type information for interface types
+ */
+export interface InterfaceTypeInfo extends BaseTypeInfo {
+  kind: TypeKind.Interface
+  methods: Set<string>
+}
+
+/**
+ * Type information for basic types (string, number, boolean)
+ */
+export interface BasicTypeInfo extends BaseTypeInfo {
+  kind: TypeKind.Basic
+}
+
+/**
+ * Type information for map types
+ */
+export interface MapTypeInfo extends BaseTypeInfo {
+  kind: TypeKind.Map
+  keyType?: string | TypeInfo
+  elemType?: string | TypeInfo
+}
+
+/**
+ * Type information for slice types
+ */
+export interface SliceTypeInfo extends BaseTypeInfo {
+  kind: TypeKind.Slice
+  elemType?: string | TypeInfo
+}
+
+/**
+ * Type information for array types
+ */
+export interface ArrayTypeInfo extends BaseTypeInfo {
+  kind: TypeKind.Array
+  elemType?: string | TypeInfo
+  length: number
+}
+
+/**
+ * Type information for pointer types
+ */
+export interface PointerTypeInfo extends BaseTypeInfo {
+  kind: TypeKind.Pointer
+  elemType?: string | TypeInfo
+}
+
+/**
+ * Type information for function types
+ */
+export interface FunctionTypeInfo extends BaseTypeInfo {
+  kind: TypeKind.Function
+  params?: (string | TypeInfo)[]
+  results?: (string | TypeInfo)[]
+}
+
+/**
+ * Type information for channel types
+ */
+export interface ChannelTypeInfo extends BaseTypeInfo {
+  kind: TypeKind.Channel
+  elemType?: string | TypeInfo
+  direction?: 'send' | 'receive' | 'both'
+}
+
+/**
+ * Union type representing all possible TypeInfo variants
+ */
+export type TypeInfo =
+  | StructTypeInfo
+  | InterfaceTypeInfo
+  | BasicTypeInfo
+  | MapTypeInfo
+  | SliceTypeInfo
+  | ArrayTypeInfo
+  | PointerTypeInfo
+  | FunctionTypeInfo
+  | ChannelTypeInfo
+
+// Type guard functions for TypeInfo variants
+export function isStructTypeInfo(info: TypeInfo): info is StructTypeInfo {
+  return info.kind === TypeKind.Struct
+}
+
+export function isInterfaceTypeInfo(info: TypeInfo): info is InterfaceTypeInfo {
+  return info.kind === TypeKind.Interface
+}
+
+export function isBasicTypeInfo(info: TypeInfo): info is BasicTypeInfo {
+  return info.kind === TypeKind.Basic
+}
+
+export function isMapTypeInfo(info: TypeInfo): info is MapTypeInfo {
+  return info.kind === TypeKind.Map
+}
+
+export function isSliceTypeInfo(info: TypeInfo): info is SliceTypeInfo {
+  return info.kind === TypeKind.Slice
+}
+
+export function isArrayTypeInfo(info: TypeInfo): info is ArrayTypeInfo {
+  return info.kind === TypeKind.Array
+}
+
+export function isPointerTypeInfo(info: TypeInfo): info is PointerTypeInfo {
+  return info.kind === TypeKind.Pointer
+}
+
+export function isFunctionTypeInfo(info: TypeInfo): info is FunctionTypeInfo {
+  return info.kind === TypeKind.Function
+}
+
+export function isChannelTypeInfo(info: TypeInfo): info is ChannelTypeInfo {
+  return info.kind === TypeKind.Channel
 }
 
 // Registry to store runtime type information
 const typeRegistry = new Map<string, TypeInfo>()
 
 /**
- * Registers a type with the runtime type system.
+ * Registers a struct type with the runtime type system.
  *
  * @param name The name of the type.
- * @param kind The kind of the type.
  * @param zeroValue The zero value for the type.
- * @param methods Optional set of method names for interfaces.
- * @param constructor Optional constructor for structs.
- * @returns The type information object for chaining.
+ * @param methods Set of method names for the struct.
+ * @param ctor Constructor for the struct.
+ * @returns The struct type information object.
  */
-export const registerType = (
+export const registerStructType = (
   name: string,
-  kind: TypeKind,
   zeroValue: any,
-  methods?: Set<string>,
-  constructor?: new (...args: any[]) => any,
-): TypeInfo => {
-  const typeInfo: TypeInfo = {
+  methods: Set<string>,
+  ctor: new (...args: any[]) => any,
+): StructTypeInfo => {
+  const typeInfo: StructTypeInfo = {
     name,
-    kind,
+    kind: TypeKind.Struct,
+    zeroValue,
+    methods,
+    ctor: ctor,
+  }
+  typeRegistry.set(name, typeInfo)
+  return typeInfo
+}
+
+/**
+ * Registers an interface type with the runtime type system.
+ *
+ * @param name The name of the type.
+ * @param zeroValue The zero value for the type (usually null).
+ * @param methods Set of method names the interface requires.
+ * @returns The interface type information object.
+ */
+export const registerInterfaceType = (
+  name: string,
+  zeroValue: any,
+  methods: Set<string>,
+): InterfaceTypeInfo => {
+  const typeInfo: InterfaceTypeInfo = {
+    name,
+    kind: TypeKind.Interface,
     zeroValue,
     methods,
-    constructor,
   }
   typeRegistry.set(name, typeInfo)
   return typeInfo
@@ -228,115 +914,410 @@ export interface TypeAssertResult<T> {
 }
 
 /**
- * Performs a type assertion at runtime.
+ * Normalizes a type info to a structured TypeInfo object.
  *
- * @param value The value to assert.
- * @param typeName The name of the target type.
- * @returns An object with the asserted value and whether the assertion succeeded.
+ * @param info The type info or name.
+ * @returns A normalized TypeInfo object.
  */
-export function typeAssert<T>(
-  value: any,
-  typeName: string,
-): TypeAssertResult<T> {
-  // Get the type information from the registry
-  const typeInfo = typeRegistry.get(typeName)
-  if (!typeInfo) {
-    console.warn(`Type information for '${typeName}' not found in registry.`)
-    return { value: null as unknown as T, ok: false }
+function normalizeTypeInfo(info: string | TypeInfo): TypeInfo {
+  if (typeof info === 'string') {
+    const typeInfo = typeRegistry.get(info)
+    if (typeInfo) {
+      return typeInfo
+    }
+    return {
+      kind: TypeKind.Basic,
+      name: info,
+    }
   }
 
-  // If value is null or undefined, assertion fails
-  if (value === null || value === undefined) {
-    return { value: typeInfo.zeroValue as T, ok: false }
-  }
+  return info
+}
 
-  // Check based on the kind of the target type
-  switch (typeInfo.kind) {
-    case TypeKind.Struct:
-      // For structs, use instanceof with the constructor
-      if (typeInfo.constructor && value instanceof typeInfo.constructor) {
-        return { value: value as T, ok: true }
+/**
+ * Validates that a map key matches the expected type info.
+ *
+ * @param key The key to validate
+ * @param keyTypeInfo The normalized type info for the key
+ * @returns True if the key matches the type info, false otherwise
+ */
+function validateMapKey(key: any, keyTypeInfo: TypeInfo): boolean {
+  if (keyTypeInfo.kind === TypeKind.Basic) {
+    // For string keys
+    if (keyTypeInfo.name === 'string') {
+      return typeof key === 'string'
+    } else if (
+      keyTypeInfo.name === 'int' ||
+      keyTypeInfo.name === 'float64' ||
+      keyTypeInfo.name === 'number'
+    ) {
+      if (typeof key === 'string') {
+        return /^-?\d+(\.\d+)?$/.test(key)
+      } else {
+        return typeof key === 'number'
       }
-      break
+    }
+  }
+  return false
+}
 
-    case TypeKind.Interface:
-      // For interfaces, check if the value has all the required methods
-      if (typeInfo.methods && typeof value === 'object') {
-        const allMethodsPresent = Array.from(typeInfo.methods).every(
-          (method) => typeof (value as any)[method] === 'function',
-        )
-        if (allMethodsPresent) {
-          return { value: value as T, ok: true }
+/**
+ * Checks if a value matches a basic type info.
+ *
+ * @param value The value to check.
+ * @param info The basic type info to match against.
+ * @returns True if the value matches the basic type, false otherwise.
+ */
+function matchesBasicType(value: any, info: TypeInfo): boolean {
+  if (info.name === 'string') return typeof value === 'string'
+  if (info.name === 'number' || info.name === 'int' || info.name === 'float64')
+    return typeof value === 'number'
+  if (info.name === 'boolean' || info.name === 'bool')
+    return typeof value === 'boolean'
+  return false
+}
+
+/**
+ * Checks if a value matches a struct type info.
+ *
+ * @param value The value to check.
+ * @param info The struct type info to match against.
+ * @returns True if the value matches the struct type, false otherwise.
+ */
+function matchesStructType(value: any, info: TypeInfo): boolean {
+  if (!isStructTypeInfo(info)) return false
+
+  // For structs, use instanceof with the constructor
+  if (info.ctor && value instanceof info.ctor) {
+    return true
+  }
+
+  if (info.fields && typeof value === 'object') {
+    // For struct type assertions, we need to check that the value has exactly
+    const descFields = Array.from(info.fields as Set<string>)
+    const valueFields = Object.keys(value)
+
+    const condition1 = descFields.every((field) => field in value)
+    const condition2 = valueFields.length === descFields.length
+    const condition3 = valueFields.every((field) => descFields.includes(field))
+
+    console.log('Struct field matching debug:', {
+      descFields,
+      valueFields,
+      allDescFieldsInValue: condition1,
+      sameFieldCount: condition2,
+      allValueFieldsInDesc: condition3,
+    })
+
+    return condition1 && condition2 && condition3
+  }
+
+  return false
+}
+
+/**
+ * Checks if a value matches an interface type info.
+ *
+ * @param value The value to check.
+ * @param info The interface type info to match against.
+ * @returns True if the value matches the interface type, false otherwise.
+ */
+function matchesInterfaceType(value: any, info: TypeInfo): boolean {
+  // For interfaces, check if the value has all the required methods
+  if (
+    isInterfaceTypeInfo(info) &&
+    info.methods &&
+    typeof value === 'object' &&
+    value !== null
+  ) {
+    return Array.from(info.methods).every(
+      (method) => typeof (value as any)[method] === 'function',
+    )
+  }
+  return false
+}
+
+/**
+ * Checks if a value matches a map type info.
+ *
+ * @param value The value to check.
+ * @param info The map type info to match against.
+ * @returns True if the value matches the map type, false otherwise.
+ */
+function matchesMapType(value: any, info: TypeInfo): boolean {
+  if (typeof value !== 'object' || value === null) return false
+  if (!isMapTypeInfo(info)) return false
+
+  if (info.keyType || info.elemType) {
+    let entries: [any, any][] = []
+
+    if (value instanceof Map) {
+      entries = Array.from(value.entries())
+    } else {
+      entries = Object.entries(value)
+    }
+
+    if (entries.length === 0) return true // Empty map matches any map type
+
+    const sampleSize = Math.min(5, entries.length)
+    for (let i = 0; i < sampleSize; i++) {
+      const [k, v] = entries[i]
+
+      if (info.keyType) {
+        if (
+          !validateMapKey(
+            k,
+            normalizeTypeInfo(info.keyType as string | TypeInfo),
+          )
+        ) {
+          return false
         }
       }
-      break
 
-    case TypeKind.Basic:
-      // For basic types, check if the value matches the expected JavaScript type
-      // This is a simple check for common basic types
-      const basicType = typeof value
       if (
-        basicType === 'string' ||
-        basicType === 'number' ||
-        basicType === 'boolean'
+        info.elemType &&
+        !matchesType(v, normalizeTypeInfo(info.elemType as string | TypeInfo))
       ) {
-        return { value: value as T, ok: true }
+        return false
       }
-      break
+    }
+  }
 
-    case TypeKind.Pointer:
-      // For pointers, check if value is not null or undefined
-      // In Go, pointers can be nil which we represent as null/undefined in TS
-      if (value !== null && value !== undefined) {
-        return { value: value as T, ok: true }
-      }
-      break
+  return true
+}
 
-    case TypeKind.Slice:
-      // For slices, check if the value is an array
-      if (Array.isArray(value)) {
-        return { value: value as T, ok: true }
-      }
-      break
+/**
+ * Checks if a value matches an array or slice type info.
+ *
+ * @param value The value to check.
+ * @param info The array or slice type info to match against.
+ * @returns True if the value matches the array or slice type, false otherwise.
+ */
+function matchesArrayOrSliceType(value: any, info: TypeInfo): boolean {
+  // For slices and arrays, check if the value is an array and sample element types
+  if (!Array.isArray(value)) return false
+  if (!isArrayTypeInfo(info) && !isSliceTypeInfo(info)) return false
 
-    case TypeKind.Map:
-      // For maps, check if the value is a Map
-      if (value instanceof Map) {
-        return { value: value as T, ok: true }
-      }
-      break
+  if (info.elemType) {
+    const arr = value as any[]
+    if (arr.length === 0) return true // Empty array matches any array type
 
-    case TypeKind.Channel:
-      // For channels, check if the value has the required Channel interface methods
+    const sampleSize = Math.min(5, arr.length)
+    for (let i = 0; i < sampleSize; i++) {
       if (
-        typeof value === 'object' &&
-        value !== null &&
-        'send' in value &&
-        'receive' in value &&
-        'close' in value &&
-        typeof value.send === 'function' &&
-        typeof value.receive === 'function' &&
-        typeof value.close === 'function'
+        !matchesType(
+          arr[i],
+          normalizeTypeInfo(info.elemType as string | TypeInfo),
+        )
       ) {
-        return { value: value as T, ok: true }
+        return false
       }
-      break
+    }
+  }
+
+  return true
+}
+
+/**
+ * Checks if a value matches a pointer type info.
+ *
+ * @param value The value to check.
+ * @param info The pointer type info to match against.
+ * @returns True if the value matches the pointer type, false otherwise.
+ */
+function matchesPointerType(value: any, info: TypeInfo): boolean {
+  // For pointers, check if value is a Box (has a 'value' property)
+  if (value === null || value === undefined) {
+    return false
+  }
+
+  // Check if the value is a Box (has a 'value' property)
+  if (typeof value !== 'object' || !('value' in value)) {
+    return false
+  }
+
+  if (!isPointerTypeInfo(info)) return false
+
+  if (info.elemType) {
+    const elemTypeInfo = normalizeTypeInfo(info.elemType as string | TypeInfo)
+    return matchesType(value.value, elemTypeInfo)
+  }
+
+  return true
+}
+
+/**
+ * Checks if a value matches a function type info.
+ *
+ * @param value The value to check.
+ * @param info The function type info to match against.
+ * @returns True if the value matches the function type, false otherwise.
+ */
+function matchesFunctionType(value: any, info: TypeInfo): boolean {
+  // For functions, check if the value is a function
+  return typeof value === 'function'
+}
+
+/**
+ * Checks if a value matches a channel type info.
+ *
+ * @param value The value to check.
+ * @param info The channel type info to match against.
+ * @returns True if the value matches the channel type, false otherwise.
+ */
+function matchesChannelType(value: any, info: TypeInfo): boolean {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'send' in value &&
+    'receive' in value &&
+    'close' in value &&
+    typeof value.send === 'function' &&
+    typeof value.receive === 'function' &&
+    typeof value.close === 'function'
+  )
+}
+
+/**
+ * Checks if a value matches a type info.
+ *
+ * @param value The value to check.
+ * @param info The type info to match against.
+ * @returns True if the value matches the type info, false otherwise.
+ */
+function matchesType(value: any, info: TypeInfo): boolean {
+  if (value === null || value === undefined) {
+    return false
+  }
+
+  switch (info.kind) {
+    case TypeKind.Basic:
+      return matchesBasicType(value, info)
+
+    case TypeKind.Struct:
+      return matchesStructType(value, info)
+
+    case TypeKind.Interface:
+      return matchesInterfaceType(value, info)
+
+    case TypeKind.Map:
+      return matchesMapType(value, info)
+
+    case TypeKind.Slice:
+    case TypeKind.Array:
+      return matchesArrayOrSliceType(value, info)
+
+    case TypeKind.Pointer:
+      return matchesPointerType(value, info)
 
     case TypeKind.Function:
-      // For functions, check if the value is a function
-      if (typeof value === 'function') {
-        return { value: value as T, ok: true }
-      }
-      break
+      return matchesFunctionType(value, info)
+
+    case TypeKind.Channel:
+      return matchesChannelType(value, info)
 
     default:
       console.warn(
-        `Type assertion for kind '${typeInfo.kind}' not implemented.`,
+        `Type matching for kind '${(info as TypeInfo).kind}' not implemented.`,
       )
+      return false
+  }
+}
+
+export function typeAssert<T>(
+  value: any,
+  typeInfo: string | TypeInfo,
+): TypeAssertResult<T> {
+  const normalizedType = normalizeTypeInfo(typeInfo)
+
+  if (
+    isStructTypeInfo(normalizedType) &&
+    normalizedType.fields &&
+    typeof value === 'object' &&
+    value !== null
+  ) {
+    const descFields = Array.from(normalizedType.fields as Set<string>)
+    const valueFields = Object.keys(value)
+
+    // For struct type assertions, we need exact field matching
+    const structMatch =
+      descFields.length === valueFields.length &&
+      descFields.every((field: string) => field in value) &&
+      valueFields.every((field) => descFields.includes(field))
+
+    if (structMatch) {
+      return { value: value as T, ok: true }
+    } else {
+      return { value: null as unknown as T, ok: false }
+    }
   }
 
-  // Assertion failed
-  return { value: typeInfo.zeroValue as T, ok: false }
+  if (
+    isMapTypeInfo(normalizedType) &&
+    typeof value === 'object' &&
+    value !== null
+  ) {
+    if (normalizedType.keyType || normalizedType.elemType) {
+      let entries: [any, any][] = []
+
+      if (value instanceof Map) {
+        entries = Array.from(value.entries())
+      } else {
+        entries = Object.entries(value)
+      }
+
+      if (entries.length === 0) {
+        return { value: value as T, ok: true }
+      }
+
+      const sampleSize = Math.min(5, entries.length)
+      for (let i = 0; i < sampleSize; i++) {
+        const [k, v] = entries[i]
+
+        if (normalizedType.keyType) {
+          if (
+            !validateMapKey(
+              k,
+              normalizeTypeInfo(normalizedType.keyType as string | TypeInfo),
+            )
+          ) {
+            return { value: null as unknown as T, ok: false }
+          }
+        }
+
+        if (normalizedType.elemType) {
+          const elemTypeInfo = normalizeTypeInfo(
+            normalizedType.elemType as string | TypeInfo,
+          )
+          if (!matchesType(v, elemTypeInfo)) {
+            return { value: null as unknown as T, ok: false }
+          }
+        }
+      }
+
+      // If we get here, the map type assertion passes
+      return { value: value as T, ok: true }
+    }
+  }
+
+  const matches = matchesType(value, normalizedType)
+
+  if (matches) {
+    return { value: value as T, ok: true }
+  }
+
+  // If we get here, the assertion failed
+  // For registered types, use the zero value from the registry
+  if (typeof typeInfo === 'string') {
+    const registeredType = typeRegistry.get(typeInfo)
+    if (registeredType && registeredType.zeroValue !== undefined) {
+      return { value: registeredType.zeroValue as T, ok: false }
+    }
+  } else if (normalizedType.zeroValue !== undefined) {
+    return { value: normalizedType.zeroValue as T, ok: false }
+  }
+
+  return { value: null as unknown as T, ok: false }
 }
 
 /**
@@ -770,13 +1751,15 @@ export const makeChannel = <T>(
  * Implements the `Disposable` interface for use with `using` declarations.
  */
 export class DisposableStack implements Disposable {
-  #stack: (() => void)[] = [];
+  private stack: (() => void)[] = []
 
   /**
    * Adds a function to be executed when the stack is disposed.
    * @param fn The function to defer.
    */
-  defer(fn: () => void): void { this.#stack.push(fn); }
+  defer(fn: () => void): void {
+    this.stack.push(fn)
+  }
 
   /**
    * Disposes of the resources in the stack by executing the deferred functions
@@ -786,9 +1769,9 @@ export class DisposableStack implements Disposable {
    */
   [Symbol.dispose](): void {
     // Emulate Go: if a deferred throws, stop and rethrow
-    while (this.#stack.length) {
-      const fn = this.#stack.pop()!;
-      fn();
+    while (this.stack.length) {
+      const fn = this.stack.pop()!
+      fn()
     }
   }
 }
@@ -799,14 +1782,14 @@ export class DisposableStack implements Disposable {
  * Implements the `AsyncDisposable` interface for use with `await using` declarations.
  */
 export class AsyncDisposableStack implements AsyncDisposable {
-  #stack: (() => Promise<void> | void)[] = [];
+  private stack: (() => Promise<void> | void)[] = []
 
   /**
    * Adds a synchronous or asynchronous function to be executed when the stack is disposed.
    * @param fn The function to defer. Can return void or a Promise<void>.
    */
   defer(fn: () => Promise<void> | void): void {
-    this.#stack.push(fn);
+    this.stack.push(fn)
   }
 
   /**
@@ -815,8 +1798,16 @@ 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]();
+    for (let i = this.stack.length - 1; i >= 0; --i) {
+      await this.stack[i]()
     }
   }
-}
+}
+
+/**
+ * Implementation of Go's built-in println function
+ * @param args Arguments to print
+ */
+export function println(...args: any[]): void {
+  console.log(...args)
+}