@symbolica/agentica 0.2.11-rc

package/dist-transformer/warpc/frame.js

@@ -0,0 +1,417 @@
+import { FrameContext } from './frame-context/frame-ctx.js';
+import { TermDecoder } from './frame-context/message-conversion/decoder.js';
+import { TermEncoder } from './frame-context/message-conversion/encoder.js';
+import { SyntheticsFactory } from './frame-context/synthetic-resources/factory.js';
+import { SystemFrameContext } from './frame-context/system-ctx.js';
+import { DefaultVirtualizer } from './frame-context/virtual-resources/default.js';
+import { DefaultVirtualDispatcher } from './frame-context/virtual-resources/dispatcher.js';
+import { equalUid } from './msg-protocol/concept/concept.js';
+import { rehydrateMsg } from './msg-protocol/concept/rehydrate.js';
+import { ClassMsg } from './msg-protocol/concept/resource/class-msg.js';
+import { FunctionMsg } from './msg-protocol/concept/resource/function-msg.js';
+import { ConceptKind } from './msg-protocol/kinds.js';
+import { RpcHandler } from './rpc-channel/handler.js';
+import { throwNoBareFutures } from '../coming-soon.js';
+export class FrameTree {
+    constructor() {
+        this.frames = new Map();
+        this.childMap = new Map();
+        this.parentMap = new Map();
+    }
+    push(parentFrameID, frame) {
+        this.frames.set(frame.frameID, frame);
+        if (parentFrameID) {
+            const children = this.childMap.get(parentFrameID);
+            if (!children) {
+                this.childMap.set(parentFrameID, new Set([frame.frameID]));
+            }
+            else {
+                children.add(frame.frameID);
+            }
+            this.parentMap.set(frame.frameID, parentFrameID);
+        }
+    }
+    pop(frameID) {
+        const frame = this.frames.get(frameID);
+        if (!frame) {
+            return undefined;
+        }
+        this.frames.delete(frameID);
+        const parentFrameID = this.parentMap.get(frameID);
+        if (parentFrameID) {
+            this.childMap.get(parentFrameID)?.delete(frameID);
+        }
+        this.parentMap.delete(frameID);
+        return frame;
+    }
+}
+export class Frame {
+    constructor(runtime, frameID, parent) {
+        this.encodingDepth = 3;
+        this.replBuffer = new Map();
+        this.runtime = runtime;
+        this.frameID = frameID;
+        this.parentFrame = parent;
+        this.logger = runtime.logger.withScope(`frame-${frameID}`);
+        // The core of a frame: definition context
+        const parentCtx = parent?.context || new SystemFrameContext(this.runtime.uidGenerator);
+        this.uidGenerator = parentCtx.uidGenerator.share();
+        this.context = FrameContext.newFromParent(parentCtx, this.frameID, this.uidGenerator);
+        // Encoding/decoding + virtualization
+        this.rpcHandler = new RpcHandler(this);
+        this.dispatcher = new DefaultVirtualDispatcher(this);
+        this.dispatcher.setRpcHandler(this.rpcHandler);
+        this.virtualizer = new DefaultVirtualizer(this.dispatcher);
+        this.syntheticsFactory = new SyntheticsFactory(this.context);
+        this.conceptEncoder = new TermEncoder(this.context);
+        this.conceptDecoder = new TermDecoder(this.virtualizer, this.context);
+        this.logger.debug(`Frame ${frameID} initialized (parent=${parent?.frameID ?? 'none'})`);
+    }
+    toMsg(concept) {
+        const message = this.conceptEncoder.encodeWithCtx(concept, this.encodingDepth);
+        return message;
+    }
+    fromMsg(msg) {
+        return this.conceptDecoder.decodeWithCtx(msg);
+    }
+    generateUID() {
+        return this.uidGenerator.next();
+    }
+    ingestLocals(compilerContext) {
+        const span = this.logger.startSpan(`ingestLocals-${this.frameID}`);
+        try {
+            const classes = new Map();
+            const functions = new Map();
+            const objects = new Map();
+            const annotations = new Map();
+            const synthetics = [];
+            // Step 0: parse the context and reconstruct resources
+            const parsedContext = new Map();
+            for (const [uidAsString, entry] of Object.entries(compilerContext)) {
+                // Parsing
+                const uid = {
+                    world: this.runtime.world,
+                    resource: parseInt(uidAsString),
+                };
+                this.uidGenerator.setmin(uid.resource);
+                let resource;
+                try {
+                    resource = entry.defGetter ?? undefined;
+                }
+                catch (error) {
+                    this.logger.error(`Error getting resource for ${uidAsString}: ${error}`);
+                    resource = undefined;
+                }
+                const parsedMsg = JSON.parse(entry.defMsg);
+                const rehydratedMsg = parsedMsg.kind ? rehydrateMsg(parsedMsg) : parsedMsg; // kind should exist
+                parsedContext.set(uid, [rehydratedMsg, entry.defName, resource]);
+            }
+            // Step 1: Reconstruct resources and sort by kind
+            for (const [uid, [msg, name, resource]] of parsedContext) {
+                let kind = ConceptKind.fromStr(msg.kind);
+                if (!kind) {
+                    this.logger.warn(`Unsupported kind: ${msg.kind}`);
+                    continue;
+                }
+                // Resource reconstruction
+                let updatedResource = resource;
+                let updatedMsg = msg;
+                if (!resource) {
+                    // Generics (like Person[]) -> synthetic generic resource
+                    if (kind === ConceptKind.Resource.Cls) {
+                        if (updatedMsg.payload?.instance_of_generic) {
+                            updatedResource = this.syntheticsFactory.createSyntheticGenericType(updatedMsg, updatedMsg.payload.instance_of_generic, updatedMsg.payload.type_args ?? []);
+                            this.logger.debug(`Created synthetic generic for ${name}`);
+                        }
+                        else {
+                            // Found a non-generic class without resource -> demote to interface!
+                            updatedMsg = ClassMsg.createInterfaceMsg(uid, updatedMsg.payload);
+                            kind = ConceptKind.Annotation.Interface;
+                            this.logger.debug(`Converting non-generic class ${name} to interface (setting kind=${kind})`);
+                        }
+                    }
+                    // Interfaces -> synthetic runtime class resource only (do not emit as ClassMsg def)
+                    if (kind === ConceptKind.Annotation.Interface) {
+                        const { ctor: syntheticClass, msgUp } = this.syntheticsFactory.createSyntheticClassForInterface(updatedMsg, name);
+                        updatedResource = syntheticClass;
+                        // Some interfaces get promoted to classes
+                        if (msgUp) {
+                            synthetics.push(uid);
+                            updatedMsg = msgUp;
+                            kind = ConceptKind.Resource.Cls;
+                        }
+                        this.logger.debugObject(`Created synthetic class for interface ${name} promoted to class?`, msgUp ? msgUp : 'no');
+                    }
+                    // Intersections -> synthetic runtime class resource only (may emit as ClassMsg def)
+                    if (kind === ConceptKind.Annotation.Intersection) {
+                        updatedResource = this.syntheticsFactory.createSyntheticClassForIntersection(updatedMsg, name);
+                        this.logger.debug(`Created synthetic class for intersection ${name}`);
+                    }
+                }
+                // Sort by kind
+                switch (kind) {
+                    case ConceptKind.Resource.Cls:
+                        classes.set(uid, [updatedMsg, name, updatedResource]);
+                        break;
+                    case ConceptKind.Resource.Func:
+                        functions.set(uid, [updatedMsg, name, updatedResource]);
+                        break;
+                    case ConceptKind.Resource.Obj:
+                        objects.set(uid, [updatedMsg, name, updatedResource]);
+                        break;
+                    case ConceptKind.Annotation.Union:
+                    case ConceptKind.Annotation.Intersection:
+                    case ConceptKind.Annotation.MemberSig:
+                    case ConceptKind.Annotation.Interface:
+                        annotations.set(uid, [updatedMsg, name]);
+                        break;
+                }
+            }
+            // Step: 2: Process by kind
+            this.logger.debug(`Ingesting: ${classes.size} classes, ${functions.size} functions, ${objects.size} objects, ${annotations.size} annotations`);
+            // Process constructor objects (classes)
+            for (const [uid, [clsMsg, name, resource]] of classes) {
+                this.logger.debug(`Ingesting class ${name} with uid ${uid.resource}`);
+                this.context.classes.setRecord(uid, resource, clsMsg);
+                this.setLocal(name, clsMsg);
+            }
+            // Process annotations
+            for (const [uid, [annMsg, name]] of annotations) {
+                this.logger.debug(`Ingesting annotation ${name} with uid ${uid.resource}`);
+                this.context.annotations.setRecord(uid, annMsg);
+                this.setLocal(name, annMsg);
+            }
+            // Process function objects
+            for (const [uid, [funcMsg, name, resource]] of functions) {
+                this.logger.debug(`Ingesting function ${name} with uid ${uid.resource}`);
+                this.context.functions.setRecord(uid, resource, funcMsg);
+                this.setLocal(name, funcMsg);
+            }
+            // Process objects
+            for (const [uid, [objMsg, name, resource]] of objects) {
+                const clsMsg = this.context.getMessageFromUID(objMsg.payload.cls.uid);
+                const isSyntheticClass = !!clsMsg && synthetics.includes(clsMsg.uid);
+                this.logger.debug(`Ingesting object ${name} with uid ${uid.resource} of type ${clsMsg?.kind} where function? ${clsMsg?.isFunction()}, annotation? ${clsMsg?.isAnnotation()}, synthetic class? ${isSyntheticClass}, container? ${clsMsg?.isContainer()}, primitive? ${clsMsg?.isPrimitive()}, literal? ${clsMsg?.isLiteral()}, object? ${clsMsg?.isObject()}`);
+                // Case function: Turn into an actual FunctionMsg
+                if (clsMsg?.isFunction()) {
+                    const embeddedFuncMsg = clsMsg.payload.supplied_type_args;
+                    const funcMsg = new FunctionMsg(uid, {
+                        ...embeddedFuncMsg.payload,
+                        is_top_level: objMsg.payload?.is_top_level,
+                    });
+                    funcMsg.payload.name = name;
+                    this.context.functions.setRecord(uid, resource, funcMsg);
+                    this.setLocal(name, funcMsg);
+                    // Assumption: actual function objects : function types = 1 : 1 ... only need former
+                    const functionTypeName = clsMsg.payload.name ?? '';
+                    if (this.replBuffer.has(functionTypeName)) {
+                        this.replBuffer.delete(functionTypeName); // leave in context for now, no harm
+                    }
+                    this.logger.debug(`Converted function object ${name} to FunctionMsg`);
+                }
+                // Case annotation (or synthetic class): Re-encode to use the actual class of the object
+                else if (clsMsg?.isAnnotation() || isSyntheticClass) {
+                    const nestedDefs = [];
+                    const actualMsg = this.conceptEncoder.tryEncodeAnnotatedObject(resource, uid, this.encodingDepth, nestedDefs, clsMsg, isSyntheticClass);
+                    if (actualMsg) {
+                        let nestedDefCounter = 0;
+                        for (const def of nestedDefs) {
+                            this.setLocal(`__${name}_Def${nestedDefCounter}`, def);
+                            nestedDefCounter++;
+                        }
+                        this.context.objects.setRecord(uid, resource, actualMsg); // redundant
+                        this.setLocal(name, actualMsg);
+                        this.logger.debug(`Re-encoded annotation ${name} with ${nestedDefs.length} nested defs`);
+                    }
+                }
+                // Case container/primitive: Encode the actual object, do NOT set record
+                else if (clsMsg?.isContainer() || clsMsg?.isPrimitive() || clsMsg?.isLiteral()) {
+                    const nestedDefs = [];
+                    const actualMsg = this.conceptEncoder.encodeWithCtx(resource, this.encodingDepth, nestedDefs, clsMsg);
+                    let nestedObjCounter = 0;
+                    for (const def of nestedDefs) {
+                        this.setLocal(`__${name}_auxiliaryDef_${nestedObjCounter}`, def);
+                        nestedObjCounter++;
+                    }
+                    this.logger.debug(`Encoded container/primitive ${name} with ${nestedDefs.length} nested defs`);
+                    // omit setting a resource record!!
+                    this.setLocal(name, actualMsg); // but do set the local
+                }
+                // Case future object: unsupported for now!
+                else if (clsMsg?.isFuture()) {
+                    throwNoBareFutures();
+                }
+                // Case Any or Object: best effort is to re-encode!
+                else if (clsMsg?.isAny() || clsMsg?.isObject()) {
+                    const nestedDefs = [];
+                    const actualMsg = this.conceptEncoder.encodeObject(resource, uid, this.encodingDepth, undefined, nestedDefs);
+                    let nestedObjCounter = 0;
+                    for (const def of nestedDefs) {
+                        this.setLocal(`__${name}_auxiliaryDef_${nestedObjCounter}`, def);
+                        nestedObjCounter++;
+                    }
+                    this.logger.debug(`Re-encoded Any object ${name} with ${nestedDefs.length} nested defs`);
+                    if (ConceptKind.isResourceMsg(actualMsg)) {
+                        this.context.objects.setRecord(uid, resource, actualMsg);
+                    }
+                    this.setLocal(name, actualMsg);
+                }
+                // Case regular object: Set record
+                else {
+                    this.context.objects.setRecord(uid, resource, objMsg);
+                    this.setLocal(name, objMsg);
+                }
+            }
+            this.logger.debug(`Ingested ${this.replBuffer.size} locals`);
+        }
+        catch (error) {
+            span.recordException(error);
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    setLocal(name, msg) {
+        if (this.replBuffer.has(name)) {
+            const existing = this.replBuffer.get(name);
+            // Check if it's the same resource (by UID) - if so, skip duplicate
+            if (existing &&
+                'uid' in existing &&
+                'uid' in msg &&
+                existing.uid.world === msg.uid.world &&
+                existing.uid.resource === msg.uid.resource) {
+                this.logger.debug(`Skipping duplicate local ${name} with same UID ${msg.uid.resource}`);
+                return;
+            }
+            // Different resource with same name - create overload
+            const overload_name = `${name}_overload${this.replBuffer.size}`;
+            this.logger.warn(`Local ${name} already exists with different UID, using ${overload_name}`);
+            this.replBuffer.set(overload_name, msg);
+        }
+        else {
+            this.replBuffer.set(name, msg);
+        }
+    }
+    resetReplBuffer() {
+        this.replBuffer.clear();
+    }
+    passContextFromRemoteDefs(msgs) {
+        /*
+         * If a remote sends us some defs, we need to add them to our context
+         */
+        for (const msg of msgs) {
+            this.conceptDecoder.decodeWithCtx(msg);
+        }
+    }
+    passContextFromOtherFrame(other, msg, defs) {
+        /*
+         * If another frame returns to us, then we needs to keep some of its
+         * concepts in our frame... walk defs recursively!
+         */
+        this.logger.debug(`Passing context from other frame: ${msg.kind}`);
+        if (!!msg.uid && !!this.context.getMessageFromUID(msg.uid)) {
+            // We already know about this concept
+            return;
+        }
+        this.logger.debug(`Passing context from other frame: ${msg.kind} - dereferencing`);
+        // Dereference
+        if (msg.kind === ConceptKind.Reference.Ref) {
+            const cachedMsg = other.context.getMessageFromUID(msg.uid);
+            if (!cachedMsg) {
+                throw new Error('got uncached ref msg');
+            }
+            msg = cachedMsg;
+            defs?.push(msg);
+        }
+        // Recursive depending on message kind
+        const kind = msg.kind;
+        switch (kind) {
+            case ConceptKind.Annotation.MemberSig: {
+                const uid = msg.uid;
+                this.context.annotations.setRecord(uid, msg);
+                if (defs && !defs.some((def) => equalUid(def.uid, uid))) {
+                    defs.push(msg);
+                }
+                break;
+            }
+            case ConceptKind.Resource.Func: {
+                const uid = msg.uid;
+                const func = other.context.getResourceFromUID(uid);
+                this.context.functions.setRecord(uid, func, msg);
+                if (defs && !defs.some((def) => equalUid(def.uid, uid))) {
+                    defs.push(msg);
+                }
+                break;
+            }
+            case ConceptKind.Resource.Obj: {
+                const uid = msg.uid;
+                const obj = other.context.getResourceFromUID(uid);
+                this.context.objects.setRecord(uid, obj, msg);
+                if (defs && !defs.some((def) => equalUid(def.uid, uid))) {
+                    defs.push(msg);
+                }
+                // Recurse to object's class
+                if (msg.payload?.cls) {
+                    this.passContextFromOtherFrame(other, msg.payload.cls, defs);
+                }
+                break;
+            }
+            case ConceptKind.Resource.Cls: {
+                const uid = msg.uid;
+                const cls = other.context.getResourceFromUID(uid);
+                this.context.classes.setRecord(uid, cls, msg);
+                if (defs && !defs.some((def) => equalUid(def.uid, uid))) {
+                    defs.push(msg);
+                }
+                // Recurse into methods
+                for (const method of msg.payload?.methods ?? []) {
+                    this.passContextFromOtherFrame(other, method.function, defs);
+                }
+                // Recurse into bases
+                for (const base of msg.payload?.bases ?? []) {
+                    this.passContextFromOtherFrame(other, base, defs);
+                }
+                // Recurse into type args
+                if (Array.isArray(msg.payload?.supplied_type_args)) {
+                    for (const arg of msg.payload?.supplied_type_args) {
+                        this.passContextFromOtherFrame(other, arg.type, defs);
+                    }
+                }
+                // TODO: recurse into ctor args etc. ... or uniformize the recursive reference crawling for all messages :-)
+                break;
+            }
+            case ConceptKind.Container.Set:
+            case ConceptKind.Container.Array:
+            case ConceptKind.Container.Tuple: {
+                for (const item of msg.val) {
+                    const derefedItem = other.context.derefValueOrMsg(item);
+                    this.passContextFromOtherFrame(other, derefedItem, defs);
+                }
+                break;
+            }
+            case ConceptKind.Container.Map: {
+                const items = [...msg.val.keys, ...msg.val.vals];
+                this.logger.debug(`Passing context from other frame: ${kind} - ${items.length} items`);
+                for (const item of items) {
+                    const derefedItem = other.context.derefValueOrMsg(item);
+                    this.passContextFromOtherFrame(other, derefedItem, defs);
+                }
+                break;
+            }
+            case ConceptKind.Annotation.Union:
+            case ConceptKind.Annotation.Intersection:
+            case ConceptKind.Annotation.Interface:
+                throw new Error('Cannot ingest non-value types at runtime');
+            case ConceptKind.Atom.Bool:
+            case ConceptKind.Atom.Int:
+            case ConceptKind.Atom.Float:
+            case ConceptKind.Atom.Str:
+            case ConceptKind.Atom.Bytes:
+            case ConceptKind.Atom.None:
+                // Nothing to do
+                this.logger.debug(`Passing context from other frame: ${kind} - nothing to do`);
+                break;
+        }
+    }
+}

package/dist-transformer/warpc/msg-protocol/concept/annotations/annotation-msg.d.ts

@@ -0,0 +1,68 @@
+import { ConceptMsg, RefMsg } from '../../../msg-protocol/concept/concept.js';
+import { ClassMsg, ClassPayload } from '../../../msg-protocol/concept/resource/class-msg.js';
+import { FunctionPayload } from '../../../msg-protocol/concept/resource/function-msg.js';
+import { ConceptKind, DefnUID, Membership } from '../../../msg-protocol/kinds.js';
+export type Resource = any;
+export type EncFields = Iterable<[string, any]>;
+export type DecFields = Iterable<[string, any]>;
+/**
+ * ABC for messages describing concepts that can pass through a frame by reference.
+ * Resources can only be interacted with via RPC.
+ */
+export declare abstract class AnnotationMsg extends ConceptMsg {
+    readonly kind: ConceptKind.Annotation;
+    readonly uid: DefnUID;
+    readonly payload?: any | undefined;
+    constructor(kind: ConceptKind.Annotation, uid: DefnUID, payload?: any | undefined);
+    abstract referentialize(): RefMsg<this>;
+    get isDef(): true;
+    isFuture(): boolean;
+    isContainer(): boolean;
+    isLiteral(): boolean;
+    isEnum(): boolean;
+    isPrimitive(): boolean;
+    isObject(): boolean;
+    isAny(): boolean;
+    isFunction(): boolean;
+    isError(): boolean;
+    isAnnotation(): boolean;
+    isUnion(): boolean;
+    isIntersection(): boolean;
+    isInterface(): boolean;
+    isMemberSig(): boolean;
+    static rehydrate(msg: AnnotationMsg | any): AnnotationMsg;
+}
+interface UnionPayload {
+    classes: RefMsg<ClassMsg>[];
+}
+export declare class UnionMsg extends AnnotationMsg {
+    readonly payload: UnionPayload;
+    constructor(uid: DefnUID, payload: UnionPayload);
+    referentialize(): RefMsg<UnionMsg>;
+    static rehydrate(msg: UnionMsg | any): UnionMsg;
+}
+interface IntersectionPayload {
+    classes: RefMsg<ClassMsg>[];
+}
+export declare class IntersectionMsg extends AnnotationMsg {
+    readonly payload: IntersectionPayload;
+    constructor(uid: DefnUID, payload: IntersectionPayload);
+    referentialize(): RefMsg<IntersectionMsg>;
+    static rehydrate(msg: IntersectionMsg | any): IntersectionMsg;
+}
+export declare class InterfaceMsg extends AnnotationMsg {
+    readonly payload: ClassPayload;
+    constructor(uid: DefnUID, payload: ClassPayload);
+    referentialize(): RefMsg<InterfaceMsg>;
+    static rehydrate(msg: InterfaceMsg | any): InterfaceMsg;
+    asClass(): ClassMsg;
+}
+export declare class MethodSignatureMsg extends AnnotationMsg {
+    readonly methodOf: Membership;
+    readonly payload: FunctionPayload;
+    constructor(uid: DefnUID, methodOf: Membership, payload: FunctionPayload);
+    referentialize(): RefMsg<MethodSignatureMsg>;
+    static rehydrate(msg: MethodSignatureMsg | any): MethodSignatureMsg;
+}
+export {};
+//# sourceMappingURL=annotation-msg.d.ts.map

package/dist-transformer/warpc/msg-protocol/concept/annotations/annotation-msg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotation-msg.d.ts","sourceRoot":"","sources":["../../../../../src/warpc/msg-protocol/concept/annotations/annotation-msg.ts"],"names":[],"mappings":"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"}

package/dist-transformer/warpc/msg-protocol/concept/annotations/annotation-msg.js

@@ -0,0 +1,135 @@
+import { ConceptMsg, RefMsg } from '../../../msg-protocol/concept/concept.js';
+import { rehydrateMsg } from '../../../msg-protocol/concept/rehydrate.js';
+import { ClassMsg } from '../../../msg-protocol/concept/resource/class-msg.js';
+import { ConceptKind } from '../../../msg-protocol/kinds.js';
+/**
+ * ABC for messages describing concepts that can pass through a frame by reference.
+ * Resources can only be interacted with via RPC.
+ */
+export class AnnotationMsg extends ConceptMsg {
+    constructor(kind, uid, payload) {
+        super(kind);
+        this.kind = kind;
+        this.uid = uid;
+        this.payload = payload;
+    }
+    get isDef() {
+        return true;
+    }
+    // Annotation messages are never containers, primitives, or promises
+    // (containers and primitives are always ClassMsg with specific system UIDs)
+    isFuture() {
+        return false;
+    }
+    isContainer() {
+        return false;
+    }
+    isLiteral() {
+        return false;
+    }
+    isEnum() {
+        return false;
+    }
+    isPrimitive() {
+        return false;
+    }
+    isObject() {
+        return false;
+    }
+    isAny() {
+        return false;
+    }
+    isFunction() {
+        return false;
+    }
+    isError() {
+        return false;
+    }
+    isAnnotation() {
+        return true;
+    }
+    isUnion() {
+        return this.kind === ConceptKind.Annotation.Union;
+    }
+    isIntersection() {
+        return this.kind === ConceptKind.Annotation.Intersection;
+    }
+    isInterface() {
+        return this.kind === ConceptKind.Annotation.Interface;
+    }
+    isMemberSig() {
+        return this.kind === ConceptKind.Annotation.MemberSig;
+    }
+    static rehydrate(msg) {
+        if (msg instanceof AnnotationMsg)
+            return msg;
+        switch (msg.kind) {
+            case ConceptKind.Annotation.Union:
+                return new UnionMsg(msg.uid, msg.payload);
+            case ConceptKind.Annotation.Intersection:
+                return new IntersectionMsg(msg.uid, msg.payload);
+            case ConceptKind.Annotation.Interface:
+                return new InterfaceMsg(msg.uid, msg.payload);
+            case ConceptKind.Annotation.MemberSig:
+                return new MethodSignatureMsg(msg.uid, msg.methodOf, msg.payload);
+            default:
+                throw new Error(`Unknown annotation kind: ${msg.kind}`);
+        }
+    }
+}
+export class UnionMsg extends AnnotationMsg {
+    constructor(uid, payload) {
+        super(ConceptKind.Annotation.Union, uid, payload);
+        this.payload = payload;
+    }
+    referentialize() {
+        return new RefMsg(this.kind, this.uid);
+    }
+    static rehydrate(msg) {
+        const payload = { classes: msg.payload.classes.map((c) => rehydrateMsg(c)) };
+        return msg instanceof UnionMsg ? msg : new UnionMsg(msg.uid, payload);
+    }
+}
+export class IntersectionMsg extends AnnotationMsg {
+    constructor(uid, payload) {
+        super(ConceptKind.Annotation.Intersection, uid, payload);
+        this.payload = payload;
+    }
+    referentialize() {
+        return new RefMsg(this.kind, this.uid);
+    }
+    static rehydrate(msg) {
+        const payload = { classes: msg.payload.classes.map((c) => rehydrateMsg(c)) };
+        return msg instanceof IntersectionMsg ? msg : new IntersectionMsg(msg.uid, payload);
+    }
+}
+export class InterfaceMsg extends AnnotationMsg {
+    constructor(uid, payload) {
+        super(ConceptKind.Annotation.Interface, uid, payload);
+        this.payload = payload;
+    }
+    referentialize() {
+        return new RefMsg(this.kind, this.uid);
+    }
+    static rehydrate(msg) {
+        return msg instanceof InterfaceMsg ? msg : new InterfaceMsg(msg.uid, msg.payload);
+    }
+    asClass() {
+        return new ClassMsg(this.uid, this.payload);
+    }
+}
+export class MethodSignatureMsg extends AnnotationMsg {
+    constructor(uid, methodOf, payload) {
+        super(ConceptKind.Annotation.MemberSig, uid, payload);
+        this.methodOf = methodOf;
+        this.payload = payload;
+    }
+    referentialize() {
+        return new RefMsg(this.kind, this.uid);
+    }
+    static rehydrate(msg) {
+        const payload = { ...msg.payload };
+        payload.returnType = rehydrateMsg(payload.returnType);
+        return msg instanceof MethodSignatureMsg ? msg : new MethodSignatureMsg(msg.uid, msg.methodOf, payload);
+    }
+}

package/dist-transformer/warpc/msg-protocol/concept/concept.d.ts

@@ -0,0 +1,33 @@
+import type { ResourceMsg } from './resource/resource-msg.js';
+import { ConceptKind, DefnUID, Msg } from '../../msg-protocol/kinds.js';
+import { type AnnotationMsg } from './annotations/annotation-msg.js';
+import { type ForeignExceptionMsg, type GenericExceptionMsg, type InternalErrorMsg } from './exception/exception-msg.js';
+import { SymbolMsg } from './value/symbol.js';
+import { ValueMsg } from './value/value-msg.js';
+export type Term = any;
+export declare abstract class ConceptMsg extends Msg {
+    readonly kind: ConceptKind.Any;
+    constructor(kind: ConceptKind.Any);
+    get isRef(): boolean;
+    get isDef(): boolean;
+    abstract referentialize(): NoDefMsg;
+    static rehydrate(msg: ConceptMsg | any): ConceptMsg;
+}
+export declare function equalUid(uid1: DefnUID, uid2: DefnUID): boolean;
+export type DefMsg = ResourceMsg | AnnotationMsg;
+export type ExceptionMsg = ForeignExceptionMsg | InternalErrorMsg | GenericExceptionMsg;
+export type NoDefMsg = RefMsg<DefMsg> | ValueMsg | ExceptionMsg | SymbolMsg;
+export type TermMsg = DefMsg | ValueMsg | ExceptionMsg | SymbolMsg;
+export declare class RefMsg<MsgType extends DefMsg> extends ConceptMsg {
+    readonly refKind: ConceptKind.Any;
+    readonly uid: DefnUID;
+    readonly system: boolean;
+    kind: ConceptKind.Reference;
+    constructor(refKind: ConceptKind.Any, uid: DefnUID, system?: boolean);
+    get isRef(): true;
+    get isDef(): false;
+    referentialize(): RefMsg<MsgType>;
+    static rehydrate<T extends DefMsg>(msg: RefMsg<T> | any): RefMsg<T>;
+}
+export declare function resolveAliasedRefMsg(msg: RefMsg<DefMsg>, aliasedUid: DefnUID): RefMsg<DefMsg>;
+//# sourceMappingURL=concept.d.ts.map

package/dist-transformer/warpc/msg-protocol/concept/concept.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concept.d.ts","sourceRoot":"","sources":["../../../../src/warpc/msg-protocol/concept/concept.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAEtE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AACtH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,MAAM,MAAM,IAAI,GAAG,GAAG,CAAC;AAEvB,8BAAsB,UAAW,SAAQ,GAAG;aACZ,IAAI,EAAE,WAAW,CAAC,GAAG;gBAArB,IAAI,EAAE,WAAW,CAAC,GAAG;IAKjD,IAAI,KAAK,IAAI,OAAO,CAEnB;IAGD,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,QAAQ,CAAC,cAAc,IAAI,QAAQ;IAEnC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,UAAU,GAAG,GAAG,GAAG,UAAU;CAGtD;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAE9D;AAED,MAAM,MAAM,MAAM,GAAG,WAAW,GAAG,aAAa,CAAC;AACjD,MAAM,MAAM,YAAY,GAAG,mBAAmB,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;AACxF,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,CAAC;AAC5E,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,CAAC;AAEnE,qBAAa,MAAM,CAAC,OAAO,SAAS,MAAM,CAAE,SAAQ,UAAU;aAItC,OAAO,EAAE,WAAW,CAAC,GAAG;aACxB,GAAG,EAAE,OAAO;aACZ,MAAM,EAAE,OAAO;IAL3B,IAAI,EAAE,WAAW,CAAC,SAAS,CAAC;gBAGhB,OAAO,EAAE,WAAW,CAAC,GAAG,EACxB,GAAG,EAAE,OAAO,EACZ,MAAM,GAAE,OAAe;IAK3C,IAAI,KAAK,IAAI,IAAI,CAEhB;IAED,IAAI,KAAK,IAAI,KAAK,CAEjB;IAED,cAAc,IAAI,MAAM,CAAC,OAAO,CAAC;IAIjC,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC;CAGtE;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,CAE7F"}