@symbolica/agentica 0.2.11-rc

package/dist-transformer/warpc/frame-context/synthetic-resources/factory.js

@@ -0,0 +1,196 @@
+import { createLogger } from '../../../logging/index.js';
+import { CLASS_IDS, SystemContext } from '../../../warpc/msg-protocol/concept/resource/system-msg.js';
+export class SyntheticsFactory {
+    constructor(context, logger) {
+        this.logger = logger ?? createLogger(`factory:synthetics`);
+        this.context = context;
+    }
+    createSyntheticGenericType(msg, instance_of_generic, _typeArgs) {
+        const genericBaseName = SystemContext.getNameByUID(instance_of_generic) ?? `GenericAlias`;
+        const name = msg.payload.name ?? 'Object';
+        const synthCtor = class {
+            constructor(..._args) {
+                throw new Error(`Cannot instantiate generic alias ${name} of base type ${genericBaseName}`);
+            }
+        };
+        Object.defineProperty(synthCtor, 'name', {
+            value: name,
+            writable: false,
+            configurable: true,
+        });
+        Object.defineProperty(synthCtor, '__uid__', {
+            value: msg.uid,
+            writable: false,
+            configurable: true,
+        });
+        return synthCtor;
+    }
+    /**
+     * Create a synthetic class resource for an interface.
+     * Python will create Protocol classes from interfaces and needs to access attributes
+     * for introspection (inspect module, print_stubs, etc.).
+     */
+    createSyntheticClassForInterface(msg, name) {
+        const payload = msg.payload;
+        // Maybe turn this into a concrete class (if possible)
+        const { ctor: synthCtor, msgUp } = this.maybeMakeConcreteClass(msg);
+        // Set the class name
+        Object.defineProperty(synthCtor, 'name', {
+            value: name,
+            writable: false,
+            configurable: true,
+        });
+        // Add docstring if present
+        if (payload.doc) {
+            Object.defineProperty(synthCtor, '__doc__', {
+                value: payload.doc,
+                writable: false,
+                configurable: true,
+            });
+        }
+        // Add static field stubs
+        const clsMsg = msgUp ?? msg.asClass();
+        for (const field of clsMsg.getStaticFields()) {
+            // Create a getter that throws (Protocols shouldn't be instantiated)
+            Object.defineProperty(synthCtor, field.name, {
+                get() {
+                    throw new Error(`Cannot access field ${field.name} on Protocol ${name}`);
+                },
+                enumerable: false,
+                configurable: true,
+            });
+        }
+        // Add static method stubs
+        for (const [methodName] of clsMsg.getStaticMethods()) {
+            // Create a method stub that throws if called
+            const methodStub = function (..._args) {
+                throw new Error(`Cannot call method ${methodName} on Protocol ${name}`);
+            };
+            // Set method name
+            Object.defineProperty(methodStub, 'name', {
+                value: methodName,
+                writable: false,
+                configurable: true,
+            });
+            // Add to class
+            Object.defineProperty(synthCtor, methodName, {
+                value: methodStub,
+                writable: false,
+                enumerable: true,
+                configurable: true,
+            });
+        }
+        this.logger.debug(`Synthetic class for ${name}: ` +
+            `${clsMsg.getStaticFieldNames().length} static fields, ` +
+            `${clsMsg.getStaticMethodNames().length} static methods`);
+        if (msgUp)
+            return { ctor: synthCtor, msgUp };
+        else
+            return { ctor: synthCtor };
+    }
+    /**
+     * Create a synthetic class resource for an intersection type by merging
+     * fields and methods from its base classes/interfaces. Methods throw if called.
+     */
+    createSyntheticClassForIntersection(msg, name) {
+        // Intersection is a type-only construct; create an empty synthetic class
+        // with no own fields or methods so semantics rely on bases only.
+        const syntheticClass = class {
+        };
+        Object.defineProperty(syntheticClass, 'name', {
+            value: name,
+            writable: false,
+            configurable: true,
+        });
+        return syntheticClass;
+    }
+    maybeMakeConcreteClass(msg) {
+        const uid = msg.uid;
+        if (msg.asClass().getStaticFieldNames().length) {
+            this.logger.debug(`Interface class ${msg.payload.name} (uid=${uid.resource}) has static fields and is therefore not a concrete class`);
+            return { ctor: class {
+                } };
+        }
+        if (msg.asClass().getMethodNames().length) {
+            this.logger.debug(`Interface class ${msg.payload.name} (uid=${uid.resource}) has methods and is therefore not a concrete class`);
+            return { ctor: class {
+                } };
+        }
+        const nonOptionalFields = msg.asClass().getNonOptionalFields();
+        const optionalFields = msg.asClass().getOptionalFields();
+        const indexSignatures = msg.asClass().getIndexSignatures();
+        const { name: interfaceName } = msg.payload;
+        this.logger.debug(`Creating interface class ${interfaceName} (uid=${uid.resource})`);
+        function verifyKeyType(keyType, key) {
+            switch (keyType.uid.resource) {
+                case CLASS_IDS.String:
+                    if (typeof key !== 'string')
+                        throw new Error(`Key must be a string`);
+                    break;
+                case CLASS_IDS.Number:
+                    if (typeof key !== 'number')
+                        throw new Error(`Key must be a number`);
+                    break;
+                case CLASS_IDS.Symbol:
+                    if (typeof key !== 'symbol')
+                        throw new Error(`Key must be a symbol`);
+                    break;
+                default:
+                    throw new Error(`Unsupported index signature key type: ${keyType.uid.resource}`);
+            }
+        }
+        const classMsg = msg.asClass();
+        classMsg.payload.ctor_args = [];
+        // Populate ctor_args metadata
+        for (const signature of indexSignatures) {
+            classMsg.payload.ctor_args.push({
+                name: 'index_signature',
+                type: signature.map_type,
+            });
+        }
+        for (const field of nonOptionalFields) {
+            classMsg.payload.ctor_args.push({
+                name: field.name,
+                type: field.type,
+                default: field.default,
+                optional: field.is_optional,
+            });
+        }
+        for (const field of optionalFields) {
+            classMsg.payload.ctor_args.push({
+                name: field.name,
+                type: field.type,
+                default: field.default,
+                optional: field.is_optional,
+            });
+        }
+        // Make a concrete class (i.e. class that can be instantiated with a constructor)
+        const SyntheticCtor = class {
+            constructor(...args) {
+                let arg_position = 0;
+                // First read index signatures
+                for (const signature of indexSignatures) {
+                    const indexMap = args[arg_position++];
+                    for (const [key, value] of indexMap) {
+                        verifyKeyType(signature.key_type, key);
+                        this[key] = value;
+                    }
+                }
+                // Then read non-optional fields
+                for (const field of nonOptionalFields) {
+                    this[field.name] = args[arg_position++];
+                }
+                // Then read optional fields
+                for (const field of optionalFields) {
+                    this[field.name] = args[arg_position++];
+                }
+            }
+            static get [Symbol.species]() {
+                return interfaceName;
+            }
+        };
+        Object.defineProperty(SyntheticCtor, 'name', { value: interfaceName, enumerable: false });
+        Object.defineProperty(SyntheticCtor, '__uid__', { value: uid, enumerable: false });
+        return { ctor: SyntheticCtor, msgUp: classMsg };
+    }
+}

package/dist-transformer/warpc/frame-context/system-ctx.d.ts

@@ -0,0 +1,18 @@
+import { ClassContext, FrameContext, FunctionContext, ObjectContext } from './frame-ctx.js';
+import { UIDGenerator } from './uid-gen.js';
+export declare class SystemObjectContext extends ObjectContext {
+    readonly uidGenerator: UIDGenerator;
+    constructor(uidGenerator: UIDGenerator);
+}
+export declare class SystemClassContext extends ClassContext {
+    readonly uidGenerator: UIDGenerator;
+    constructor(uidGenerator: UIDGenerator);
+}
+export declare class SystemFunctionContext extends FunctionContext {
+    readonly uidGenerator: UIDGenerator;
+    constructor(uidGenerator: UIDGenerator);
+}
+export declare class SystemFrameContext extends FrameContext {
+    constructor(generator: UIDGenerator);
+}
+//# sourceMappingURL=system-ctx.d.ts.map

package/dist-transformer/warpc/frame-context/system-ctx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-ctx.d.ts","sourceRoot":"","sources":["../../../src/warpc/frame-context/system-ctx.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACzF,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAmEzC,qBAAa,mBAAoB,SAAQ,aAAa;aACtB,YAAY,EAAE,YAAY;gBAA1B,YAAY,EAAE,YAAY;CASzD;AAED,qBAAa,kBAAmB,SAAQ,YAAY;aACpB,YAAY,EAAE,YAAY;gBAA1B,YAAY,EAAE,YAAY;CASzD;AAuBD,qBAAa,qBAAsB,SAAQ,eAAe;aAC1B,YAAY,EAAE,YAAY;gBAA1B,YAAY,EAAE,YAAY;CASzD;AAED,qBAAa,kBAAmB,SAAQ,YAAY;gBACpC,SAAS,EAAE,YAAY;CAStC"}

package/dist-transformer/warpc/frame-context/system-ctx.js

@@ -0,0 +1,135 @@
+import { SystemContext } from '../msg-protocol/concept/resource/system-msg.js';
+import { AnnotationContext } from './annotation-ctx.js';
+import { ClassContext, FrameContext, FunctionContext, ObjectContext } from './frame-ctx.js';
+import { orUndefined } from '../../common.js';
+const withCustomCall = (cls, customCall) => {
+    const _Cls = cls;
+    const _NewCls = new Proxy(_Cls, {
+        apply(target, thisArg, args) {
+            return customCall(...args); // Called as function
+        },
+        construct(target, args, newTarget) {
+            // Called with `new`, forward to original constructor
+            return Reflect.construct(_Cls, args, newTarget);
+        },
+        get(target, prop, receiver) {
+            if (prop === 'toString') {
+                return Function.prototype.toString.bind(target);
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+    Object.getOwnPropertyNames(cls).forEach((prop) => {
+        if (prop === 'prototype')
+            return;
+        const desc = Object.getOwnPropertyDescriptor(_Cls, prop);
+        try {
+            Object.defineProperty(_NewCls, prop, desc);
+        }
+        catch {
+            // Ignore property definition errors for non-configurable properties
+        }
+    });
+    Object.getOwnPropertySymbols(_Cls).forEach((sym) => {
+        const desc = Object.getOwnPropertyDescriptor(String, sym);
+        try {
+            Object.defineProperty(_NewCls, sym, desc);
+        }
+        catch {
+            // Ignore symbol property definition errors
+        }
+    });
+    try {
+        Object.defineProperty(_NewCls, 'name', { value: _Cls.name });
+    }
+    catch {
+        // Ignore name property definition errors
+    }
+    const _Cls_prototype = _Cls.prototype;
+    try {
+        Object.setPrototypeOf(_NewCls, _Cls);
+    }
+    catch {
+        // Ignore prototype setting errors
+    }
+    try {
+        _NewCls.prototype = _Cls_prototype;
+    }
+    catch {
+        // Ignore prototype assignment errors
+    }
+    return _NewCls;
+};
+const _globalThis = Object.assign({}, globalThis);
+const _String = withCustomCall(String, (value) => {
+    // in place of `magicString`, return null for objects with no good string conversion.
+    const converted = String(value);
+    if (converted === '[object Object]' || value.toString == Object.prototype.toString)
+        return null;
+    return converted;
+});
+_globalThis.String = _String;
+export class SystemObjectContext extends ObjectContext {
+    constructor(uidGenerator) {
+        super(uidGenerator);
+        this.uidGenerator = uidGenerator;
+        for (const name of SystemContext.getObjectNames()) {
+            const uid = SystemContext.getUIDByName(this.world, name);
+            const realObj = orUndefined(_globalThis[name], globalThis[name]);
+            const msg = SystemContext.getObjectMsgByName(this.world, name);
+            if (uid && realObj !== undefined && msg)
+                this.setRecord(uid, realObj, msg);
+        }
+    }
+}
+export class SystemClassContext extends ClassContext {
+    constructor(uidGenerator) {
+        super(uidGenerator);
+        this.uidGenerator = uidGenerator;
+        for (const name of SystemContext.getClassNames()) {
+            const uid = SystemContext.getUIDByName(this.world, name);
+            const ctor = orUndefined(_globalThis[name], globalThis[name]);
+            const msg = SystemContext.getClassMsgByName(this.world, name);
+            if (uid && ctor !== undefined && msg)
+                this.setRecord(uid, ctor, msg);
+        }
+    }
+}
+function resolveGlobalPath(path) {
+    const parts = path.split('.');
+    let a = _globalThis;
+    let b = globalThis;
+    let receiver = undefined;
+    for (let i = 0; i < parts.length; i++) {
+        if (a === undefined && b === undefined)
+            return undefined;
+        receiver = orUndefined(a, b);
+        a = a?.[parts[i]];
+        b = b?.[parts[i]];
+    }
+    const current = orUndefined(a, b); // Prioritize `a` from `_globalThis`.
+    if (typeof current === 'function') {
+        if (receiver === globalThis)
+            return current;
+        return current.bind(receiver);
+    }
+    return current;
+}
+export class SystemFunctionContext extends FunctionContext {
+    constructor(uidGenerator) {
+        super(uidGenerator);
+        this.uidGenerator = uidGenerator;
+        for (const name of SystemContext.getFunctionNames()) {
+            const uid = SystemContext.getUIDByName(this.world, name);
+            const fn = resolveGlobalPath(name);
+            const msg = SystemContext.getFunctionMsgByName(this.world, name);
+            if (uid && fn !== undefined && msg)
+                this.setRecord(uid, fn, msg);
+        }
+    }
+}
+export class SystemFrameContext extends FrameContext {
+    constructor(generator) {
+        super(new SystemObjectContext(generator), new SystemClassContext(generator), new SystemFunctionContext(generator), new AnnotationContext(generator), generator);
+    }
+}

package/dist-transformer/warpc/frame-context/uid-gen.d.ts

@@ -0,0 +1,14 @@
+import type { DefnUID, World } from '../msg-protocol/kinds.js';
+/**
+ * UID generator for creating new resource IDs
+ * User types start at 0, system types use negative IDs
+ */
+export declare class UIDGenerator {
+    world: World;
+    private currentID;
+    constructor(world: World, startID?: number);
+    next(): DefnUID;
+    setmin(id: number): void;
+    share(): UIDGenerator;
+}
+//# sourceMappingURL=uid-gen.d.ts.map

package/dist-transformer/warpc/frame-context/uid-gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uid-gen.d.ts","sourceRoot":"","sources":["../../../src/warpc/frame-context/uid-gen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAEhE;;;GAGG;AACH,qBAAa,YAAY;IAIV,KAAK,EAAE,KAAK;IAHvB,OAAO,CAAC,SAAS,CAAS;gBAGf,KAAK,EAAE,KAAK,EACnB,OAAO,CAAC,EAAE,MAAM;IAKpB,IAAI,IAAI,OAAO;IAKf,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAKxB,KAAK,IAAI,YAAY;CAGxB"}

package/dist-transformer/warpc/frame-context/uid-gen.js

@@ -0,0 +1,22 @@
+/**
+ * UID generator for creating new resource IDs
+ * User types start at 0, system types use negative IDs
+ */
+export class UIDGenerator {
+    constructor(world, startID) {
+        this.world = world;
+        this.currentID = startID ?? 0;
+    }
+    next() {
+        this.currentID += 1;
+        return { world: this.world, resource: this.currentID };
+    }
+    setmin(id) {
+        if (id > this.currentID)
+            this.currentID = id;
+    }
+    // In the async model we keep a single generator per runtime; sharing simply returns itself.
+    share() {
+        return this;
+    }
+}

package/dist-transformer/warpc/frame-context/virtual-resources/default.d.ts

@@ -0,0 +1,16 @@
+import { FrameContext } from '../../frame-context/frame-ctx.js';
+import { ClassMsg } from '../../msg-protocol/concept/resource/class-msg.js';
+import { FunctionMsg } from '../../msg-protocol/concept/resource/function-msg.js';
+import { ObjectMsg } from '../../msg-protocol/concept/resource/object-msg.js';
+import { VirtualDispatcher, Virtualizer } from './virtualizer.js';
+export declare class DefaultVirtualizer implements Virtualizer {
+    readonly dispatcher: VirtualDispatcher;
+    readonly manager: FrameContext;
+    private logger;
+    private termDecoder;
+    constructor(dispatcher: VirtualDispatcher);
+    createVirtualObject(msg: ObjectMsg): any;
+    createVirtualClass(msg: ClassMsg): any;
+    createVirtualFunction(msg: FunctionMsg): any;
+}
+//# sourceMappingURL=default.d.ts.map

package/dist-transformer/warpc/frame-context/virtual-resources/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../src/warpc/frame-context/virtual-resources/default.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE9D,OAAO,EAAE,QAAQ,EAAE,MAAM,gDAAgD,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,mDAAmD,CAAC;AAChF,OAAO,EAAE,SAAS,EAAE,MAAM,iDAAiD,CAAC;AAG5E,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI/D,qBAAa,kBAAmB,YAAW,WAAW;aAKtB,UAAU,EAAE,iBAAiB;IAJzD,SAAgB,OAAO,EAAE,YAAY,CAAC;IACtC,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,WAAW,CAAc;gBAEL,UAAU,EAAE,iBAAiB;IAMzD,mBAAmB,CAAC,GAAG,EAAE,SAAS,GAAG,GAAG;IAgExC,kBAAkB,CAAC,GAAG,EAAE,QAAQ,GAAG,GAAG;IAuHtC,qBAAqB,CAAC,GAAG,EAAE,WAAW,GAAG,GAAG;CAgB/C"}

package/dist-transformer/warpc/frame-context/virtual-resources/default.js

@@ -0,0 +1,196 @@
+import { throwNoVirtualization } from '../../../coming-soon.js';
+export class DefaultVirtualizer {
+    constructor(dispatcher) {
+        this.dispatcher = dispatcher;
+        this.manager = dispatcher.owner.context;
+        this.termDecoder = dispatcher.owner.conceptDecoder;
+        this.logger = dispatcher.owner.logger.withScope('virtualizer');
+    }
+    createVirtualObject(msg) {
+        throwNoVirtualization();
+        const uid = msg.uid;
+        const keys = msg.payload?.keys || [];
+        const clsUuid = msg.payload.cls.uid;
+        const clsMsg = this.manager.getMessageFromUID(clsUuid);
+        if (!clsMsg) {
+            this.logger.error(`Cannot create virtual object without class (uid=${uid.resource})`);
+            throw new Error('Cannot create virtual object without class');
+        }
+        const fields = clsMsg.getInstanceFieldNames();
+        const methods = clsMsg.getInstanceMethodNames();
+        this.logger.debug(`Creating virtual object (uid=${uid.resource}, fields=${fields.length}, methods=${methods.length})`);
+        const jsClass = this.termDecoder.decodeWithCtx(clsMsg);
+        const target = Object.create(jsClass.prototype);
+        return new Proxy(target, {
+            get: (_t, prop) => {
+                if (prop === '__uid__')
+                    return uid;
+                if (typeof prop === 'string') {
+                    if (fields.includes(prop)) {
+                        return this.dispatcher.virtualGetAttr(uid, prop);
+                    }
+                    if (methods.includes(prop)) {
+                        return (...args) => this.dispatcher.virtualMethodCall(uid, prop, args);
+                    }
+                }
+                return undefined;
+            },
+            set: (_t, prop, value) => {
+                if (typeof prop === 'string') {
+                    if (fields.includes(prop)) {
+                        this.dispatcher.virtualSetAttr(uid, prop, value);
+                        return true;
+                    }
+                }
+                return false;
+            },
+            has: (_t, prop) => {
+                if (typeof prop === 'string') {
+                    // Virtual object attribute checking for string props
+                    throw new Error('Virtual object attribute check for string properties is not yet supported');
+                }
+                return false;
+            },
+            deleteProperty: (_t, prop) => {
+                if (typeof prop === 'string') {
+                    this.dispatcher.virtualDelAttr(uid, prop);
+                    return true;
+                }
+                return false;
+            },
+            ownKeys: () => {
+                return Array.from(new Set(['__uid__', ...keys]));
+            },
+            getOwnPropertyDescriptor: () => ({
+                configurable: true,
+                enumerable: true,
+            }),
+        });
+    }
+    createVirtualClass(msg) {
+        throwNoVirtualization();
+        const uid = msg.uid;
+        const { name: className } = msg.payload;
+        this.logger.debug(`Creating virtual class ${className} (uid=${uid.resource})`);
+        const staticFields = msg.getStaticFieldNames();
+        const staticMethods = msg.getStaticMethodNames();
+        const baseRefs = msg.getBases();
+        // Resolve runtime constructors for bases (if any)
+        const resolvedBases = baseRefs
+            .map((ref) => this.manager.classes.getResourceFromUID(ref.uid))
+            .filter((b) => !!b);
+        const PrimaryBase = resolvedBases[0] ?? Object;
+        const virtualDispatchLogger = this.logger;
+        const virtualDispatcher = this.dispatcher;
+        const VirtualClass = class extends PrimaryBase {
+            constructor(...args) {
+                super();
+                virtualDispatchLogger.debug(`Virtual class constructor (uid=${uid.resource}, args=`, args);
+                this._instance = virtualDispatcher.virtualNew(uid, args, msg.payload.system_resource);
+                const instance = this._instance;
+                return new Proxy(this, {
+                    get: (target, prop) => {
+                        if (prop === '__uid__')
+                            return uid;
+                        if (prop === 'name')
+                            return className;
+                        if (prop in target) {
+                            return Reflect.get(target, prop);
+                        }
+                        return instance.then((inst) => inst[prop]);
+                    },
+                    set: (target, prop, value, receiver) => {
+                        if (prop in target) {
+                            return Reflect.set(target, prop, value, receiver);
+                        }
+                        instance.then((inst) => (inst[prop] = value));
+                        return true;
+                    },
+                });
+            }
+            static get [Symbol.species]() {
+                return className;
+            }
+        };
+        Object.defineProperty(VirtualClass, 'name', { value: className, enumerable: false });
+        Object.defineProperty(VirtualClass, '__uid__', { value: uid, enumerable: false });
+        // Wire static fields through dispatcher
+        for (const fieldName of staticFields) {
+            this.logger.debug(`Wiring static field ${fieldName} to virtual class ${className}`);
+            Object.defineProperty(VirtualClass, fieldName, {
+                configurable: true,
+                enumerable: true,
+                get() {
+                    return virtualDispatcher.virtualGetAttr(uid, fieldName);
+                },
+                set(value) {
+                    virtualDispatcher.virtualSetAttr(uid, fieldName, value);
+                },
+            });
+        }
+        // Wire static methods through dispatcher
+        for (const methodName of staticMethods) {
+            this.logger.debug(`Wiring static method ${methodName} to virtual class ${className}`);
+            Object.defineProperty(VirtualClass, methodName, {
+                configurable: true,
+                enumerable: true,
+                value: (...args) => virtualDispatcher.virtualMethodCall(uid, methodName, args),
+            });
+        }
+        // Best-effort mixin of additional bases (static and prototype members)
+        for (const mixinBase of resolvedBases.slice(1)) {
+            this.logger.debug(`Adding mixin base ${mixinBase.name} to virtual class ${className}`);
+            // Copy static properties
+            for (const key of Object.getOwnPropertyNames(mixinBase)) {
+                if (key === 'prototype' || key === 'name' || key === 'length')
+                    continue;
+                if (Object.prototype.hasOwnProperty.call(VirtualClass, key))
+                    continue;
+                const desc = Object.getOwnPropertyDescriptor(mixinBase, key);
+                if (desc) {
+                    try {
+                        Object.defineProperty(VirtualClass, key, desc);
+                    }
+                    catch {
+                        // Ignore property definition errors for mixin bases
+                    }
+                }
+            }
+            // Copy prototype methods
+            const proto = mixinBase?.prototype ?? {};
+            for (const key of Object.getOwnPropertyNames(proto)) {
+                if (key === 'constructor')
+                    continue;
+                if (Object.prototype.hasOwnProperty.call(VirtualClass.prototype, key))
+                    continue;
+                const desc = Object.getOwnPropertyDescriptor(proto, key);
+                if (desc) {
+                    try {
+                        Object.defineProperty(VirtualClass.prototype, key, desc);
+                    }
+                    catch {
+                        // Ignore prototype property definition errors for mixin bases
+                    }
+                }
+            }
+        }
+        this.logger.debug(`Creating virtual class ${className} (uid=${uid.resource}, bases=${baseRefs.length}, primary=${PrimaryBase.name || 'Object'})`);
+        return VirtualClass;
+    }
+    createVirtualFunction(msg) {
+        throwNoVirtualization();
+        const uid = msg.uid;
+        const fnTarget = function () { };
+        this.logger.debug(`Creating virtual function ${msg.payload.name} (uid=${uid.resource})`);
+        return new Proxy(fnTarget, {
+            get: (_t, prop) => {
+                if (prop === '__uid__')
+                    return uid;
+                return undefined;
+            },
+            apply: (_t, _thisArg, args) => {
+                return this.dispatcher.virtualFunctionCall(uid, args);
+            },
+        });
+    }
+}

package/dist-transformer/warpc/frame-context/virtual-resources/dispatcher.d.ts

@@ -0,0 +1,17 @@
+import { Frame } from '../../frame.js';
+import { DefnUID } from '../../msg-protocol/kinds.js';
+import { RpcHandler } from '../../rpc-channel/handler.js';
+import { VirtualDispatcher } from './virtualizer.js';
+export declare class DefaultVirtualDispatcher extends VirtualDispatcher {
+    private logger;
+    constructor(owner: Frame);
+    setRpcHandler(handler: RpcHandler): void;
+    virtualNew(uid: DefnUID, args: any[], systemResource: boolean): Promise<any>;
+    virtualFunctionCall(functionID: DefnUID, args: any[]): Promise<any>;
+    virtualMethodCall(ownerID: DefnUID, methodName: string, args: any[]): Promise<any>;
+    virtualSetAttr(uid: DefnUID, name: string, value: any): Promise<void>;
+    virtualGetAttr(uid: DefnUID, name: string): Promise<any>;
+    virtualHasAttr(uid: DefnUID, name: string): Promise<boolean>;
+    virtualDelAttr(_uid: DefnUID, _name: string): Promise<void>;
+}
+//# sourceMappingURL=dispatcher.d.ts.map

package/dist-transformer/warpc/frame-context/virtual-resources/dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../../../../src/warpc/frame-context/virtual-resources/dispatcher.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAMrC,OAAO,EAAe,OAAO,EAAW,MAAM,2BAA2B,CAAC;AAU1E,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAExD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElD,qBAAa,wBAAyB,SAAQ,iBAAiB;IAC3D,OAAO,CAAC,MAAM,CAAe;gBAEjB,KAAK,EAAE,KAAK;IAKxB,aAAa,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI;IAIlC,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,cAAc,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC;IAsD5E,mBAAmB,CAAC,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC;IA+CnE,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC;IAoElF,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCrE,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAgCxD,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAW5D,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGpE"}