goscript 0.1.4 → 0.2.0

package/dist/gs/reflect/type.js

@@ -1,7 +1,7 @@
 import { StructField, StructTag, ValueError, } from './types.js';
 export { StructField };
 import { MapIter } from './map.js';
-import { getTypeByName as builtinGetTypeByName, TypeKind, isStructTypeInfo, isInterfaceTypeInfo, isStructFieldInfo, } from '../builtin/type.js';
+import { getTypeByName as builtinGetTypeByName, isStructTypeInfo, isInterfaceTypeInfo, structFieldRuntimeKey, } from '../builtin/type.js';
 import { Zero } from './value.js';
 import { DeepEqual } from './deepequal.js';
 import * as $ from '../builtin/index.js';
@@ -153,8 +153,10 @@ export const Struct = 25;
 export const UnsafePointer = 26;
 const pointerAddressStride = 0x100000000;
 const pointerAddresses = new WeakMap();
+const fieldPointerAddresses = new WeakMap();
 let nextPointerAddress = 1;
 const canonicalTypes = new globalThis.Map();
+const constructingRegisteredTypes = new globalThis.Map();
 function pointerAddress(value) {
     let address = pointerAddresses.get(value);
     if (address === undefined) {
@@ -164,15 +166,121 @@ function pointerAddress(value) {
     }
     return address;
 }
+function fieldPointerAddress(target, key) {
+    let addresses = fieldPointerAddresses.get(target);
+    if (addresses === undefined) {
+        addresses = new globalThis.Map();
+        fieldPointerAddresses.set(target, addresses);
+    }
+    let address = addresses.get(key);
+    if (address === undefined) {
+        address = nextPointerAddress * pointerAddressStride;
+        nextPointerAddress++;
+        addresses.set(key, address);
+    }
+    return address;
+}
 function internType(t) {
-    const key = `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}`;
+    const key = typeIdentityKey(t);
     const existing = canonicalTypes.get(key);
     if (existing) {
+        mergeTypeMetadata(existing, t);
         return existing;
     }
     canonicalTypes.set(key, t);
     return t;
 }
+function mergeTypeMetadata(target, source) {
+    if (target instanceof BasicType && source instanceof BasicType) {
+        target.mergeMethodSignatures(source.methodSignatures());
+        return;
+    }
+    if (target instanceof PointerType && source instanceof PointerType) {
+        target.mergeMethodSignatures(source.methodSignatures());
+        return;
+    }
+    if (target instanceof FunctionType && source instanceof FunctionType) {
+        target.mergeSignature(source);
+        target.mergeMethodSignatures(source.methodSignatures());
+    }
+}
+function typeIdentityKey(t, seen = new Set()) {
+    if (seen.has(t)) {
+        return `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}`;
+    }
+    seen.add(t);
+    if (t instanceof StructType) {
+        return t.identityKey(seen);
+    }
+    switch (t.Kind()) {
+        case Array:
+            return `${t.Kind()}:${t.Len()}:${typeIdentityKey(t.Elem(), seen)}`;
+        case Chan:
+        case Ptr:
+        case Slice:
+            return `${t.Kind()}:${t.String()}:${typeIdentityKey(t.Elem(), seen)}`;
+        case Map:
+            return `${t.Kind()}:${typeIdentityKey(t.Key(), seen)}:${typeIdentityKey(t.Elem(), seen)}`;
+        case Func: {
+            if (t.Name() !== '') {
+                return `${t.Kind()}:named:${t.PkgPath()}:${t.Name()}`;
+            }
+            const params = globalThis.Array.from({ length: t.NumIn() }, (_unused, idx) => typeIdentityKey(t.In(idx), seen));
+            const results = globalThis.Array.from({ length: t.NumOut() }, (_unused, idx) => typeIdentityKey(t.Out(idx), seen));
+            return `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}:${t.IsVariadic()}:${params.join(',')}:${results.join(',')}`;
+        }
+        default:
+            return `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}`;
+    }
+}
+function typeUnderlyingIdentityKey(t, seen = new Set()) {
+    if (seen.has(t)) {
+        return `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}`;
+    }
+    seen.add(t);
+    if (t instanceof BasicType) {
+        return `basic:${t.underlyingName()}`;
+    }
+    if (t instanceof StructType) {
+        return t.underlyingIdentityKey(seen);
+    }
+    switch (t.Kind()) {
+        case Array:
+            return `array:${t.Len()}:${typeIdentityKey(t.Elem(), seen)}`;
+        case Chan:
+            return `chan:${t.String()}:${typeIdentityKey(t.Elem(), seen)}`;
+        case Ptr:
+            return `ptr:${typeIdentityKey(t.Elem(), seen)}`;
+        case Slice:
+            return `slice:${typeIdentityKey(t.Elem(), seen)}`;
+        case Map:
+            return `map:${typeIdentityKey(t.Key(), seen)}:${typeIdentityKey(t.Elem(), seen)}`;
+        case Func: {
+            const params = globalThis.Array.from({ length: t.NumIn() }, (_unused, idx) => typeIdentityKey(t.In(idx), seen));
+            const results = globalThis.Array.from({ length: t.NumOut() }, (_unused, idx) => typeIdentityKey(t.Out(idx), seen));
+            return `func:${t.IsVariadic()}:${params.join(',')}:${results.join(',')}`;
+        }
+        case Interface:
+            return `interface:${typeMethods(t).map(methodSignatureIdentityKey).join('|')}`;
+        default:
+            return `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}`;
+    }
+}
+function typeIsNamed(t) {
+    if (t.Kind() === Interface) {
+        return t.String() !== 'interface{}' && !t.String().startsWith('interface {');
+    }
+    if (t.Kind() === Struct || t.Kind() === Func) {
+        return t.Name() !== '';
+    }
+    if (t instanceof BasicType) {
+        return t.Kind() !== Invalid && t.Name() !== '';
+    }
+    return t.Name() !== '';
+}
+function nonFunctionTypePanic(method, t) {
+    throw new Error(`reflect: ${method} of non-func type ${t.String()}`);
+}
 // InvalidTypeInstance is a singleton type for invalid/zero reflect.Value
 class InvalidTypeClass {
     Kind() {
@@ -202,6 +310,21 @@ class InvalidTypeClass {
     NumField() {
         return 0;
     }
+    NumIn() {
+        return nonFunctionTypePanic('NumIn', this);
+    }
+    In(_i) {
+        return nonFunctionTypePanic('In', this);
+    }
+    NumOut() {
+        return nonFunctionTypePanic('NumOut', this);
+    }
+    Out(_i) {
+        return nonFunctionTypePanic('Out', this);
+    }
+    IsVariadic() {
+        return nonFunctionTypePanic('IsVariadic', this);
+    }
     Field(_i) {
         throw new Error('reflect: Field of invalid type');
     }
@@ -335,6 +458,9 @@ export class Value {
         return this._type.String();
     }
     Len() {
+        if (this.Kind() === Slice || this.Kind() === Array) {
+            return $.len(this._value);
+        }
         // Check for slice objects created by $.arrayToSlice
         if (this._value &&
             typeof this._value === 'object' &&
@@ -383,8 +509,9 @@ export class Value {
         return this._value === null || this._value === undefined;
     }
     Index(i) {
-        if (globalThis.Array.isArray(this._value)) {
-            return new Value(this._value[i], getTypeOf(this._value[i]));
+        if (this.Kind() === Slice || this.Kind() === Array) {
+            const ref = $.indexRef(this._value, i);
+            return new Value(ref.value, this._type.Elem(), ref);
         }
         throw new Error('reflect: call of reflect.Value.Index on ' +
             Kind_String(this._type.Kind()) +
@@ -446,16 +573,17 @@ export class Value {
             throw new ValueError({ Kind: this.Kind(), Method: 'Field' });
         }
         const field = this.Type().Field(i);
+        const fieldKey = structFieldStorageKey(this.Type(), i);
         if (!field) {
             throw new Error('reflect: struct field index out of range');
         }
         const parentObj = this._value;
-        let fieldVal = parentObj[field.Name];
+        let fieldVal = parentObj[fieldKey];
         if (fieldVal === undefined) {
             fieldVal = null;
         }
         // Pass parent struct and field name so Set() can update the struct
-        return new Value(fieldVal, field.Type, undefined, parentObj, field.Name);
+        return new Value(fieldVal, field.Type, undefined, parentObj, fieldKey);
     }
     FieldByIndex(index) {
         let current = this;
@@ -488,6 +616,9 @@ export class Value {
         if (this._value === null || this._value === undefined) {
             return 0;
         }
+        if ($.isOwnedPointerHandle(this._value)) {
+            return $.ownedPointerAddress(this._value);
+        }
         if ($.isVarRef(this._value)) {
             const address = this._value.__goAddress?.();
             if (address !== undefined) {
@@ -517,7 +648,18 @@ export class Value {
             throw new ValueError({ Kind: this.Kind(), Method: 'UnsafeAddr' });
         }
         if (this._parentStruct && this._fieldName) {
-            return { value: this };
+            const target = this._parentStruct;
+            const key = this._fieldName;
+            const ref = $.fieldRef(target, key);
+            return {
+                __goOwnedPointer: true,
+                __goAddress: () => fieldPointerAddress(target, key),
+                __goRef: () => ref,
+            };
+        }
+        if (this._parentVarRef?.__goPointer) {
+            return this._parentVarRef
+                .__goPointer;
         }
         return this.Pointer();
     }
@@ -547,6 +689,9 @@ export class Value {
         if (this._parentStruct && this._fieldName) {
             return new Value($.fieldRef(this._parentStruct, this._fieldName), ptrType);
         }
+        if (this._parentVarRef) {
+            return new Value(this._parentVarRef, ptrType);
+        }
         return new Value($.varRef(this._value), ptrType);
     }
     CanSet() {
@@ -558,23 +703,9 @@ export class Value {
         if (!this.CanSet()) {
             throw new Error('reflect: assign to invalid value');
         }
-        // Interface types can accept any value
-        if (this.Kind() === Interface) {
-            this._value = x.value;
-            // Also update the parent VarRef if we were dereferenced from one
-            if (this._parentVarRef) {
-                this._parentVarRef.value = x.value;
-            }
-            // Also update the parent struct field if this is a struct field
-            if (this._parentStruct && this._fieldName) {
-                this._parentStruct[this._fieldName] = x.value;
-            }
-            return;
-        }
-        // For other types, check if types are compatible (simplified check)
         const thisType = this.Type();
         const xType = x.Type();
-        if (thisType.Kind() !== xType.Kind()) {
+        if (!xType.AssignableTo(thisType)) {
             throw new Error('reflect: assign to wrong type');
         }
         this._value = x.value;
@@ -605,21 +736,23 @@ export class Value {
         if (typeof method !== 'function') {
             return new Value();
         }
-        return new Value(method.bind(receiver), new FunctionType('func'));
+        const [signature] = methodSignatureByName(this.Type(), name);
+        const methodType = signature ?
+            methodTypeFromSignature(signature, this.Type(), false)
+            : new FunctionType('func');
+        return new Value(method.bind(receiver), methodType);
     }
-    Call(inArgs) {
+    async Call(inArgs) {
         if (this.Kind() !== Func || typeof this._value !== 'function') {
             throw new ValueError({ Kind: this.Kind(), Method: 'Call' });
         }
-        const args = $.asArray(inArgs).map((arg) => arg.Interface());
-        const result = this._value(...args);
-        if (globalThis.Array.isArray(result)) {
-            return $.arrayToSlice(result.map((value) => ValueOf(value)));
-        }
-        if (result === undefined) {
-            return $.makeSlice(0);
+        return await callReflectFunction(this._value, this._type, inArgs, 'Call');
+    }
+    async CallSlice(inArgs) {
+        if (this.Kind() !== Func || typeof this._value !== 'function') {
+            throw new ValueError({ Kind: this.Kind(), Method: 'CallSlice' });
         }
-        return $.arrayToSlice([ValueOf(result)]);
+        return await callReflectFunction(this._value, this._type, inArgs, 'CallSlice');
     }
     IsZero() {
         const zeroVal = Zero(this.Type()).value;
@@ -886,10 +1019,7 @@ export class Value {
     Cap() {
         const k = this.Kind();
         if (k === Slice || k === Array) {
-            if (globalThis.Array.isArray(this._value)) {
-                return this._value.length;
-            }
-            return 0;
+            return $.cap(this._value);
         }
         if (k === Chan) {
             return 0; // Simplified
@@ -962,11 +1092,13 @@ export class BasicType {
     _name;
     _size;
     _typeName;
-    constructor(_kind, _name, _size = 8, _typeName = '') {
+    _methods;
+    constructor(_kind, _name, _size = 8, _typeName = '', _methods = []) {
         this._kind = _kind;
         this._name = _name;
         this._size = _size;
         this._typeName = _typeName;
+        this._methods = _methods;
     }
     String() {
         return this._typeName || this._name;
@@ -974,6 +1106,9 @@ export class BasicType {
     Kind() {
         return this._kind;
     }
+    underlyingName() {
+        return Kind_String(this._kind);
+    }
     Comparable() {
         return this._kind !== Func && this._kind !== Map && this._kind !== Slice;
     }
@@ -986,6 +1121,21 @@ export class BasicType {
     NumField() {
         return 0;
     }
+    NumIn() {
+        return nonFunctionTypePanic('NumIn', this);
+    }
+    In(_i) {
+        return nonFunctionTypePanic('In', this);
+    }
+    NumOut() {
+        return nonFunctionTypePanic('NumOut', this);
+    }
+    Out(_i) {
+        return nonFunctionTypePanic('Out', this);
+    }
+    IsVariadic() {
+        return nonFunctionTypePanic('IsVariadic', this);
+    }
     PkgPath() {
         if (this._typeName) {
             const dotIndex = this._typeName.lastIndexOf('.');
@@ -1025,7 +1175,7 @@ export class BasicType {
         if (u.Kind() !== Interface) {
             throw new Error('reflect: non-interface type passed to Type.Implements');
         }
-        return false;
+        return typeImplementsInterface(this, u);
     }
     AssignableTo(u) {
         return typeAssignableTo(this, u);
@@ -1084,10 +1234,16 @@ export class BasicType {
             ' Type');
     }
     NumMethod() {
-        return 0;
+        return typeMethods(this).length;
     }
-    MethodByName(_name) {
-        return [zeroMethod(), false];
+    MethodByName(name) {
+        return typeMethodByName(this, name);
+    }
+    methodSignatures() {
+        return this._methods;
+    }
+    mergeMethodSignatures(methods) {
+        this._methods = mergeMethodSignatureList(this._methods, methods);
     }
     Len() {
         throw new Error('reflect: call of reflect.Type.Len on ' +
@@ -1150,6 +1306,21 @@ class SliceType {
     NumField() {
         return 0;
     }
+    NumIn() {
+        return nonFunctionTypePanic('NumIn', this);
+    }
+    In(_i) {
+        return nonFunctionTypePanic('In', this);
+    }
+    NumOut() {
+        return nonFunctionTypePanic('NumOut', this);
+    }
+    Out(_i) {
+        return nonFunctionTypePanic('Out', this);
+    }
+    IsVariadic() {
+        return nonFunctionTypePanic('IsVariadic', this);
+    }
     PkgPath() {
         return '';
     }
@@ -1176,7 +1347,7 @@ class SliceType {
         if (u.Kind() !== Interface) {
             throw new Error('reflect: non-interface type passed to Type.Implements');
         }
-        return false;
+        return typeImplementsInterface(this, u);
     }
     AssignableTo(u) {
         return typeAssignableTo(this, u);
@@ -1229,6 +1400,21 @@ class ArrayType {
     NumField() {
         return 0;
     }
+    NumIn() {
+        return nonFunctionTypePanic('NumIn', this);
+    }
+    In(_i) {
+        return nonFunctionTypePanic('In', this);
+    }
+    NumOut() {
+        return nonFunctionTypePanic('NumOut', this);
+    }
+    Out(_i) {
+        return nonFunctionTypePanic('Out', this);
+    }
+    IsVariadic() {
+        return nonFunctionTypePanic('IsVariadic', this);
+    }
     Len() {
         return this._len;
     }
@@ -1258,7 +1444,7 @@ class ArrayType {
         if (u.Kind() !== Interface) {
             throw new Error('reflect: non-interface type passed to Type.Implements');
         }
-        return false;
+        return typeImplementsInterface(this, u);
     }
     AssignableTo(u) {
         return typeAssignableTo(this, u);
@@ -1288,8 +1474,10 @@ class ArrayType {
 // Pointer type implementation
 class PointerType {
     _elemType;
-    constructor(_elemType) {
+    _methods;
+    constructor(_elemType, _methods = []) {
         this._elemType = _elemType;
+        this._methods = _methods;
     }
     String() {
         return '*' + this._elemType.String();
@@ -1309,6 +1497,21 @@ class PointerType {
     NumField() {
         return 0;
     }
+    NumIn() {
+        return nonFunctionTypePanic('NumIn', this);
+    }
+    In(_i) {
+        return nonFunctionTypePanic('In', this);
+    }
+    NumOut() {
+        return nonFunctionTypePanic('NumOut', this);
+    }
+    Out(_i) {
+        return nonFunctionTypePanic('Out', this);
+    }
+    IsVariadic() {
+        return nonFunctionTypePanic('IsVariadic', this);
+    }
     PkgPath() {
         return '';
     }
@@ -1335,9 +1538,7 @@ class PointerType {
         if (u.Kind() !== Interface) {
             throw new Error('reflect: non-interface type passed to Type.Implements');
         }
-        // For pointer types, check if the element type implements the interface
-        const elemTypeName = this._elemType.String();
-        return typeImplementsInterface(elemTypeName, u);
+        return typeImplementsInterface(this, u);
     }
     AssignableTo(u) {
         return typeAssignableTo(this, u);
@@ -1355,10 +1556,16 @@ class PointerType {
         throw new Error('reflect: call of reflect.Type.OverflowFloat on pointer Type');
     }
     NumMethod() {
-        return 0;
+        return typeMethods(this).length;
     }
     MethodByName(name) {
-        return typeMethodByName(this._elemType, name);
+        return typeMethodByName(this, name);
+    }
+    methodSignatures() {
+        return this._methods;
+    }
+    mergeMethodSignatures(methods) {
+        this._methods = mergeMethodSignatureList(this._methods, methods);
     }
     Len() {
         throw new Error('reflect: call of reflect.Type.Len on pointer Type');
@@ -1367,13 +1574,42 @@ class PointerType {
         throw new Error('reflect: call of reflect.Type.Bits on pointer Type');
     }
 }
-// Function type implementation
 class FunctionType {
+    _name;
     _signature;
-    constructor(_signature) {
-        this._signature = _signature;
+    _params;
+    _results;
+    _variadic;
+    _hasSignature;
+    _methods;
+    constructor(signatureOrDescriptor) {
+        if (typeof signatureOrDescriptor === 'string') {
+            this._name = '';
+            this._signature = signatureOrDescriptor;
+            this._params = [];
+            this._results = [];
+            this._variadic = false;
+            this._hasSignature = false;
+            this._methods = [];
+            return;
+        }
+        this._name = signatureOrDescriptor.name ?? '';
+        this._params = signatureOrDescriptor.params ?? [];
+        this._results = signatureOrDescriptor.results ?? [];
+        this._variadic = signatureOrDescriptor.variadic ?? false;
+        this._hasSignature =
+            signatureOrDescriptor.signature !== undefined ||
+                signatureOrDescriptor.params !== undefined ||
+                signatureOrDescriptor.results !== undefined;
+        this._methods = signatureOrDescriptor.methods ?? [];
+        this._signature =
+            signatureOrDescriptor.signature ??
+                formatFunctionSignature(this._params, this._results, this._variadic);
     }
     String() {
+        if (this._name !== '') {
+            return this._name;
+        }
         return this._signature;
     }
     Kind() {
@@ -1391,11 +1627,44 @@ class FunctionType {
     NumField() {
         return 0;
     }
+    NumIn() {
+        return this._params.length;
+    }
+    In(i) {
+        if (i < 0 || i >= this._params.length) {
+            throw new Error(`reflect: In index out of range [${i}] with length ${this._params.length}`);
+        }
+        return this._params[i];
+    }
+    NumOut() {
+        return this._results.length;
+    }
+    Out(i) {
+        if (i < 0 || i >= this._results.length) {
+            throw new Error(`reflect: Out index out of range [${i}] with length ${this._results.length}`);
+        }
+        return this._results[i];
+    }
+    IsVariadic() {
+        return this._variadic;
+    }
     PkgPath() {
+        if (this._name !== '') {
+            const dotIndex = this._name.lastIndexOf('.');
+            if (dotIndex > 0) {
+                return this._name.substring(0, dotIndex);
+            }
+        }
         return '';
     }
     Name() {
-        // Function types are unnamed composite types
+        if (this._name !== '') {
+            const dotIndex = this._name.lastIndexOf('.');
+            if (dotIndex >= 0) {
+                return this._name.substring(dotIndex + 1);
+            }
+            return this._name;
+        }
         return '';
     }
     Field(_i) {
@@ -1417,7 +1686,7 @@ class FunctionType {
         if (u.Kind() !== Interface) {
             throw new Error('reflect: non-interface type passed to Type.Implements');
         }
-        return false;
+        return typeImplementsInterface(this, u);
     }
     AssignableTo(u) {
         return typeAssignableTo(this, u);
@@ -1435,10 +1704,26 @@ class FunctionType {
         throw new Error('reflect: call of reflect.Type.OverflowFloat on func Type');
     }
     NumMethod() {
-        return 0;
+        return typeMethods(this).length;
     }
-    MethodByName(_name) {
-        return [zeroMethod(), false];
+    MethodByName(name) {
+        return typeMethodByName(this, name);
+    }
+    methodSignatures() {
+        return this._methods;
+    }
+    mergeMethodSignatures(methods) {
+        this._methods = mergeMethodSignatureList(this._methods, methods);
+    }
+    mergeSignature(source) {
+        if (!source._hasSignature || this._hasSignature) {
+            return;
+        }
+        this._params = source._params;
+        this._results = source._results;
+        this._variadic = source._variadic;
+        this._signature = source._signature;
+        this._hasSignature = true;
     }
     Len() {
         throw new Error('reflect: call of reflect.Type.Len on func Type');
@@ -1447,6 +1732,174 @@ class FunctionType {
         throw new Error('reflect: call of reflect.Type.Bits on func Type');
     }
 }
+function formatFunctionSignature(params, results, variadic) {
+    const paramStrings = params.map((param, index) => {
+        const typeName = param.String();
+        if (!variadic || index !== params.length - 1) {
+            return typeName;
+        }
+        if (typeName.startsWith('[]')) {
+            return '...' + typeName.slice(2);
+        }
+        return '...' + typeName;
+    });
+    let signature = `func(${paramStrings.join(', ')})`;
+    if (results.length === 1) {
+        signature += ` ${results[0].String()}`;
+    }
+    else if (results.length > 1) {
+        signature += ` (${results.map((result) => result.String()).join(', ')})`;
+    }
+    return signature;
+}
+async function callReflectFunction(fn, fnType, inArgs, op) {
+    const args = $.asArray(inArgs);
+    const rawArgs = reflectCallRawArgs(fnType, args, op);
+    const result = await fn(...rawArgs);
+    return normalizeReflectCallResults(fnType, result);
+}
+function reflectCallRawArgs(fnType, args, op) {
+    if (op === 'CallSlice') {
+        return reflectCallSliceRawArgs(fnType, args);
+    }
+    if (!fnType.IsVariadic()) {
+        validateReflectCallInputCount(fnType, args.length);
+        return args.map((arg, index) => reflectCallValueInterface(op, arg, fnType.In(index), index));
+    }
+    const fixedCount = fnType.NumIn() - 1;
+    if (args.length < fixedCount) {
+        throw new Error('reflect: Call with too few input arguments');
+    }
+    const rawArgs = [];
+    for (let i = 0; i < fixedCount; i++) {
+        rawArgs.push(reflectCallValueInterface(op, args[i], fnType.In(i), i));
+    }
+    const variadicElemType = fnType.In(fixedCount).Elem();
+    const variadicValues = args.slice(fixedCount);
+    for (let i = 0; i < variadicValues.length; i++) {
+        const value = variadicValues[i];
+        if (!value.IsValid()) {
+            throw new Error(`reflect: ${op} using zero Value argument`);
+        }
+        if (!value.Type().AssignableTo(variadicElemType)) {
+            throw new Error(`reflect: cannot use ${value.Type().String()} as type ${variadicElemType.String()} in ${op}`);
+        }
+    }
+    rawArgs.push($.arrayToSlice(variadicValues.map((value) => value.Interface())));
+    return rawArgs;
+}
+function reflectCallSliceRawArgs(fnType, args) {
+    if (!fnType.IsVariadic()) {
+        throw new Error('reflect: CallSlice of non-variadic function');
+    }
+    const expected = fnType.NumIn();
+    if (args.length < expected) {
+        throw new Error('reflect: CallSlice with too few input arguments');
+    }
+    if (args.length > expected) {
+        throw new Error('reflect: CallSlice with too many input arguments');
+    }
+    return args.map((arg, index) => reflectCallValueInterface('CallSlice', arg, fnType.In(index), index));
+}
+function reflectCallValueInterface(op, value, target, _index) {
+    if (!value.IsValid()) {
+        throw new Error(`reflect: ${op} using zero Value argument`);
+    }
+    if (!value.Type().AssignableTo(target)) {
+        throw new Error(`reflect: ${op} using ${value.Type().String()} as type ${target.String()}`);
+    }
+    return value.Interface();
+}
+function validateReflectCallInputCount(fnType, actual) {
+    const expected = fnType.NumIn();
+    if (actual !== expected) {
+        throw new Error(`reflect: Call with ${actual} input arguments for function with ${expected} inputs`);
+    }
+}
+function normalizeReflectCallResults(fnType, result) {
+    const expected = fnType.NumOut();
+    if (expected === 0) {
+        if (result !== undefined) {
+            throw new Error('reflect: Call returned 1 results for function with 0 outputs');
+        }
+        return $.makeSlice(0);
+    }
+    if (expected === 1) {
+        return $.arrayToSlice([new Value(result, fnType.Out(0))]);
+    }
+    if (!globalThis.Array.isArray(result)) {
+        throw new Error(`reflect: Call returned 1 results for function with ${expected} outputs`);
+    }
+    if (result.length !== expected) {
+        throw new Error(`reflect: Call returned ${result.length} results for function with ${expected} outputs`);
+    }
+    return $.arrayToSlice(result.map((value, index) => new Value(value, fnType.Out(index))));
+}
+export function MakeFunc(typ, fn) {
+    if (!typ || typ.Kind() !== Func) {
+        throw new Error('reflect: call of MakeFunc with non-Func type');
+    }
+    if (typeof fn !== 'function') {
+        throw new Error('reflect.MakeFunc: nil implementation');
+    }
+    const typeInfo = functionTypeInfoFromType(typ);
+    const wrapper = $.functionValue(async (...rawArgs) => {
+        const args = makeFuncArgs(typ, rawArgs);
+        const resultValues = $.asArray(await fn($.arrayToSlice(args)));
+        validateMakeFuncResults(typ, resultValues);
+        if (typ.NumOut() === 0) {
+            return undefined;
+        }
+        if (typ.NumOut() === 1) {
+            return makeFuncReturnInterface(resultValues[0], typ.Out(0));
+        }
+        return resultValues.map((value, index) => makeFuncReturnInterface(value, typ.Out(index)));
+    }, typeInfo);
+    return new Value(wrapper, typ);
+}
+function makeFuncArgs(typ, rawArgs) {
+    validateReflectCallInputCount(typ, rawArgs.length);
+    return rawArgs.map((arg, index) => {
+        const value = ValueOf(arg);
+        const target = typ.In(index);
+        if (!value.Type().AssignableTo(target)) {
+            throw new Error(`reflect.MakeFunc: cannot use ${value.Type().String()} as type ${target.String()} in argument ${index}`);
+        }
+        return value;
+    });
+}
+function validateMakeFuncResults(typ, resultValues) {
+    const expected = typ.NumOut();
+    if (resultValues.length !== expected) {
+        throw new Error(`reflect.MakeFunc: returned ${resultValues.length} results for function with ${expected} outputs`);
+    }
+    for (let i = 0; i < resultValues.length; i++) {
+        const result = resultValues[i];
+        if (!result.IsValid()) {
+            throw new Error(`reflect.MakeFunc: returned zero Value for result ${i}`);
+        }
+        const target = typ.Out(i);
+        if (!result.Type().AssignableTo(target)) {
+            throw new Error(`reflect.MakeFunc: cannot use ${result.Type().String()} as type ${target.String()} in result ${i}`);
+        }
+    }
+}
+function makeFuncReturnInterface(value, target) {
+    const raw = value.Interface();
+    if (target.Kind() === Interface) {
+        return raw;
+    }
+    return unwrapGoInterfaceBox(raw);
+}
+function unwrapGoInterfaceBox(value) {
+    if (value !== null &&
+        value !== undefined &&
+        typeof value === 'object' &&
+        '__goValue' in value) {
+        return value.__goValue;
+    }
+    return value;
+}
 // Map type implementation
 class MapType {
     _keyType;
@@ -1473,6 +1926,21 @@ class MapType {
     NumField() {
         return 0;
     }
+    NumIn() {
+        return nonFunctionTypePanic('NumIn', this);
+    }
+    In(_i) {
+        return nonFunctionTypePanic('In', this);
+    }
+    NumOut() {
+        return nonFunctionTypePanic('NumOut', this);
+    }
+    Out(_i) {
+        return nonFunctionTypePanic('Out', this);
+    }
+    IsVariadic() {
+        return nonFunctionTypePanic('IsVariadic', this);
+    }
     Key() {
         return this._keyType;
     }
@@ -1499,7 +1967,7 @@ class MapType {
         if (u.Kind() !== Interface) {
             throw new Error('reflect: non-interface type passed to Type.Implements');
         }
-        return false;
+        return typeImplementsInterface(this, u);
     }
     AssignableTo(u) {
         return typeAssignableTo(this, u);
@@ -1530,47 +1998,122 @@ class MapType {
     }
 }
 // Struct type implementation
-/**
- * Helper function to check if a type's method set contains all methods
- * required by an interface.
- *
- * @param typeName The name of the type to check (e.g., "main.MyType")
- * @param interfaceType The interface type that must be implemented
- * @returns True if the type implements the interface, false otherwise
- */
-function typeImplementsInterface(typeName, interfaceType) {
-    // Get the interface name and look it up in the type registry
-    const interfaceName = interfaceType instanceof InterfaceType ?
-        interfaceType.registeredName() || interfaceType.String()
-        : interfaceType.String();
-    const interfaceTypeInfo = builtinGetTypeByName(interfaceName);
-    if (!interfaceTypeInfo || !isInterfaceTypeInfo(interfaceTypeInfo)) {
-        return false;
+function typeImplementsInterface(t, interfaceType) {
+    if (interfaceType.Kind() !== Interface) {
+        throw new Error('reflect: non-interface type passed to Type.Implements');
+    }
+    const requiredMethods = typeMethods(interfaceType);
+    if (requiredMethods.length === 0) {
+        return true;
     }
-    // Get the type info for the struct/type
-    const typeInfo = builtinGetTypeByName(typeName);
-    if (!typeInfo || !isStructTypeInfo(typeInfo)) {
+    const methods = typeMethods(t);
+    return requiredMethods.every((requiredMethod) => {
+        const method = methods.find((candidate) => candidate.name === requiredMethod.name);
+        return (method !== undefined && methodSignatureIdentical(method, requiredMethod));
+    });
+}
+function methodSignatureIdentical(actual, required) {
+    return (methodArgListIdentical(actual.args, required.args) &&
+        methodArgListIdentical(actual.returns, required.returns));
+}
+function methodArgListIdentical(actual, required) {
+    if (actual.length !== required.length) {
         return false;
     }
-    // Check if the type has all required methods
-    const requiredMethods = interfaceTypeInfo.methods || [];
-    const typeMethods = typeInfo.methods || [];
-    // For each required method, check if the type has a matching method
-    for (const requiredMethod of requiredMethods) {
-        const typeMethod = typeMethods.find((m) => m.name === requiredMethod.name);
-        if (!typeMethod) {
-            return false;
+    return actual.every((arg, index) => methodArgIdentityKey(arg) === methodArgIdentityKey(required[index]));
+}
+function methodArgIdentityKey(arg) {
+    return typeInfoIdentityKey(arg.type, new Set());
+}
+function methodSignatureIdentityKey(method) {
+    const args = method.args.map(methodArgIdentityKey).join(',');
+    const returns = method.returns.map(methodArgIdentityKey).join(',');
+    return `${method.name}(${args})(${returns})`;
+}
+function mergeMethodSignatureList(existing, incoming) {
+    if (incoming.length === 0) {
+        return existing;
+    }
+    const merged = [...existing];
+    for (const method of incoming) {
+        const existingIndex = merged.findIndex((candidate) => candidate.name === method.name);
+        if (existingIndex === -1) {
+            merged.push(method);
+            continue;
         }
-        // Check if method signatures match (simplified - just check counts)
-        if (typeMethod.args.length !== requiredMethod.args.length) {
-            return false;
+        if (methodSignatureIdentityKey(merged[existingIndex]) !==
+            methodSignatureIdentityKey(method)) {
+            merged[existingIndex] = method;
         }
-        if (typeMethod.returns.length !== requiredMethod.returns.length) {
-            return false;
+    }
+    return merged.sort((left, right) => left.name.localeCompare(right.name));
+}
+function typeInfoIdentityKey(info, seen) {
+    if (typeof info === 'string') {
+        const registered = builtinGetTypeByName(info);
+        if (!registered) {
+            return `named:${info}`;
+        }
+        const registeredName = registered.name ?? info;
+        if (registeredName !== '') {
+            return `named:${registeredName}`;
         }
-        // Could add deeper type checking here, but for now this is sufficient
+        if (seen.has(info)) {
+            return `named:${info}`;
+        }
+        seen.add(info);
+        const key = typeInfoIdentityKey(registered, seen);
+        seen.delete(info);
+        return key;
+    }
+    switch (info.kind) {
+        case $.TypeKind.Basic:
+            if (info.typeName) {
+                return `named:${info.typeName}`;
+            }
+            return `basic:${info.name ?? 'unknown'}`;
+        case $.TypeKind.Interface:
+            if (info.name) {
+                return `named:${info.name}`;
+            }
+            return `interface:${(info.methods ?? [])
+                .map(methodSignatureIdentityKey)
+                .join('|')}`;
+        case $.TypeKind.Struct:
+            if (info.name) {
+                return `named:${info.name}`;
+            }
+            return `struct:${(info.fields ?? [])
+                .map((field) => [
+                field.name,
+                field.pkgPath ?? '',
+                field.tag ?? '',
+                field.anonymous === true ? 'anonymous' : 'named',
+                typeInfoIdentityKey(field.type, seen),
+            ].join('\u0000'))
+                .join('\u0001')}`;
+        case $.TypeKind.Pointer:
+            return `ptr:${typeInfoIdentityKey(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen)}`;
+        case $.TypeKind.Slice:
+            return `slice:${typeInfoIdentityKey(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen)}`;
+        case $.TypeKind.Array:
+            return `array:${info.length}:${typeInfoIdentityKey(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen)}`;
+        case $.TypeKind.Map:
+            return `map:${typeInfoIdentityKey(info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen)}:${typeInfoIdentityKey(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen)}`;
+        case $.TypeKind.Function:
+            if (info.name) {
+                return `named:${info.name}`;
+            }
+            return `func:${info.isVariadic === true}:${(info.params ?? [])
+                .map((param) => typeInfoIdentityKey(param, seen))
+                .join(',')}:${(info.results ?? [])
+                .map((result) => typeInfoIdentityKey(result, seen))
+                .join(',')}`;
+        case $.TypeKind.Channel:
+            return `chan:${info.direction ?? 'both'}:${typeInfoIdentityKey(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen)}`;
+        default:
+            return 'unknown';
     }
-    return true;
 }
 function typeFieldByName(t, name) {
     return typeFieldByNameFunc(t, (fieldName) => fieldName === name);
@@ -1579,14 +2122,62 @@ function typeFieldByNameFunc(t, match) {
     if (t.Kind() !== Struct) {
         throw new Error('reflect: FieldByName of non-struct type');
     }
-    for (let i = 0; i < t.NumField(); i++) {
-        const field = t.Field(i);
+    for (const field of visibleStructFields(t)) {
         if (match(field.Name)) {
             return [field, true];
         }
     }
     return [new StructField(), false];
 }
+export function visibleStructFields(t) {
+    const fields = [];
+    const byName = new globalThis.Map();
+    const visiting = new Set();
+    const index = [];
+    const walk = (typ) => {
+        if (visiting.has(typ)) {
+            return;
+        }
+        visiting.add(typ);
+        for (let i = 0; i < typ.NumField(); i++) {
+            const field = typ.Field(i).clone();
+            index.push(i);
+            let add = true;
+            const oldIndex = byName.get(field.Name);
+            if (oldIndex !== undefined) {
+                const old = fields[oldIndex];
+                if (index.length === old.Index.length) {
+                    old.Name = '';
+                    add = false;
+                }
+                else if (index.length < old.Index.length) {
+                    old.Name = '';
+                }
+                else {
+                    add = false;
+                }
+            }
+            if (add) {
+                field.Index = [...index];
+                byName.set(field.Name, fields.length);
+                fields.push(field);
+            }
+            if (field.Anonymous) {
+                let fieldType = field.Type;
+                if (fieldType.Kind() === Ptr) {
+                    fieldType = fieldType.Elem();
+                }
+                if (fieldType.Kind() === Struct) {
+                    walk(fieldType);
+                }
+            }
+            index.pop();
+        }
+        visiting.delete(typ);
+    };
+    walk(t);
+    return fields.filter((field) => field.Name !== '');
+}
 function zeroMethod() {
     return {
         Name: '',
@@ -1595,16 +2186,50 @@ function zeroMethod() {
         Index: 0,
     };
 }
-function methodFromSignature(signature, index) {
+function methodFromSignature(signature, index, receiver) {
     return {
         Name: signature.name,
-        Type: new FunctionType('func'),
+        Type: methodTypeFromSignature(signature, receiver, receiver.Kind() !== Interface),
         Func: () => undefined,
         Index: index,
     };
 }
+function methodTypeFromSignature(signature, receiver, includeReceiver) {
+    const params = signature.args.map(methodArgType);
+    if (includeReceiver) {
+        params.unshift(receiver);
+    }
+    return new FunctionType({
+        params,
+        results: signature.returns.map(methodArgType),
+    });
+}
+function methodArgType(arg) {
+    return typeFromTypeInfoWithSeen(arg.type, new Set());
+}
 function typeMethods(t) {
-    const typeInfo = builtinGetTypeByName(t.String());
+    let typeInfo = builtinGetTypeByName(t.String());
+    if (!typeInfo && t.Kind() === Ptr) {
+        typeInfo = builtinGetTypeByName(t.Elem().String());
+    }
+    if (!typeInfo && t instanceof InterfaceType) {
+        const registeredName = t.registeredName();
+        if (registeredName) {
+            typeInfo = builtinGetTypeByName(registeredName);
+        }
+    }
+    if (!typeInfo && t instanceof InterfaceType) {
+        return t.methodSignatures();
+    }
+    if (!typeInfo && t instanceof PointerType) {
+        return mergeMethodSignatureList(typeMethods(t.Elem()), t.methodSignatures());
+    }
+    if (!typeInfo && t instanceof BasicType) {
+        return t.methodSignatures();
+    }
+    if (!typeInfo && t instanceof FunctionType) {
+        return t.methodSignatures();
+    }
     if (!typeInfo) {
         return [];
     }
@@ -1613,29 +2238,98 @@ function typeMethods(t) {
     }
     return [];
 }
-function typeMethodByName(t, name) {
+function methodSignatureByName(t, name) {
     const methods = typeMethods(t);
     const index = methods.findIndex((method) => method.name === name);
     if (index === -1) {
+        return [undefined, -1];
+    }
+    return [methods[index], index];
+}
+function typeMethodByName(t, name) {
+    const [signature, index] = methodSignatureByName(t, name);
+    if (!signature) {
         return [zeroMethod(), false];
     }
-    return [methodFromSignature(methods[index], index), true];
+    return [methodFromSignature(signature, index, t), true];
 }
 function typeAssignableTo(t, u) {
     if (u === null) {
         return false;
     }
-    return t.String() === u.String() || t.Implements(u);
+    if (typeIdentityKey(t) === typeIdentityKey(u)) {
+        return true;
+    }
+    if ((!typeIsNamed(t) || !typeIsNamed(u)) &&
+        typeUnderlyingIdentityKey(t) === typeUnderlyingIdentityKey(u)) {
+        return true;
+    }
+    if (u.Kind() !== Interface) {
+        return false;
+    }
+    return t.Implements(u);
+}
+export function structFieldStorageKey(t, i) {
+    if (t instanceof StructType) {
+        return t.fieldKey(i);
+    }
+    return t.Field(i).Name;
+}
+function typeAlignment(typ) {
+    switch (typ.Kind()) {
+        case Bool:
+        case Int8:
+        case Uint8:
+            return 1;
+        case Int16:
+        case Uint16:
+            return 2;
+        case Int32:
+        case Uint32:
+        case Float32:
+        case Complex64:
+            return 4;
+        case Array:
+            return typeAlignment(typ.Elem());
+        case Struct: {
+            let align = 1;
+            for (let i = 0; i < typ.NumField(); i++) {
+                align = Math.max(align, typeAlignment(typ.Field(i).Type));
+            }
+            return align;
+        }
+        default:
+            return 8;
+    }
+}
+function alignOffset(offset, alignment) {
+    if (alignment <= 1) {
+        return offset;
+    }
+    return Math.ceil(offset / alignment) * alignment;
+}
+function structDescriptorSize(fields) {
+    let size = 0;
+    let alignment = 1;
+    for (const field of fields) {
+        alignment = Math.max(alignment, typeAlignment(field.type));
+        size = Math.max(size, field.offset + field.type.Size());
+    }
+    return alignOffset(size, alignment);
 }
 class StructType {
     _name;
     _fields;
-    constructor(_name, _fields = []) {
+    _pkgPath;
+    _string;
+    constructor(_name, _fields = [], _pkgPath = '', _string = _name) {
         this._name = _name;
         this._fields = _fields;
+        this._pkgPath = _pkgPath;
+        this._string = _string;
     }
     String() {
-        return this._name;
+        return this._string;
     }
     Kind() {
         return Struct;
@@ -1644,8 +2338,7 @@ class StructType {
         return this._fields.every((field) => field.type.Comparable());
     }
     Size() {
-        // Struct size is implementation-defined, we'll use a reasonable default
-        return this._fields.reduce((sum, field) => sum + field.type.Size(), 0);
+        return structDescriptorSize(this._fields);
     }
     Elem() {
         throw new Error('reflect: Elem of invalid type');
@@ -1653,7 +2346,28 @@ class StructType {
     NumField() {
         return this._fields.length;
     }
+    NumIn() {
+        return nonFunctionTypePanic('NumIn', this);
+    }
+    In(_i) {
+        return nonFunctionTypePanic('In', this);
+    }
+    NumOut() {
+        return nonFunctionTypePanic('NumOut', this);
+    }
+    Out(_i) {
+        return nonFunctionTypePanic('Out', this);
+    }
+    IsVariadic() {
+        return nonFunctionTypePanic('IsVariadic', this);
+    }
     PkgPath() {
+        if (this._pkgPath !== '') {
+            return this._pkgPath;
+        }
+        if (this._name === '') {
+            return '';
+        }
         // Extract package path from full type name (e.g., "main.Person" -> "main")
         const dotIndex = this._name.lastIndexOf('.');
         if (dotIndex > 0) {
@@ -1662,6 +2376,9 @@ class StructType {
         return '';
     }
     Name() {
+        if (this._name === '') {
+            return '';
+        }
         // Extract type name from full type name (e.g., "main.Person" -> "Person")
         const dotIndex = this._name.lastIndexOf('.');
         if (dotIndex >= 0) {
@@ -1676,12 +2393,56 @@ class StructType {
         const f = this._fields[i];
         return new StructField({
             Name: f.name,
-            PkgPath: '',
+            PkgPath: f.pkgPath,
             Type: f.type,
             Tag: f.tag ? new StructTag(f.tag) : undefined,
-            Index: [i],
+            Offset: f.offset,
+            Index: [...f.index],
+            Anonymous: f.anonymous,
         });
     }
+    fieldKey(i) {
+        if (i < 0 || i >= this.NumField()) {
+            throw new Error(`reflect: Field index out of range [${i}] with length ${this.NumField()}`);
+        }
+        return this._fields[i].key;
+    }
+    descriptors() {
+        return this._fields.map((field) => ({
+            ...field,
+            index: [...field.index],
+        }));
+    }
+    replaceDescriptors(fields) {
+        this._fields = fields;
+    }
+    identityKey(seen) {
+        if (this._name !== '') {
+            return `struct:${this._name}`;
+        }
+        const fields = this._fields
+            .map((field) => [
+            field.name,
+            field.pkgPath,
+            field.tag ?? '',
+            field.anonymous ? 'anonymous' : 'named',
+            typeIdentityKey(field.type, seen),
+        ].join('\u0000'))
+            .join('\u0001');
+        return `struct:${this._pkgPath}:${this._name}:${fields}`;
+    }
+    underlyingIdentityKey(seen) {
+        const fields = this._fields
+            .map((field) => [
+            field.name,
+            field.pkgPath,
+            field.tag ?? '',
+            field.anonymous ? 'anonymous' : 'named',
+            typeIdentityKey(field.type, seen),
+        ].join('\u0000'))
+            .join('\u0001');
+        return `struct:${fields}`;
+    }
     FieldByName(name) {
         return typeFieldByName(this, name);
     }
@@ -1698,7 +2459,7 @@ class StructType {
         if (u.Kind() !== Interface) {
             throw new Error('reflect: non-interface type passed to Type.Implements');
         }
-        return typeImplementsInterface(this._name, u);
+        return typeImplementsInterface(this, u);
     }
     AssignableTo(u) {
         return typeAssignableTo(this, u);
@@ -1727,7 +2488,7 @@ class StructType {
     Bits() {
         throw new Error('reflect: call of reflect.Type.Bits on struct Type');
     }
-    static createTypeFromFieldInfo(ti) {
+    static createTypeFromFieldInfo(ti, seen = new Set()) {
         if (typeof ti === 'string') {
             return basicTypeFromName(ti === 'number' ? 'int' : ti);
         }
@@ -1740,18 +2501,21 @@ class StructType {
                     return basicTypeFromName(name === 'number' ? 'int' : name, typeName);
                 case 'slice':
                     if (ti.elemType) {
-                        return new SliceType(StructType.createTypeFromFieldInfo(ti.elemType));
+                        return new SliceType(StructType.createTypeFromFieldInfo(ti.elemType, seen));
                     }
                     return new SliceType(new BasicType(Invalid, 'unknown', 8));
                 case 'pointer':
                     if (ti.elemType) {
-                        return new PointerType(StructType.createTypeFromFieldInfo(ti.elemType));
+                        return new PointerType(StructType.createTypeFromFieldInfo(ti.elemType, seen));
                     }
                     return new PointerType(new BasicType(Invalid, 'unknown', 8));
                 case 'interface':
-                    return new InterfaceType(name);
-                case 'struct':
-                    return new StructType(name, structFieldsFromTypeInfo(ti));
+                    return interfaceTypeFromInfo(ti, seen);
+                case 'struct': {
+                    const structName = ti.name ?? '';
+                    const fields = structFieldsFromTypeInfo(ti, seen);
+                    return new StructType(structName, fields, '', structName === '' ? structTypeString(fields) : structName);
+                }
                 default:
                     return new BasicType(Invalid, name, 8);
             }
@@ -1801,18 +2565,18 @@ function basicTypeFromName(name, typeName = '') {
             return new BasicType(Invalid, name, 8, typeName);
     }
 }
-function structFieldsFromTypeInfo(ti) {
-    return Object.entries(ti.fields || {}).map(([name, fieldInfo]) => {
-        if (isStructFieldInfo(fieldInfo)) {
-            return {
-                name: fieldInfo.name ?? name,
-                type: typeFromTypeInfo(fieldInfo.type),
-                tag: fieldInfo.tag,
-            };
-        }
+function structFieldsFromTypeInfo(ti, seen = new Set()) {
+    return (ti.fields || []).map((fieldInfo, index) => {
         return {
-            name,
-            type: typeFromTypeInfo(fieldInfo),
+            name: fieldInfo.name,
+            key: structFieldRuntimeKey(fieldInfo),
+            type: typeFromTypeInfoWithSeen(fieldInfo.type, seen),
+            tag: fieldInfo.tag,
+            pkgPath: fieldInfo.pkgPath ?? '',
+            anonymous: fieldInfo.anonymous ?? false,
+            index: fieldInfo.index ? [...fieldInfo.index] : [index],
+            offset: fieldInfo.offset ?? index * 8,
+            exported: fieldInfo.exported ?? (fieldInfo.pkgPath ?? '') === '',
         };
     });
 }
@@ -1852,6 +2616,21 @@ class ChannelType {
     NumField() {
         return 0;
     }
+    NumIn() {
+        return nonFunctionTypePanic('NumIn', this);
+    }
+    In(_i) {
+        return nonFunctionTypePanic('In', this);
+    }
+    NumOut() {
+        return nonFunctionTypePanic('NumOut', this);
+    }
+    Out(_i) {
+        return nonFunctionTypePanic('Out', this);
+    }
+    IsVariadic() {
+        return nonFunctionTypePanic('IsVariadic', this);
+    }
     PkgPath() {
         return '';
     }
@@ -1878,7 +2657,7 @@ class ChannelType {
         if (u.Kind() !== Interface) {
             throw new Error('reflect: non-interface type passed to Type.Implements');
         }
-        return false;
+        return typeImplementsInterface(this, u);
     }
     AssignableTo(u) {
         return typeAssignableTo(this, u);
@@ -1915,9 +2694,11 @@ class ChannelType {
 class InterfaceType {
     _name;
     _registeredName;
-    constructor(_name = 'interface{}', _registeredName) {
+    _methods;
+    constructor(_name = 'interface{}', _registeredName, _methods = []) {
         this._name = _name;
         this._registeredName = _registeredName;
+        this._methods = _methods;
     }
     String() {
         return this._name;
@@ -1937,6 +2718,21 @@ class InterfaceType {
     NumField() {
         return 0;
     }
+    NumIn() {
+        return nonFunctionTypePanic('NumIn', this);
+    }
+    In(_i) {
+        return nonFunctionTypePanic('In', this);
+    }
+    NumOut() {
+        return nonFunctionTypePanic('NumOut', this);
+    }
+    Out(_i) {
+        return nonFunctionTypePanic('Out', this);
+    }
+    IsVariadic() {
+        return nonFunctionTypePanic('IsVariadic', this);
+    }
     PkgPath() {
         if (this._name === 'interface{}' || this._name.startsWith('interface {')) {
             return '';
@@ -1969,8 +2765,14 @@ class InterfaceType {
     Key() {
         throw new Error('reflect: Key of non-map type');
     }
-    Implements(_u) {
-        return false;
+    Implements(u) {
+        if (!u) {
+            return false;
+        }
+        if (u.Kind() !== Interface) {
+            throw new Error('reflect: non-interface type passed to Type.Implements');
+        }
+        return typeImplementsInterface(this, u);
     }
     AssignableTo(u) {
         return typeAssignableTo(this, u);
@@ -2002,6 +2804,9 @@ class InterfaceType {
     registeredName() {
         return this._registeredName;
     }
+    methodSignatures() {
+        return this._methods;
+    }
 }
 function getTypeOf(value) {
     // Check for typed nil before checking for plain null
@@ -2043,22 +2848,19 @@ function getTypeOf(value) {
                 if ((typeInfo.kind === 'function' || typeInfo.kind === 'Function') &&
                     typeInfo.params &&
                     typeInfo.results) {
+                    if (funcWithMeta.__goTypeName && !typeInfo.name) {
+                        return functionTypeFromInfo({
+                            ...typeInfo,
+                            name: funcWithMeta.__goTypeName,
+                        });
+                    }
                     return functionTypeFromInfo(typeInfo);
                 }
             }
             // Then check for __goTypeName which indicates a typed function
             if (funcWithMeta.__goTypeName) {
-                // This is a typed Go function - try to reconstruct the signature
                 const typeName = funcWithMeta.__goTypeName;
-                // For known Go function types, construct proper signatures
-                if (typeName === 'Greeter') {
-                    return new FunctionType('func(string) string');
-                }
-                else if (typeName === 'Adder') {
-                    return new FunctionType('func(int, int) int');
-                }
-                // Generic fallback for typed functions
-                return new FunctionType(`func`); // Could be enhanced with parameter parsing
+                return new FunctionType({ name: typeName });
             }
             // For untyped functions, try to parse the signature
             const funcStr = value.toString();
@@ -2165,34 +2967,31 @@ function getTypeOf(value) {
                 }
             }
             // Check if it has a constructor with __typeInfo for proper struct names
+            if (value &&
+                typeof value === 'object' &&
+                value.constructor &&
+                '__reflectType' in value.constructor) {
+                const reflectType = value.constructor
+                    .__reflectType;
+                if (reflectType) {
+                    return reflectType;
+                }
+            }
             if (value &&
                 typeof value === 'object' &&
                 value.constructor &&
                 '__typeInfo' in value.constructor) {
                 const typeInfo = value.constructor.__typeInfo;
-                if (typeInfo && typeInfo.name) {
-                    const typeName = typeInfo.name.includes('.') ?
-                        typeInfo.name
-                        : `main.${typeInfo.name}`;
-                    const regTypeInfo = builtinGetTypeByName(typeName);
-                    let fields = [];
-                    if (regTypeInfo && isStructTypeInfo(regTypeInfo)) {
-                        fields = Object.entries(regTypeInfo.fields || {}).map(([name, fieldInfo]) => {
-                            // Check if fieldInfo is a StructFieldInfo with type and tag
-                            if (isStructFieldInfo(fieldInfo)) {
-                                return {
-                                    name: fieldInfo.name ?? name,
-                                    type: StructType.createTypeFromFieldInfo(fieldInfo.type),
-                                    tag: fieldInfo.tag,
-                                };
-                            }
-                            // Otherwise it's just the type info directly (backwards compatible)
-                            return {
-                                name,
-                                type: StructType.createTypeFromFieldInfo(fieldInfo),
-                            };
-                        });
+                if (typeInfo && isStructTypeInfo(typeInfo)) {
+                    const name = typeInfo.name ?? '';
+                    if (name === '') {
+                        return new StructType('', structFieldsFromTypeInfo(typeInfo));
                     }
+                    const typeName = name.includes('.') ? name : `main.${name}`;
+                    const regTypeInfo = builtinGetTypeByName(typeName);
+                    const fields = regTypeInfo && isStructTypeInfo(regTypeInfo) ?
+                        structFieldsFromTypeInfo(regTypeInfo)
+                        : structFieldsFromTypeInfo(typeInfo);
                     return new StructType(typeName, fields);
                 }
             }
@@ -2242,86 +3041,497 @@ export function MapOf(key, elem) {
 export function ChanOf(dir, t) {
     return internType(new ChannelType(t, dir));
 }
+export function StructOf(fields) {
+    const inputFields = $.asArray(fields);
+    const descriptors = [];
+    const names = new Set();
+    let pkgPath = '';
+    let offset = 0;
+    for (const [idx, field] of inputFields.entries()) {
+        validateStructOfField(field, idx);
+        if (field.PkgPath !== '') {
+            if (pkgPath === '') {
+                pkgPath = field.PkgPath;
+            }
+            else if (pkgPath !== field.PkgPath) {
+                throw new Error(`reflect.Struct: fields with different PkgPath ${pkgPath} and ${field.PkgPath}`);
+            }
+        }
+        if (names.has(field.Name) && field.Name !== '_') {
+            throw new Error(`reflect.StructOf: duplicate field ${field.Name}`);
+        }
+        names.add(field.Name);
+        const fieldOffset = alignOffset(offset, typeAlignment(field.Type));
+        const tag = field.Tag?.toString();
+        const descriptor = {
+            name: field.Name,
+            key: field.Name === '_' ? `_${idx}` : field.Name,
+            type: field.Type,
+            ...(tag ? { tag } : {}),
+            pkgPath: field.PkgPath,
+            anonymous: field.Anonymous,
+            index: [idx],
+            offset: fieldOffset,
+            exported: field.IsExported(),
+        };
+        descriptors.push(descriptor);
+        offset = fieldOffset + field.Type.Size();
+    }
+    return internType(new StructType('', descriptors, '', structTypeString(descriptors)));
+}
+function validateStructOfField(field, idx) {
+    if (field.Name === '') {
+        throw new Error(`reflect.StructOf: field ${idx} has no name`);
+    }
+    if (!isValidStructFieldName(field.Name)) {
+        throw new Error(`reflect.StructOf: field ${idx} has invalid name`);
+    }
+    if (!field.Type) {
+        throw new Error(`reflect.StructOf: field ${idx} has no type`);
+    }
+    if (field.Anonymous && field.PkgPath !== '') {
+        throw new Error(`reflect.StructOf: field "${field.Name}" is anonymous but has PkgPath set`);
+    }
+    if (field.IsExported() && isUnexportedStructFieldName(field.Name)) {
+        throw new Error(`reflect.StructOf: field "${field.Name}" is unexported but missing PkgPath`);
+    }
+    validateAnonymousStructOfField(field);
+}
+function isValidStructFieldName(name) {
+    return /^[\p{L}_][\p{L}\p{N}_]*$/u.test(name);
+}
+function isUnexportedStructFieldName(name) {
+    const first = name.charCodeAt(0);
+    return name[0] === '_' || (first >= 97 && first <= 122);
+}
+function validateAnonymousStructOfField(field) {
+    if (!field.Anonymous) {
+        return;
+    }
+    const typ = field.Type;
+    if (typ.Kind() === Ptr) {
+        const elem = typ.Elem();
+        if (elem.Kind() === Ptr || elem.Kind() === Interface) {
+            throw new Error(`reflect.StructOf: illegal embedded field type ${typ.String()}`);
+        }
+        if (embeddedMethodCount(typ) > 0) {
+            throw new Error('reflect: embedded type with methods not implemented');
+        }
+        return;
+    }
+    if (embeddedMethodCount(typ) > 0) {
+        throw new Error('reflect: embedded type with methods not implemented');
+    }
+}
+function embeddedMethodCount(typ) {
+    if (typ.Kind() === Ptr) {
+        return Math.max(typ.NumMethod(), typ.Elem().NumMethod());
+    }
+    return typ.NumMethod();
+}
+function structTypeString(fields) {
+    if (fields.length === 0) {
+        return 'struct {}';
+    }
+    return `struct { ${fields.map(structFieldString).join('; ')} }`;
+}
+function structFieldString(field) {
+    const tag = field.tag ? ` ${JSON.stringify(field.tag)}` : '';
+    const prefix = field.anonymous ? '' : `${field.name} `;
+    return `${prefix}${field.type.String()}${tag}`;
+}
+export function FuncOf(inTypes, outTypes, variadic) {
+    const params = $.asArray(inTypes).map(funcOfType);
+    const results = $.asArray(outTypes).map(funcOfType);
+    if (variadic &&
+        (params.length === 0 || params[params.length - 1].Kind() !== Slice)) {
+        throw new Error('reflect.FuncOf: last arg of variadic func must be slice');
+    }
+    if (params.length + results.length > 128) {
+        throw new Error('reflect.FuncOf: too many arguments');
+    }
+    return internType(new FunctionType({ params, results, variadic }));
+}
+function funcOfType(typ) {
+    if (!typ) {
+        throw new Error('reflect.FuncOf: nil Type');
+    }
+    return typ;
+}
 export function TypeFor(typeArgs) {
     const descriptor = typeArgs?.T;
+    const methodSignatures = genericMethodSignatures(descriptor);
     if (descriptor?.type) {
-        return internType(typeFromTypeInfo(descriptor.type));
+        return internType(typeWithMethodSignatures(typeFromTypeInfo(descriptor.type), methodSignatures));
     }
-    if (descriptor?.methods) {
-        const methods = Object.keys(descriptor.methods);
-        if (methods.length !== 0) {
-            return internType(new InterfaceType(`interface { ${methods.map((method) => method + '()').join('; ')} }`));
-        }
+    if (methodSignatures.length !== 0) {
+        return internType(new InterfaceType(interfaceTypeString(methodSignatures), undefined, methodSignatures));
     }
     if (descriptor?.zero) {
         return internType(getTypeOf(descriptor.zero()));
     }
     return internType(new InterfaceType('interface{}'));
 }
+function genericMethodSignatures(descriptor) {
+    if (!descriptor) {
+        return [];
+    }
+    if (descriptor.methodSignatures && descriptor.methodSignatures.length !== 0) {
+        return descriptor.methodSignatures;
+    }
+    if (!descriptor.methods) {
+        return [];
+    }
+    return Object.keys(descriptor.methods).map((method) => ({
+        name: method,
+        args: [],
+        returns: [],
+    }));
+}
+function typeWithMethodSignatures(typ, methods) {
+    if (methods.length === 0) {
+        return typ;
+    }
+    if (typ instanceof BasicType) {
+        typ.mergeMethodSignatures(methods);
+        return typ;
+    }
+    if (typ instanceof PointerType) {
+        typ.mergeMethodSignatures(methods);
+        return typ;
+    }
+    if (typ instanceof FunctionType) {
+        typ.mergeMethodSignatures(methods);
+        return typ;
+    }
+    return typ;
+}
 function typeFromTypeInfo(info) {
+    return typeFromTypeInfoWithSeen(info, new Set());
+}
+function typeFromTypeInfoWithSeen(info, seen) {
     if (typeof info === 'string') {
         const registered = builtinGetTypeByName(info);
         if (registered) {
-            return internType(typeFromTypeInfo(registered));
+            const typ = typeFromTypeInfoWithSeen(registered, seen);
+            return internType(typ);
         }
-        return internType(StructType.createTypeFromFieldInfo(info));
+        return internType(StructType.createTypeFromFieldInfo(info, seen));
     }
+    const recursiveName = recursiveTypeInfoName(info);
+    if (recursiveName !== '') {
+        const constructing = constructingRegisteredTypes.get(recursiveName);
+        if (constructing) {
+            return constructing;
+        }
+        if (seen.has(recursiveName)) {
+            return internType(shallowTypeFromRegisteredInfo(recursiveName, info));
+        }
+        if (info.kind === $.TypeKind.Struct) {
+            const typ = new StructType(recursiveName, []);
+            constructingRegisteredTypes.set(recursiveName, typ);
+            seen.add(recursiveName);
+            try {
+                typ.replaceDescriptors(structFieldsFromTypeInfo(info, seen));
+                return internType(typ);
+            }
+            finally {
+                seen.delete(recursiveName);
+                constructingRegisteredTypes.delete(recursiveName);
+            }
+        }
+        seen.add(recursiveName);
+        const typ = typeFromStructuredTypeInfoWithSeen(info, seen);
+        seen.delete(recursiveName);
+        return internType(typ);
+    }
+    return internType(typeFromStructuredTypeInfoWithSeen(info, seen));
+}
+function recursiveTypeInfoName(info) {
+    if (info.kind === $.TypeKind.Basic) {
+        return info.typeName ?? '';
+    }
+    return info.name ?? '';
+}
+function typeFromStructuredTypeInfoWithSeen(info, seen) {
     switch (info.kind) {
         case $.TypeKind.Array:
-            return internType(new ArrayType(typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }), info.length));
+            return new ArrayType(typeFromTypeInfoWithSeen(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen), info.length);
         case $.TypeKind.Basic:
-            return internType(StructType.createTypeFromFieldInfo(info));
+            return StructType.createTypeFromFieldInfo(info, seen);
         case $.TypeKind.Channel:
-            return internType(new ChannelType(typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }), chanDirFromTypeInfo(info.direction)));
+            return new ChannelType(typeFromTypeInfoWithSeen(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen), chanDirFromTypeInfo(info.direction));
         case $.TypeKind.Function:
-            return internType(functionTypeFromInfo(info));
+            return functionTypeFromInfo(info, seen);
         case $.TypeKind.Interface:
-            return internType(interfaceTypeFromInfo(info));
+            return interfaceTypeFromInfo(info, seen);
         case $.TypeKind.Map:
-            return internType(new MapType(typeFromTypeInfo(info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' }), typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' })));
+            return new MapType(typeFromTypeInfoWithSeen(info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen), typeFromTypeInfoWithSeen(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen));
         case $.TypeKind.Slice:
-            return internType(new SliceType(typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' })));
+            return new SliceType(typeFromTypeInfoWithSeen(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen));
         case $.TypeKind.Struct:
-            return internType(StructType.createTypeFromFieldInfo(info));
+            return StructType.createTypeFromFieldInfo(info, seen);
         case $.TypeKind.Pointer:
-            return internType(new PointerType(typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' })));
+            return new PointerType(typeFromTypeInfoWithSeen(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen));
         default:
-            return internType(StructType.createTypeFromFieldInfo(info));
+            return StructType.createTypeFromFieldInfo(info, seen);
     }
 }
-function functionTypeFromInfo(info) {
-    if (info.name) {
-        return new FunctionType(info.name);
+function shallowTypeFromRegisteredInfo(name, info) {
+    switch (info.kind) {
+        case $.TypeKind.Interface:
+            return new InterfaceType(name, name, info.methods ?? []);
+        case $.TypeKind.Struct:
+            return new StructType(name, []);
+        case $.TypeKind.Function:
+            return new FunctionType({ name });
+        case $.TypeKind.Basic:
+            return StructType.createTypeFromFieldInfo({
+                kind: $.TypeKind.Basic,
+                name: info.name ?? 'unknown',
+                typeName: info.typeName ?? name,
+            });
+        default:
+            return StructType.createTypeFromFieldInfo(name);
     }
-    const params = info.params ?? [];
-    const paramTypes = params.map((param, index) => {
-        const typeName = functionSignatureTypeName(param);
-        if (!info.isVariadic || index !== params.length - 1) {
-            return typeName;
-        }
-        if (typeName.startsWith('[]')) {
-            return '...' + typeName.slice(2);
-        }
-        return '...' + typeName;
+}
+function functionTypeFromInfo(info, seen = new Set()) {
+    const params = (info.params ?? []).map((param) => typeFromTypeInfoWithSeen(param, seen));
+    const results = (info.results ?? []).map((result) => typeFromTypeInfoWithSeen(result, seen));
+    return new FunctionType({
+        name: info.name,
+        params,
+        results,
+        variadic: info.isVariadic ?? false,
     });
-    const resultTypes = (info.results ?? []).map(functionSignatureTypeName);
-    let signature = `func(${paramTypes.join(', ')})`;
-    if (resultTypes.length === 1) {
-        signature += ` ${resultTypes[0]}`;
+}
+function functionTypeInfoFromType(typ) {
+    const params = [];
+    for (let i = 0; i < typ.NumIn(); i++) {
+        params.push(typeInfoFromReflectType(typ.In(i)));
+    }
+    const results = [];
+    for (let i = 0; i < typ.NumOut(); i++) {
+        results.push(typeInfoFromReflectType(typ.Out(i)));
+    }
+    const info = {
+        kind: $.TypeKind.Function,
+        params,
+        results,
+    };
+    if (typ.Name() !== '') {
+        info.name = typ.String();
     }
-    if (resultTypes.length > 1) {
-        signature += ` (${resultTypes.join(', ')})`;
+    if (typ.IsVariadic()) {
+        info.isVariadic = true;
     }
-    return new FunctionType(signature);
+    return info;
 }
-function functionSignatureTypeName(info) {
-    return typeFromTypeInfo(info).String();
+export function typeInfoFromReflectType(typ) {
+    if (typ.PkgPath() !== '' && typ.Name() !== '') {
+        return typ.String();
+    }
+    switch (typ.Kind()) {
+        case Bool:
+        case Int:
+        case Int8:
+        case Int16:
+        case Int32:
+        case Int64:
+        case Uint:
+        case Uint8:
+        case Uint16:
+        case Uint32:
+        case Uint64:
+        case Uintptr:
+        case Float32:
+        case Float64:
+        case Complex64:
+        case Complex128:
+        case String:
+        case UnsafePointer:
+            return { kind: $.TypeKind.Basic, name: typ.String() };
+        case Interface:
+            return {
+                kind: $.TypeKind.Interface,
+                methods: typeMethods(typ).map((method) => ({
+                    name: method.name,
+                    args: method.args,
+                    returns: method.returns,
+                })),
+            };
+        case Slice:
+            return {
+                kind: $.TypeKind.Slice,
+                elemType: typeInfoFromReflectType(typ.Elem()),
+            };
+        case Array:
+            return {
+                kind: $.TypeKind.Array,
+                elemType: typeInfoFromReflectType(typ.Elem()),
+                length: typ.Len(),
+            };
+        case Ptr:
+            return {
+                kind: $.TypeKind.Pointer,
+                elemType: typeInfoFromReflectType(typ.Elem()),
+            };
+        case Map:
+            return {
+                kind: $.TypeKind.Map,
+                keyType: typeInfoFromReflectType(typ.Key()),
+                elemType: typeInfoFromReflectType(typ.Elem()),
+            };
+        case Chan:
+            return {
+                kind: $.TypeKind.Channel,
+                elemType: typeInfoFromReflectType(typ.Elem()),
+                direction: channelDirectionFromString(typ.String()),
+            };
+        case Func:
+            return functionTypeInfoFromType(typ);
+        case Struct: {
+            const fields = typ instanceof StructType ?
+                typ.descriptors()
+                : globalThis.Array.from({ length: typ.NumField() }, (_unused, idx) => {
+                    const field = typ.Field(idx);
+                    return {
+                        name: field.Name,
+                        key: structFieldStorageKey(typ, idx),
+                        type: field.Type,
+                        tag: field.Tag?.toString(),
+                        pkgPath: field.PkgPath,
+                        anonymous: field.Anonymous,
+                        index: [...field.Index],
+                        offset: field.Offset,
+                        exported: field.IsExported(),
+                    };
+                });
+            return {
+                kind: $.TypeKind.Struct,
+                name: typ.Name() === '' ? '' : typ.String(),
+                methods: [],
+                fields: fields.map((field) => ({
+                    name: field.name,
+                    key: field.key,
+                    type: typeInfoFromReflectType(field.type),
+                    ...(field.tag ? { tag: field.tag } : {}),
+                    ...(field.pkgPath ? { pkgPath: field.pkgPath } : {}),
+                    ...(field.anonymous ? { anonymous: true } : {}),
+                    index: [...field.index],
+                    offset: field.offset,
+                    exported: field.exported,
+                })),
+            };
+        }
+        default:
+            return typ.String();
+    }
 }
-function interfaceTypeFromInfo(info) {
-    if (info.methods.length === 0) {
-        return new InterfaceType('interface{}', info.name);
+function channelDirectionFromString(typeName) {
+    if (typeName.startsWith('<-chan ')) {
+        return 'receive';
+    }
+    if (typeName.startsWith('chan<- ')) {
+        return 'send';
+    }
+    return 'both';
+}
+function interfaceTypeFromInfo(info, seen = new Set()) {
+    const methods = info.methods ?? [];
+    if (methods.length === 0) {
+        return new InterfaceType('interface{}', info.name, methods);
+    }
+    return new InterfaceType(interfaceTypeString(methods, seen), info.name, methods);
+}
+function interfaceTypeString(methods, seen = new Set()) {
+    return `interface { ${methods
+        .map((method) => interfaceMethodString(method, seen))
+        .join('; ')} }`;
+}
+function interfaceMethodString(method, seen) {
+    const args = method.args.map((arg) => methodArgString(arg, seen)).join(', ');
+    const returns = method.returns.map((arg) => methodArgString(arg, seen));
+    if (returns.length === 0) {
+        return `${method.name}(${args})`;
+    }
+    if (returns.length === 1) {
+        return `${method.name}(${args}) ${returns[0]}`;
+    }
+    return `${method.name}(${args}) (${returns.join(', ')})`;
+}
+function structTypeInfoString(info, seen) {
+    if (info.name) {
+        return info.name;
+    }
+    const fields = info.fields ?? [];
+    if (fields.length === 0) {
+        return 'struct {}';
+    }
+    return `struct { ${fields
+        .map((field) => structFieldInfoString(field, seen))
+        .join('; ')} }`;
+}
+function structFieldInfoString(field, seen) {
+    const tag = field.tag ? ` ${JSON.stringify(field.tag)}` : '';
+    const prefix = field.anonymous ? '' : `${field.name} `;
+    return `${prefix}${typeInfoString(field.type, seen)}${tag}`;
+}
+function methodArgString(arg, seen) {
+    return typeInfoString(arg.type, seen);
+}
+function typeInfoString(info, seen) {
+    if (typeof info === 'string') {
+        return info;
+    }
+    switch (info.kind) {
+        case $.TypeKind.Basic:
+            return info.typeName ?? info.name ?? 'unknown';
+        case $.TypeKind.Interface: {
+            const name = info.name ?? '';
+            if (name !== '' && seen.has(name)) {
+                return name;
+            }
+            if (info.methods.length === 0) {
+                return 'interface{}';
+            }
+            if (name !== '') {
+                seen.add(name);
+            }
+            const text = interfaceTypeString(info.methods, seen);
+            if (name !== '') {
+                seen.delete(name);
+            }
+            return text;
+        }
+        case $.TypeKind.Struct:
+            return structTypeInfoString(info, seen);
+        case $.TypeKind.Pointer:
+            return `*${typeInfoString(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen)}`;
+        case $.TypeKind.Slice:
+            return `[]${typeInfoString(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen)}`;
+        case $.TypeKind.Array:
+            return `[${info.length}]${typeInfoString(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen)}`;
+        case $.TypeKind.Map:
+            return `map[${typeInfoString(info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen)}]${typeInfoString(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen)}`;
+        case $.TypeKind.Function: {
+            const params = (info.params ?? [])
+                .map((param) => typeInfoString(param, seen))
+                .join(', ');
+            const results = (info.results ?? []).map((result) => typeInfoString(result, seen));
+            if (results.length === 0) {
+                return `func(${params})`;
+            }
+            if (results.length === 1) {
+                return `func(${params}) ${results[0]}`;
+            }
+            return `func(${params}) (${results.join(', ')})`;
+        }
+        case $.TypeKind.Channel:
+            return `chan ${typeInfoString(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }, seen)}`;
+        default:
+            return 'unknown';
     }
-    return new InterfaceType(`interface { ${info.methods.map((method) => method.name + '()').join('; ')} }`, info.name);
 }
 function chanDirFromTypeInfo(direction) {
     switch (direction) {
@@ -2339,35 +3549,15 @@ function chanDirFromTypeInfo(direction) {
  */
 export function getInterfaceTypeByName(name) {
     const typeInfo = builtinGetTypeByName(name);
-    if (typeInfo && typeInfo.kind === TypeKind.Interface) {
-        return new InterfaceType(name, name);
+    if (typeInfo && isInterfaceTypeInfo(typeInfo)) {
+        return new InterfaceType(name, name, typeInfo.methods ?? []);
     }
     return new InterfaceType('interface{}');
 }
 export function getInterfaceLiteralTypeByName(name) {
     const typeInfo = builtinGetTypeByName(name);
-    if (typeInfo && typeInfo.kind === TypeKind.Interface) {
-        const methods = typeInfo.methods || [];
-        if (methods.length === 0) {
-            return new InterfaceType('interface{}', name);
-        }
-        const methodSigs = methods
-            .map((m) => {
-            const args = m.args
-                ?.map((a) => (typeof a === 'string' ? a : 'any'))
-                .join(', ') || '';
-            const returns = m.returns?.map((r) => typeof r === 'string' ? r : 'any');
-            let returnSig = '';
-            if (returns && returns.length === 1) {
-                returnSig = ` ${returns[0]}`;
-            }
-            else if (returns && returns.length > 1) {
-                returnSig = ` (${returns.join(', ')})`;
-            }
-            return `${m.name}(${args})${returnSig}`;
-        })
-            .join('; ');
-        return new InterfaceType(`interface { ${methodSigs} }`, name);
+    if (typeInfo && isInterfaceTypeInfo(typeInfo)) {
+        return interfaceTypeFromInfo(typeInfo);
     }
     return new InterfaceType('interface{}');
 }