@symbolica/agentica 0.2.11-rc

package/dist-transformer/transformer/traverser/traverser.js

@@ -0,0 +1,414 @@
+import { createConsolaLogger } from '../../logging/index.js';
+import { getTraversalDepth } from '../transformer-config.js';
+import { isAgenticaLibraryModule } from '../transformer-utils.js';
+import { UnionMsg } from '../../warpc/msg-protocol/concept/annotations/annotation-msg.js';
+import { ClassMsg } from '../../warpc/msg-protocol/concept/resource/class-msg.js';
+import { ObjectMsg } from '../../warpc/msg-protocol/concept/resource/object-msg.js';
+import { ANONYMOUS_CLASS, PlaceholderMsg } from '../../warpc/msg-protocol/concept/resource/resource-msg.js';
+import { SystemContext } from '../../warpc/msg-protocol/concept/resource/system-msg.js';
+import { ConceptKind, World } from '../../warpc/msg-protocol/kinds.js';
+import * as ts from 'typescript';
+import { traverseThroughClass } from './class-traversal.js';
+import { traverseThroughFunction } from './function-traversal.js';
+import { tryGenericSystemType, tryPlainSystemType, tryPrimitiveType } from './system-traversal.js';
+import { hasConstructor, isConstructorType, isEnum, substituteTypeParameter, } from './traversal-utils.js';
+export class SchemaTraversal {
+    constructor(checker, program, parentLogger) {
+        this.checker = checker;
+        this.program = program;
+        this.recordsByUid = new Map();
+        this.recordsByType = new Map();
+        this.uidAliases = new Map(); // Maps aliased UID → canonical UID
+        this.traversalDepth = 0;
+        this.logger = parentLogger ? parentLogger.withScope('traverser') : createConsolaLogger('traverser');
+        this.MAX_DEPTH = getTraversalDepth(program);
+    }
+    get traversalContext() {
+        return {
+            checker: this.checker,
+            program: this.program,
+            records: this.recordsByUid,
+            logger: this.logger,
+            allocateUid: () => ({ world: World.Client, resource: SchemaTraversal.uidCounter++ }),
+            traverseTSType: this.traverseTSType.bind(this),
+        };
+    }
+    startTraversalAtFunction(name, accessorPath, sourceFile, t, explicitExpr) {
+        const typeString = this.checker.typeToString(t);
+        this.logger.debug(`startTraversalAtFunction: ${name}, type: ${typeString}`);
+        // short-circuit if we have a record for this type
+        const typeId = this.getTypeId(t);
+        if (this.recordsByType.has(typeId)) {
+            const record = this.recordsByType.get(typeId);
+            record.__isTopLevel = true; // Explicitly passed to agentic()
+            return record;
+        }
+        const uid = {
+            world: World.Client,
+            resource: SchemaTraversal.uidCounter++,
+        };
+        const msg = traverseThroughFunction(name, this.traversalContext, t, uid);
+        const traversalRecord = {
+            uid,
+            msg,
+            __agenticArgumentPath: accessorPath, // Explicitly passed by user
+            __agenticArgumentExpr: explicitExpr,
+            __module: sourceFile,
+            __isTopLevel: true, // Explicitly passed to agentic()
+        };
+        this.logger.debugObject(`Finalized top-level function traversal with msg`, msg);
+        this.recordsByUid.set(uid, traversalRecord);
+        // Register by type so later encounters of the same function type reuse this record
+        this.recordsByType.set(typeId, traversalRecord);
+        return traversalRecord;
+    }
+    startTraversalAtClass(name, accessorPath, sourceFile, t, explicitExpr) {
+        const typeString = this.checker.typeToString(t);
+        this.logger.debug(`startTraversalAtClass: ${name}, type: ${typeString}`);
+        // short-circuit if we have a record for this type
+        const typeId = this.getTypeId(t);
+        if (this.recordsByType.has(typeId)) {
+            const record = this.recordsByType.get(typeId);
+            record.__isTopLevel = true; // Explicitly passed to agentic()
+            return record;
+        }
+        const uid = {
+            world: World.Client,
+            resource: SchemaTraversal.uidCounter++,
+        };
+        // Create Placeholder for recursive traversal
+        const traversalRecord = this.createTypePlaceholder(uid, typeId);
+        const msg = traverseThroughClass(name, this.traversalContext, t, uid);
+        traversalRecord.msg = msg;
+        traversalRecord.__agenticArgumentPath = accessorPath; // Explicitly passed by user
+        traversalRecord.__agenticArgumentExpr = explicitExpr;
+        traversalRecord.__module = sourceFile;
+        traversalRecord.__isTopLevel = true; // Explicitly passed to agentic()
+        this.logger.debugObject(`Finalized top-level class traversal with msg`, msg);
+        this.recordsByUid.set(uid, traversalRecord);
+        // Register by type so later encounters (e.g., instance-derived) reuse this aliased class record
+        this.recordsByType.set(typeId, traversalRecord);
+        return traversalRecord;
+    }
+    startTraversalAtObject(name, accessorPath, sourceFile, varType, explicitExpr) {
+        const typeString = this.checker.typeToString(varType);
+        this.logger.debug(`startTraversalAtObject: ${name}, type: ${typeString}, isEnum: ${isEnum(varType)}`);
+        const clsRecord = this.traverseTSType(varType);
+        const clsUuid = clsRecord.uid;
+        // Unpeel enum wrapper: enums are technically objects, but we think of them as classes
+        if (isEnum(varType)) {
+            this.logger.debug(`Unpeeling enum ${name} - returning enum as class message directly`);
+            clsRecord.__agenticArgumentPath = accessorPath;
+            clsRecord.__agenticArgumentExpr = explicitExpr;
+            clsRecord.__module = sourceFile;
+            clsRecord.__isTopLevel = true;
+            return clsRecord;
+        }
+        // Non-enum: wrap in ObjectMsg as usual
+        this.logger.debug(`Wrapping non-enum ${name} in ObjectMsg`);
+        const uid = {
+            world: World.Client,
+            resource: SchemaTraversal.uidCounter++,
+        };
+        const clsRef = ClassMsg.createClassRefMsg(clsUuid);
+        const msg = new ObjectMsg(uid, { cls: clsRef, name: name, module: sourceFile });
+        const traversalRecord = {
+            msg,
+            uid,
+            __agenticArgumentPath: accessorPath,
+            __agenticArgumentExpr: explicitExpr,
+            __module: sourceFile,
+            __isTopLevel: true,
+        };
+        this.logger.debugObject(`Finalized top-level object traversal with msg`, msg);
+        this.recordsByUid.set(uid, traversalRecord);
+        return traversalRecord;
+    }
+    getTypeId(t) {
+        const sym = t.getSymbol();
+        const anyT = t;
+        const typeStr = this.checker.typeToString(t);
+        // Normalize enum types by their declaration symbol (handles both typeof E and E)
+        if (isEnum(t) && sym) {
+            const enumDecl = sym.declarations?.find(ts.isEnumDeclaration);
+            if (enumDecl) {
+                const symbolId = sym.id ?? sym.getName();
+                return `enum-${symbolId}`;
+            }
+        }
+        // For anonymous inline object types (where TypeScript creates unique symbols for each occurrence),
+        // use pure structural equality to deduplicate identical types
+        if (sym && (sym.getName() === '__type' || !sym.getName())) {
+            return `anonType->${typeStr}`;
+        }
+        // For types with named symbols, use symbol ID + stringified type
+        if (sym) {
+            const symbolId = sym.id ?? sym.getName();
+            return `sym-${symbolId}:${typeStr}`;
+        }
+        // For anonymous object types without symbols
+        if (t.flags & ts.TypeFlags.Object && !anyT.symbol) {
+            return `anonType->${typeStr}`;
+        }
+        // For other anonymous types, use internal ID if available
+        if (typeof anyT.id === 'number') {
+            return `id-${anyT.id}`;
+        }
+        // Final fallback to stringified type
+        return `anonType->${typeStr}`;
+    }
+    createTypePlaceholder(uid, typeId) {
+        // Create a new record (placeholder to avoid infinite recursion)
+        const traversalRecord = {
+            uid,
+            msg: new PlaceholderMsg(ConceptKind.Resource.Cls, uid),
+        };
+        this.logger.debug(`Created new record for complex type (uid=${uid.resource})`);
+        this.recordsByType.set(typeId, traversalRecord);
+        return traversalRecord;
+    }
+    traverseTSType(t, isDeeper = false, typeNode, typeSubstitutionMap) {
+        const typeString = this.checker.typeToString(t);
+        this.logger.debug(`Traversing type ${typeString} at depth ${this.traversalDepth} (deepening: ${isDeeper})`);
+        // Validate that the type doesn't originate from magic library modules
+        const symbol = t.getSymbol();
+        if (symbol?.declarations && symbol.declarations.length > 0) {
+            const declaration = symbol.declarations[0];
+            const sourceFile = declaration.getSourceFile();
+            if (sourceFile && isAgenticaLibraryModule(sourceFile.fileName)) {
+                const symbolName = symbol.getName();
+                throw new Error(`Cannot use type '${symbolName}' as a scope argument (or transitively through other types). ` +
+                    `Types from the agentica library (spawn, agentic, Agent, etc.) cannot be passed into agent scope ` +
+                    `as they need to be transformed at compile-time. \n ${sourceFile.fileName}`);
+            }
+        }
+        // Check if we have class on record, and short-circuit if we do
+        const typeId = this.getTypeId(t);
+        if (this.recordsByType.has(typeId)) {
+            const existing = this.recordsByType.get(typeId);
+            // Re-traverse if the cached record was truncated but we're now below max depth
+            const deepening = isDeeper ? 1 : 0;
+            if (existing.__truncated && this.traversalDepth + deepening <= this.MAX_DEPTH) {
+                const name = existing.msg.payload?.name || ANONYMOUS_CLASS;
+                this.logger.debug(`Re-traversing truncated record: ${name} (${typeId}), uid=${existing.uid.resource}`);
+                this.recordsByType.delete(typeId);
+            }
+            else {
+                const name = existing.msg.payload?.name || ANONYMOUS_CLASS;
+                this.logger.debug(`Returning existing record (cycle or cache hit): ${name} (${typeId}), uid=${existing.uid.resource}`);
+                return existing;
+            }
+        }
+        // Case 1: Primitive/system atomic type
+        const sysAtomMsg = tryPrimitiveType(t, this.traversalContext);
+        if (sysAtomMsg) {
+            const traversalRecord = {
+                uid: sysAtomMsg.uid,
+                msg: sysAtomMsg,
+            };
+            this.logger.debugObject('Returning primitive/system atomic type', sysAtomMsg);
+            return traversalRecord;
+        }
+        // Case 2: Direct system global classes (String, Array, Error, ...) via constructor types
+        const sysClassMsg = tryPlainSystemType(t, this.traversalContext);
+        if (sysClassMsg) {
+            const traversalRecord = {
+                uid: sysClassMsg.uid,
+                msg: sysClassMsg,
+            };
+            this.logger.debugObject('Returning direct system global class', sysClassMsg);
+            return traversalRecord;
+        }
+        // Note: instance-side built-ins (e.g., Error instance type) should flow into complex traversal,
+        // where bases and generics are handled. Only constructor types are short-circuited above.
+        // Case 3: Complex type
+        const uid = {
+            world: World.Client,
+            resource: SchemaTraversal.uidCounter++,
+        };
+        // Create Placeholder for recursive traversal
+        const traversalRecord = this.createTypePlaceholder(uid, typeId);
+        if (isDeeper) {
+            this.traversalDepth++;
+        }
+        let finalizedMsg;
+        if (this.traversalDepth > this.MAX_DEPTH) {
+            this.logger.debug(`[MAXDEPTH] Max depth ${this.MAX_DEPTH} reached, returning object`);
+            finalizedMsg = SystemContext.createObjectClassMsg(World.Client, uid, this.checker.typeToString(t));
+            traversalRecord.__truncated = true;
+        }
+        else {
+            this.logger.incDepth();
+            // ... This call may recurse when going through classes
+            finalizedMsg = this.traverseComplexTSType(t, uid, this.logger, typeNode, typeSubstitutionMap);
+            this.logger.decDepth();
+        }
+        if (isDeeper) {
+            this.traversalDepth--;
+        }
+        // Check if finalization returned a placeholder (type alias to unfinished type)
+        if (finalizedMsg.constructor.name === 'PlaceholderMsg') {
+            const targetUid = finalizedMsg.uid.resource;
+            this.logger.debug(`Type alias detected: ${uid.resource} -> ${targetUid}`);
+            this.uidAliases.set(uid.resource, targetUid);
+            // Remove from recordsByType - this UID is just an alias, not a real type
+            this.recordsByType.delete(typeId);
+            return traversalRecord;
+        }
+        this.logger.debugObject(`Finalized message for type ${typeString}`, finalizedMsg);
+        traversalRecord.msg = finalizedMsg;
+        // If the finalized message is a system resource (e.g., Error, Function), don't record it as a def
+        // Return directly without adding to recordsByUid/recordsByType to avoid emitting a def
+        if (finalizedMsg.uid && SystemContext.getNameByUID(finalizedMsg.uid) !== undefined) {
+            // Replace traversalRecord.uid with the system uid to be consistent
+            traversalRecord.uid = finalizedMsg.uid;
+            // Remove the placeholder cache for this type
+            this.recordsByType.delete(typeId);
+            return traversalRecord;
+        }
+        // Update module and accessor path in traversal record
+        if (finalizedMsg.payload) {
+            const payload = finalizedMsg.payload;
+            if (payload.module)
+                traversalRecord.__module = payload.module;
+            // Only set accessor path for runtime-accessible concepts if not already set
+            // (class-traversal may have set more specific paths for methods)
+            if (!traversalRecord.__accessorPath &&
+                payload.name &&
+                (finalizedMsg.kind === ConceptKind.Resource.Cls ||
+                    finalizedMsg.kind === ConceptKind.Resource.Func ||
+                    finalizedMsg.kind === ConceptKind.Resource.Obj)) {
+                traversalRecord.__accessorPath = [payload.name];
+            }
+        }
+        this.recordsByUid.set(uid, traversalRecord);
+        return traversalRecord;
+    }
+    traverseComplexTSType(t, uid, logger, typeNode, typeSubstitutionMap) {
+        const f = t.flags;
+        const sym = t.getSymbol();
+        // Handle system generics, both classes or annotation (e.g. Person[], unions, etc.)
+        const systemMsg = tryGenericSystemType(this.traversalContext, t, uid, typeNode);
+        if (systemMsg) {
+            logger.debugObject('Built system message', systemMsg);
+            return systemMsg;
+        }
+        // Handle function types (e.g. (arg: Person) => void)
+        const callSigs = this.checker.getSignaturesOfType(t, ts.SignatureKind.Call);
+        if (callSigs.length) {
+            const funcMsg = traverseThroughFunction(undefined, this.traversalContext, t, uid, typeSubstitutionMap);
+            logger.debugObject('Built function message', funcMsg);
+            return SystemContext.createFunctionClassMsg(World.Client, uid, funcMsg);
+        }
+        // Handle conditional types (e.g. T extends U ? X : Y)
+        if (f & ts.TypeFlags.Conditional) {
+            const resolved = this.checker.getBaseConstraintOfType(t) || this.checker.getApparentType(t);
+            if (resolved && resolved !== t) {
+                logger.debug(`Resolving conditional type: ${this.checker.typeToString(t)}`);
+                return this.traverseTSType(resolved).msg;
+            }
+            const conditional = t;
+            const trueType = conditional.root.node.trueType
+                ? this.checker.getTypeFromTypeNode(conditional.root.node.trueType)
+                : undefined;
+            const falseType = conditional.root.node.falseType
+                ? this.checker.getTypeFromTypeNode(conditional.root.node.falseType)
+                : undefined;
+            if (trueType && falseType) {
+                const trueRef = ClassMsg.createClassRefMsg(this.traverseTSType(trueType).uid);
+                const falseRef = ClassMsg.createClassRefMsg(this.traverseTSType(falseType).uid);
+                const unionMsg = new UnionMsg(uid, { classes: [trueRef, falseRef] });
+                logger.debugObject('Built union from conditional', unionMsg);
+                return unionMsg;
+            }
+            logger.warn(`Could not resolve conditional type: ${this.checker.typeToString(t)}`);
+        }
+        // Handle type parameters (e.g. T, U, B)
+        if (f & ts.TypeFlags.TypeParameter) {
+            const substituted = substituteTypeParameter(t, typeSubstitutionMap, this.checker);
+            if (substituted) {
+                logger.debug(`Substituting type parameter: ${this.checker.typeToString(t)} -> ${substituted.uid.resource}`);
+                return new PlaceholderMsg(ConceptKind.Resource.Cls, substituted.uid);
+            }
+            const constraint = this.checker.getBaseConstraintOfType(t);
+            if (constraint && constraint !== t) {
+                logger.debug(`Resolving type parameter via constraint: ${this.checker.typeToString(t)} >>> ${this.checker.typeToString(constraint)}`);
+                const resolvedRecord = this.traverseTSType(constraint);
+                return new PlaceholderMsg(ConceptKind.Resource.Cls, resolvedRecord.uid);
+            }
+            const clsMsg = SystemContext.createObjectClassMsg(World.Client, uid, this.checker.typeToString(t));
+            logger.debugObject('Unconstrained type parameter, fallback to object message', clsMsg);
+            return clsMsg;
+        }
+        // Handle keyof types (e.g. keyof T)
+        if (f & ts.TypeFlags.Index) {
+            const indexType = t;
+            const objectType = indexType.type;
+            logger.debug(`Resolving keyof type: ${this.checker.typeToString(t)}`);
+            // Get all property names from the object type
+            const props = this.checker.getPropertiesOfType(objectType);
+            const keys = props.map((p) => p.getName());
+            if (keys.length > 0) {
+                // Create a union of string literals for the keys
+                const literalRefs = keys.map((key) => {
+                    const literalType = this.checker.getStringLiteralType(key);
+                    const literalUid = this.traverseTSType(literalType).uid;
+                    return ClassMsg.createClassRefMsg(literalUid);
+                });
+                logger.debug(`keyof resolved to union of ${keys.length} string literals`);
+                const unionMsg = new UnionMsg(uid, { classes: literalRefs });
+                return unionMsg;
+            }
+            // Fallback to string type if no keys
+            logger.debug('keyof has no keys, falling back to string');
+            return SystemContext.getClassMsgByName(World.Client, 'string');
+        }
+        // Handle indexed access types (e.g. T["key"])
+        if (f & ts.TypeFlags.IndexedAccess) {
+            const resolved = this.checker.getApparentType(t);
+            if (resolved && resolved !== t) {
+                logger.debug(`Resolving indexed access: ${this.checker.typeToString(t)}`);
+                const resolvedRecord = this.traverseTSType(resolved);
+                // Return a placeholder to create an alias relationship
+                return new PlaceholderMsg(ConceptKind.Resource.Cls, resolvedRecord.uid);
+            }
+        }
+        // Handle substitution types (from generic instantiation)
+        if (f & ts.TypeFlags.Substitution) {
+            const substitution = t;
+            logger.debug(`Resolving substitution type: ${this.checker.typeToString(t)}`);
+            return this.traverseTSType(substitution.baseType).msg;
+        }
+        logger.debug(`Type flags: ${f}, has symbol: ${!!sym}`);
+        // Handle custom classes or annotations (e.g. interface Person {})
+        if (f & ts.TypeFlags.Object || sym) {
+            // First: avoid defining system non-generic interface types (e.g., Error, Function)
+            const symName = sym?.getName();
+            const hasCtor = hasConstructor(t);
+            const maybeRef = t;
+            const hasTypeArgs = !!maybeRef.typeArguments?.length;
+            const symHasTypeParams = !!sym?.typeParameters?.length;
+            const isGenericInterface = hasTypeArgs || symHasTypeParams;
+            if (symName && !hasCtor && !isGenericInterface && SystemContext.isSystemResourceName(symName)) {
+                const sysMsg = SystemContext.getClassMsgByName(World.Client, symName);
+                logger.debugObject('Returning system non-generic interface as class msg', sysMsg);
+                return sysMsg;
+            }
+            // Detect constructor types via construct signatures
+            // Comment: this omits the actual type structures that a usual `typeof MyClass` would enforce in TS
+            if (isConstructorType(t, this.checker)) {
+                logger.debug('Building a type of type msgs (type info ignored)');
+                return SystemContext.getClassMsgByName(World.Client, 'TYPE');
+            }
+            const classMsg = traverseThroughClass(undefined, this.traversalContext, t, uid);
+            logger.debugObject('Built class message', classMsg);
+            return classMsg;
+        }
+        logger.warn(`Unknown type: ${this.checker.typeToString(t)}`);
+        // Fallback to "any" type (with name of the type t)
+        const clsMsg = SystemContext.createObjectClassMsg(World.Client, uid, this.checker.typeToString(t));
+        logger.debugObject('Fallback to any class message', clsMsg);
+        return clsMsg;
+    }
+}
+SchemaTraversal.uidCounter = 0;

package/dist-transformer/version.d.ts

@@ -0,0 +1,2 @@
+export declare const version = "0.2.11-rc";
+//# sourceMappingURL=version.d.ts.map

package/dist-transformer/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,cAAc,CAAC"}

package/dist-transformer/version.js

@@ -0,0 +1,3 @@
+// This file is auto-generated from git tags
+// Do not edit manually
+export const version = "0.2.11-rc";

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

@@ -0,0 +1,15 @@
+import { AnnotationMsg } from '../msg-protocol/concept/annotations/annotation-msg.js';
+import { DefnUID } from '../msg-protocol/kinds.js';
+import { UIDGenerator } from './uid-gen.js';
+export declare class AnnotationContext {
+    readonly uidGenerator: UIDGenerator;
+    protected readonly parent?: AnnotationContext | undefined;
+    protected uidToAnnotation: Map<string, AnnotationMsg>;
+    private logger;
+    constructor(uidGenerator: UIDGenerator, parent?: AnnotationContext | undefined);
+    getAllOwnAnnotations(): AnnotationMsg[];
+    getRecord(uid: DefnUID): AnnotationMsg | undefined;
+    setRecord(uid: DefnUID, annotation: any): void;
+    getMessageFromAnnotationName(name: string): AnnotationMsg | null;
+}
+//# sourceMappingURL=annotation-ctx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"annotation-ctx.d.ts","sourceRoot":"","sources":["../../../src/warpc/frame-context/annotation-ctx.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wDAAwD,CAAC;AACvF,OAAO,EAAE,OAAO,EAAmB,MAAM,2BAA2B,CAAC;AAErE,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAIzC,qBAAa,iBAAiB;aAKN,YAAY,EAAE,YAAY;IAC1C,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,iBAAiB;IALjD,SAAS,CAAC,eAAe,6BAAoC;IAC7D,OAAO,CAAC,MAAM,CAAe;gBAGT,YAAY,EAAE,YAAY,EACvB,MAAM,CAAC,EAAE,iBAAiB,YAAA;IAKjD,oBAAoB,IAAI,aAAa,EAAE;IAIvC,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,aAAa,GAAG,SAAS;IAIlD,SAAS,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,GAAG,IAAI;IAK9C,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;CASnE"}

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

@@ -0,0 +1,30 @@
+import { createLogger } from '../../logging/index.js';
+import { defnUidToString } from '../msg-protocol/kinds.js';
+import { orUndefined } from '../../common.js';
+export class AnnotationContext {
+    constructor(uidGenerator, parent) {
+        this.uidGenerator = uidGenerator;
+        this.parent = parent;
+        this.uidToAnnotation = new Map();
+        this.logger = createLogger(`context:annotation:${uidGenerator.world}`);
+    }
+    getAllOwnAnnotations() {
+        return [...this.uidToAnnotation.values()];
+    }
+    getRecord(uid) {
+        return orUndefined(this.uidToAnnotation.get(defnUidToString(uid)), this.parent?.getRecord(uid));
+    }
+    setRecord(uid, annotation) {
+        this.uidToAnnotation.set(defnUidToString(uid), annotation);
+    }
+    // Works for interfaces and method signatures
+    getMessageFromAnnotationName(name) {
+        for (const msg of this.uidToAnnotation.values()) {
+            if (msg.payload.name === name) {
+                return msg;
+            }
+        }
+        this.logger.error(`Annotation ${name} not found in context`);
+        throw new Error(`Annotation ${name} not found in manager`);
+    }
+}

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

@@ -0,0 +1,27 @@
+import { DefMsg, NoDefMsg, Term } from '../msg-protocol/concept/concept.js';
+import { ValueMsg } from '../msg-protocol/concept/value/value-msg.js';
+import { DefnUID, FrameID, World } from '../msg-protocol/kinds.js';
+import { AnnotationContext } from './annotation-ctx.js';
+import { ClassContext, FunctionContext, ObjectContext } from './resource-ctx.js';
+import { UIDGenerator } from './uid-gen.js';
+export { SystemContext } from '../msg-protocol/concept/resource/system-msg.js';
+export { FrameID } from '../msg-protocol/kinds.js';
+export { AnnotationContext } from './annotation-ctx.js';
+export { ClassContext, FunctionContext, ObjectContext, ResourceContext } from './resource-ctx.js';
+export { UIDGenerator } from './uid-gen.js';
+export declare class FrameContext {
+    readonly objects: ObjectContext;
+    readonly classes: ClassContext;
+    readonly functions: FunctionContext;
+    readonly annotations: AnnotationContext;
+    readonly uidGenerator: UIDGenerator;
+    readonly world: World;
+    constructor(objects: ObjectContext, classes: ClassContext, functions: FunctionContext, annotations: AnnotationContext, uidGenerator: UIDGenerator);
+    static newFromParent(parent: FrameContext, frameID: FrameID, uidGenerator: UIDGenerator): FrameContext;
+    getMessageFromResource(resource: Term): DefMsg | undefined;
+    getMessageFromUID(uid: DefnUID): DefMsg | undefined;
+    getResourceFromUID(uid: DefnUID): any | undefined;
+    derefValueOrMsg(msg: NoDefMsg): DefMsg | ValueMsg;
+    updateExistingResource(uid: DefnUID, resource: any): void;
+}
+//# sourceMappingURL=frame-ctx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frame-ctx.d.ts","sourceRoot":"","sources":["../../../src/warpc/frame-context/frame-ctx.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAU,IAAI,EAAE,MAAM,qCAAqC,CAAC;AAErF,OAAO,EAAE,QAAQ,EAAE,MAAM,6CAA6C,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAIzC,OAAO,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAChF,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC/F,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,qBAAa,YAAY;aAGD,OAAO,EAAE,aAAa;aACtB,OAAO,EAAE,YAAY;aACrB,SAAS,EAAE,eAAe;aAC1B,WAAW,EAAE,iBAAiB;aAC9B,YAAY,EAAE,YAAY;IAN9C,SAAgB,KAAK,EAAE,KAAK,CAAC;gBAET,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,iBAAiB,EAC9B,YAAY,EAAE,YAAY;IAK9C,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,YAAY,GAAG,YAAY;IAUtG,sBAAsB,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS;IAS1D,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS;IASnD,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,GAAG,SAAS;IAQjD,eAAe,CAAC,GAAG,EAAE,QAAQ,GAAG,MAAM,GAAG,QAAQ;IAMjD,sBAAsB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,GAAG,IAAI;CAK5D"}

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

@@ -0,0 +1,42 @@
+import { AnnotationContext } from './annotation-ctx.js';
+import { ClassContext, FunctionContext, ObjectContext } from './resource-ctx.js';
+import { orUndefined } from '../../common.js';
+export { SystemContext } from '../msg-protocol/concept/resource/system-msg.js';
+export { AnnotationContext } from './annotation-ctx.js';
+export { ClassContext, FunctionContext, ObjectContext, ResourceContext } from './resource-ctx.js';
+export { UIDGenerator } from './uid-gen.js';
+export class FrameContext {
+    constructor(objects, classes, functions, annotations, uidGenerator) {
+        this.objects = objects;
+        this.classes = classes;
+        this.functions = functions;
+        this.annotations = annotations;
+        this.uidGenerator = uidGenerator;
+        this.world = uidGenerator.world;
+    }
+    static newFromParent(parent, frameID, uidGenerator) {
+        return new FrameContext(new ObjectContext(uidGenerator, parent.objects), new ClassContext(uidGenerator, parent.classes), new FunctionContext(uidGenerator, parent.functions), new AnnotationContext(uidGenerator, parent.annotations), uidGenerator);
+    }
+    getMessageFromResource(resource) {
+        return (this.objects.getMessageFromResource(resource) ||
+            this.classes.getMessageFromResource(resource) ||
+            this.functions.getMessageFromResource(resource) ||
+            undefined);
+    }
+    getMessageFromUID(uid) {
+        return orUndefined(this.objects.getMessageFromUID(uid), this.classes.getMessageFromUID(uid), this.functions.getMessageFromUID(uid), this.annotations.getRecord(uid));
+    }
+    getResourceFromUID(uid) {
+        return orUndefined(this.objects.getResourceFromUID(uid), this.classes.getResourceFromUID(uid), this.functions.getResourceFromUID(uid));
+    }
+    derefValueOrMsg(msg) {
+        return msg.isRef
+            ? this.getMessageFromUID(msg.uid)
+            : msg;
+    }
+    updateExistingResource(uid, resource) {
+        this.objects.updateExistingResource(uid, resource);
+        this.classes.updateExistingResource(uid, resource);
+        this.functions.updateExistingResource(uid, resource);
+    }
+}

package/dist-transformer/warpc/frame-context/message-conversion/decoder.d.ts

@@ -0,0 +1,24 @@
+import { FrameContext } from '../../frame-context/frame-ctx.js';
+import { ForeignExceptionMsg, GenericExceptionMsg, InternalErrorMsg } from '../../msg-protocol/concept/exception/exception-msg.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 { Virtualizer } from '../../../warpc/frame-context/virtual-resources/virtualizer.js';
+import { AnnotationMsg } from '../../../warpc/msg-protocol/concept/annotations/annotation-msg.js';
+import { ConceptMsg, RefMsg, Term } from '../../../warpc/msg-protocol/concept/concept.js';
+export declare class TermDecoder {
+    virtualizer: Virtualizer;
+    context: FrameContext;
+    private logger;
+    private errorClasses;
+    constructor(virtualizer: Virtualizer, context: FrameContext);
+    decodeWithCtx(msg: ConceptMsg, expectedCls?: ClassMsg): Term | undefined;
+    decodeClass(msg: ClassMsg | RefMsg<ClassMsg>): any;
+    decodeFunction(msg: FunctionMsg | RefMsg<FunctionMsg>): any;
+    decodeObject(msg: ObjectMsg | RefMsg<ObjectMsg>): any;
+    decodeForeignException(msg: ForeignExceptionMsg): any;
+    decodeSimplifiedException(msg: GenericExceptionMsg): any;
+    decodeInternalError(msg: InternalErrorMsg): any;
+    recordAnnotation(msg: AnnotationMsg): void;
+}
+//# sourceMappingURL=decoder.d.ts.map

package/dist-transformer/warpc/frame-context/message-conversion/decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder.d.ts","sourceRoot":"","sources":["../../../../src/warpc/frame-context/message-conversion/decoder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EACH,mBAAmB,EACnB,mBAAmB,EAEnB,gBAAgB,EACnB,MAAM,qDAAqD,CAAC;AAC7D,OAAO,EAAE,QAAQ,EAAgB,MAAM,gDAAgD,CAAC;AACxF,OAAO,EAAE,WAAW,EAAE,MAAM,mDAAmD,CAAC;AAChF,OAAO,EAAE,SAAS,EAAE,MAAM,iDAAiD,CAAC;AAK5E,OAAO,EAAE,WAAW,EAAE,MAAM,qDAAqD,CAAC;AAClF,OAAO,EAAE,aAAa,EAAE,MAAM,yDAAyD,CAAC;AACxF,OAAO,EAAE,UAAU,EAAU,MAAM,EAAE,IAAI,EAAE,MAAM,sCAAsC,CAAC;AAGxF,qBAAa,WAAW;IAKT,WAAW,EAAE,WAAW;IACxB,OAAO,EAAE,YAAY;IALhC,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,YAAY,CAAwC;gBAGjD,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,YAAY;IAKhC,aAAa,CAAC,GAAG,EAAE,UAAU,EAAE,WAAW,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS;IA6GxE,WAAW,CAAC,GAAG,EAAE,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,GAAG;IAqBlD,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,GAAG;IAkB3D,YAAY,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC,GAAG,GAAG;IAkBrD,sBAAsB,CAAC,GAAG,EAAE,mBAAmB,GAAG,GAAG;IAOrD,yBAAyB,CAAC,GAAG,EAAE,mBAAmB,GAAG,GAAG;IAyBxD,mBAAmB,CAAC,GAAG,EAAE,gBAAgB,GAAG,GAAG;IAI/C,gBAAgB,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI;CAM7C"}