@symbolica/agentica 0.2.11-rc

package/dist-transformer/transformer/transformer.js

@@ -0,0 +1,104 @@
+import { createConsolaLogger, shortenPath } from '../logging/index.js';
+import * as ts from 'typescript';
+import { AgenticCodeInjector } from './codegen/context-gen.js';
+import { collectAgenticFunSites, generateContextAtAgenticSite } from './processor/processor.js';
+import { AGENTIC_TRANSFORMATION_NAME, CALL_TRANSFORMATION_NAME, SPAWN_TRANSFORMATION_NAME } from './transformer-config.js';
+import { addAgenticTransformationImport, isAgenticFunCall, isCallMethod, isSpawnFunCall, wrapTransformationSite, } from './transformer-utils.js';
+/**
+ * Main transformer entry point
+ * Note: Transformer runs at build-time, so we use createConsolaLogger (never OTel)
+ */
+function agenticFunTransformer(program) {
+    const checker = program.getTypeChecker();
+    const logger = createConsolaLogger('transformer');
+    const span = logger.startSpan('agenticFunTransformer');
+    try {
+        // Collect agentic sites
+        const agenticSites = collectAgenticFunSites(program);
+        logger.debug(`Collected ${agenticSites.length} agentic sites`);
+        span.setAttribute('agentic_sites_count', agenticSites.length);
+        // Traverse each agentic site to generate context
+        const agenticSiteContexts = agenticSites.map((site) => generateContextAtAgenticSite(checker, program, site));
+        // Return the transformation factory
+        return (ctx) => {
+            const factory = ctx.factory;
+            const agenticCodeInjector = new AgenticCodeInjector(factory, program);
+            return (sourceFile) => {
+                const fileLogger = logger.withScope('file');
+                const fileName = sourceFile.fileName;
+                const sitesInFile = agenticSites.filter((s) => s.sourceFile.fileName === sourceFile.fileName);
+                fileLogger.debug(`Processing ${shortenPath(fileName)}: ${sitesInFile.length} agentic site(s)`);
+                if (!sitesInFile.length)
+                    return sourceFile;
+                sourceFile = addAgenticTransformationImport(factory, sourceFile);
+                const siteCodeByPos = new Map();
+                // Codegen per agentic site
+                for (const site of sitesInFile) {
+                    const siteIdx = agenticSites.indexOf(site);
+                    const siteContext = agenticSiteContexts[siteIdx];
+                    // Generate context code (spawn may have empty context if no scope provided)
+                    const agenticCode = agenticCodeInjector.generatePerSiteAgenticCode(sourceFile, '__AGENTIC_CONTEXT__', siteContext.context, false, site.id);
+                    fileLogger.debug(`Injecting ${agenticCode.contextDecl ? 'context' : 'empty context'}${agenticCode.needsAsync ? ' with dynamic imports' : ''} for site ${site.id}`);
+                    siteCodeByPos.set(site.call.pos, {
+                        contextDecl: agenticCode.contextDecl,
+                        dynamicImports: agenticCode.dynamicImports,
+                        needsAsync: agenticCode.needsAsync,
+                        siteId: site.id,
+                        siteOutputType: siteContext.siteOutputType,
+                        docString: site.docString,
+                        promptTemplate: siteContext.promptTemplate,
+                    });
+                }
+                if (siteCodeByPos.size === 0)
+                    return sourceFile;
+                let transformedCalls = 0;
+                const visitor = (node) => {
+                    if (isAgenticFunCall(node)) {
+                        const code = siteCodeByPos.get(node.pos);
+                        if (code) {
+                            transformedCalls++;
+                            return wrapTransformationSite({
+                                factory,
+                                call: node,
+                                code: code,
+                                functionName: AGENTIC_TRANSFORMATION_NAME,
+                            });
+                        }
+                    }
+                    else if (isSpawnFunCall(node)) {
+                        const code = siteCodeByPos.get(node.pos);
+                        if (code) {
+                            transformedCalls++;
+                            return wrapTransformationSite({
+                                factory,
+                                call: node,
+                                code: code,
+                                functionName: SPAWN_TRANSFORMATION_NAME,
+                            });
+                        }
+                    }
+                    else if (isCallMethod(node, checker)) {
+                        const code = siteCodeByPos.get(node.pos);
+                        if (code) {
+                            transformedCalls++;
+                            return wrapTransformationSite({
+                                factory,
+                                call: node,
+                                code: code,
+                                functionName: CALL_TRANSFORMATION_NAME,
+                            });
+                        }
+                    }
+                    return ts.visitEachChild(node, visitor, ctx);
+                };
+                const updated = ts.visitEachChild(sourceFile, visitor, ctx);
+                fileLogger.debug(`Transformed ${transformedCalls} agentica call(s) in ${shortenPath(fileName)}`);
+                return updated;
+            };
+        };
+    }
+    finally {
+        span.end();
+    }
+}
+export default agenticFunTransformer;

package/dist-transformer/transformer/traverser/class-traversal.d.ts

@@ -0,0 +1,9 @@
+import { InterfaceMsg } from '../../warpc/msg-protocol/concept/annotations/annotation-msg.js';
+import { RefMsg } from '../../warpc/msg-protocol/concept/concept.js';
+import { ClassMsg } from '../../warpc/msg-protocol/concept/resource/class-msg.js';
+import { DefnUID } from '../../warpc/msg-protocol/kinds.js';
+import * as ts from 'typescript';
+import { TraversalCtx } from './traverser.js';
+export declare function getOrCreateMapType(ctx: TraversalCtx, keyUid: DefnUID, valueUid: DefnUID): RefMsg<ClassMsg>;
+export declare function traverseThroughClass(name: string | undefined, ctx: TraversalCtx, t: ts.Type, uid: DefnUID): ClassMsg | InterfaceMsg;
+//# sourceMappingURL=class-traversal.d.ts.map

package/dist-transformer/transformer/traverser/class-traversal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-traversal.d.ts","sourceRoot":"","sources":["../../../src/transformer/traverser/class-traversal.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,wDAAwD,CAAC;AACtF,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAC7D,OAAO,EAGH,QAAQ,EAGX,MAAM,gDAAgD,CAAC;AAIxD,OAAO,EAAe,OAAO,EAAS,MAAM,2BAA2B,CAAC;AACxE,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AASjC,OAAO,EAAE,YAAY,EAAmB,MAAM,aAAa,CAAC;AAE5D,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,CAiD1G;AAED,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,GAAG,EAAE,YAAY,EACjB,CAAC,EAAE,EAAE,CAAC,IAAI,EACV,GAAG,EAAE,OAAO,GACb,QAAQ,GAAG,YAAY,CA2UzB"}

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

@@ -0,0 +1,336 @@
+import { extractDocstringFromSymbol } from '../processor/processor-utils.js';
+import { ClassMsg, } from '../../warpc/msg-protocol/concept/resource/class-msg.js';
+import { FunctionMsg } from '../../warpc/msg-protocol/concept/resource/function-msg.js';
+import { ANONYMOUS_CLASS } from '../../warpc/msg-protocol/concept/resource/resource-msg.js';
+import { CLASS_IDS, 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 { hasConstructor, isBuiltinConcept, isEnum, parseParameterArgument, } from './traversal-utils.js';
+export function getOrCreateMapType(ctx, keyUid, valueUid) {
+    const { records, logger, allocateUid } = ctx;
+    /*
+    Check if we already have a Map with these exact type arguments
+
+    Comment: we do this currently by searching messages (not types), and adding messages as needed.
+    This circumvents setting the recordsByType of the traverser, which could lead to a duplicate record
+    for the intended map type (but that is okay, since we do not materialize Map Types as classes)
+    */
+    for (const [uid, record] of records.entries()) {
+        if (record.msg.kind === ConceptKind.Resource.Cls) {
+            const clsMsg = record.msg;
+            const payload = clsMsg.payload;
+            if (payload.instance_of_generic?.resource === CLASS_IDS.Map &&
+                payload.supplied_type_args &&
+                payload.supplied_type_args.length === 2) {
+                const [keyArg, valueArg] = payload.supplied_type_args;
+                if (keyArg.type.uid.world === keyUid.world &&
+                    keyArg.type.uid.resource === keyUid.resource &&
+                    valueArg.type.uid.world === valueUid.world &&
+                    valueArg.type.uid.resource === valueUid.resource) {
+                    logger.debug(`Reusing existing Map<${keyUid.resource}, ${valueUid.resource}> with UID ${uid.resource}`);
+                    return ClassMsg.createClassRefMsg(uid);
+                }
+            }
+        }
+    }
+    // No existing Map<K,V> found, create a new one
+    const mapUid = allocateUid();
+    const mapMsg = SystemContext.createMapClassMsg(World.Client, mapUid, keyUid, valueUid);
+    const mapRecord = {
+        uid: mapUid,
+        msg: mapMsg,
+    };
+    records.set(mapUid, mapRecord);
+    logger.debug(`Created new Map<${keyUid.resource}, ${valueUid.resource}> with UID ${mapUid.resource}`);
+    return ClassMsg.createClassRefMsg(mapUid);
+}
+export function traverseThroughClass(name, ctx, t, uid) {
+    const { checker, traverseTSType, records, logger } = ctx;
+    // Check for type alias first, then fall back to the underlying type's symbol
+    const aliasSym = t.aliasSymbol;
+    const sym = aliasSym || t.getSymbol();
+    let className = name ?? (sym && sym.getName()) ?? ANONYMOUS_CLASS;
+    // Special case: treat globalThis as a plain object to avoid deep traversal
+    if (className === 'globalThis') {
+        logger.debug('Stopping at globalThis, returning object');
+        return SystemContext.getClassMsgByName(World.Client, 'object');
+    }
+    const isInterface = !hasConstructor(t);
+    // Replace __type and __object (TypeScript's names for anonymous inline object types) with a proper anonymous name
+    if (className === '__type' || className === '__object') {
+        logger.debug(`Replacing ${className} with ${ANONYMOUS_CLASS} for ${isInterface ? 'interface' : 'class'} ${uid.resource}`);
+        className = ANONYMOUS_CLASS + '_' + uid.resource.toString();
+    }
+    const doc = sym ? extractDocstringFromSymbol(sym) : undefined;
+    const fields = [];
+    const methods = [];
+    // Resolve the class declaration and constructor type early
+    let classDecl;
+    let constructorFunctionType;
+    if (sym && (sym.valueDeclaration || (sym.declarations && sym.declarations[0]))) {
+        classDecl = (sym.valueDeclaration || sym.declarations[0]);
+        constructorFunctionType = checker.getTypeOfSymbolAtLocation(sym, classDecl);
+    }
+    /*
+    ** Generic classes logic (e.g. Factory<T, U> -> Factory<string, number>) **
+
+    Terminology:
+    * typeParams: The generic parameters declared on the class itself, e.g. in class Box<T, U> {}, the T and U. read
+        these from the declaration via clsDecl.typeParameters.
+    * typeArgs: The concrete types supplied at the use site, e.g.Map<string, number>. read these from the ts.
+        TypeReference((t as ts.TypeReference).typeArguments).
+    */
+    // Build type substitution map from generic class type parameters to concrete type arguments
+    let typeSubstitutionMap;
+    let supplied_type_args;
+    const maybeTypeRef = t;
+    const typeArgs = maybeTypeRef.typeArguments;
+    if (typeArgs && typeArgs.length && classDecl && ts.isClassLike(classDecl)) {
+        const clsDecl = classDecl;
+        const typeParams = clsDecl.typeParameters || ts.factory.createNodeArray();
+        if (typeParams.length === typeArgs.length) {
+            typeSubstitutionMap = {};
+            for (let i = 0; i < typeParams.length; i++) {
+                const paramName = typeParams[i].name.text;
+                typeSubstitutionMap[paramName] = ClassMsg.createClassRefMsg(traverseTSType(typeArgs[i], true).uid);
+            }
+            supplied_type_args = Object.entries(typeSubstitutionMap).map(([name, type]) => ({ name, type }));
+        }
+        else {
+            throw new Error(`Type ${className} has ${typeParams.length} type parameters but ${typeArgs.length} type arguments. ` +
+                `This is currently not supported during type analysis.`);
+        }
+    }
+    function addClassMember(memberName, memberType, isStatic, memberSymbol) {
+        // Attempt to capture the source TypeNode for better ordering of unions/intersections
+        const memberDecl = (memberSymbol?.valueDeclaration || memberSymbol?.declarations?.[0]);
+        let memberTypeNode = undefined;
+        if (memberDecl && (ts.isPropertySignature(memberDecl) || ts.isPropertyDeclaration(memberDecl))) {
+            memberTypeNode = memberDecl.type;
+        }
+        const callSigs = checker.getSignaturesOfType(memberType, ts.SignatureKind.Call);
+        if (callSigs.length > 0) {
+            // methods
+            logger.debug(`METHOD: detected that ${memberName} is a method of ${uid.resource}`);
+            // Yields either an existing method record or a new Function Type class message
+            const memberTypeRecord = traverseTSType(memberType, false, memberTypeNode, typeSubstitutionMap);
+            // Class message case
+            if (memberTypeRecord.msg.kind === ConceptKind.Resource.Cls) {
+                logger.debugObject(`Method ${memberName} resolved to`, memberTypeRecord.msg);
+                const funcMsg = memberTypeRecord.msg.payload.supplied_type_args;
+                if (funcMsg === undefined) {
+                    // throw unsupportedBultinClass(className, 'code');
+                    return;
+                }
+                memberTypeRecord.msg = funcMsg; // replace ClassMsg with FunctionMsg in place!
+                const methodUuid = memberTypeRecord.uid;
+                let isPrivate = false;
+                if (memberSymbol) {
+                    const decl = memberSymbol.valueDeclaration || memberSymbol.declarations?.[0];
+                    if (decl && ts.isMethodDeclaration(decl)) {
+                        isPrivate =
+                            memberName.startsWith('#') ||
+                                (decl.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.PrivateKeyword) ?? false);
+                    }
+                }
+                methods.push({
+                    name: memberName,
+                    function: FunctionMsg.createFunctionRefMsg(funcMsg.uid),
+                    is_static: isStatic,
+                    is_private: isPrivate,
+                });
+                const methodRecord = records.get(methodUuid);
+                if (methodRecord) {
+                    // Set accessor path only for runtime classes (not interfaces)
+                    if (!isInterface) {
+                        methodRecord.__accessorPath = isStatic
+                            ? [className, memberName]
+                            : [className, 'prototype', memberName];
+                    }
+                    // Convert to MethodSignatureMsg for all methods (classes and interfaces)
+                    if (methodRecord.msg.kind === 'func') {
+                        if (typeof methodRecord.msg.toMethodSignature === 'function') {
+                            methodRecord.msg.payload.name = memberName;
+                            methodRecord.msg = methodRecord.msg.toMethodSignature({
+                                uid,
+                                kind: isStatic ? 'static' : 'instance',
+                            });
+                            logger.debug(`Method ${memberName} converted to MethodSignatureMsg`);
+                        }
+                        else {
+                            logger.warn(`Method ${memberName} was interpreted by the type traverser as a non-function with the following message:`, methodRecord.msg);
+                            logger.debugObject(`Method ${memberName} resolved to`, methodRecord.msg);
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            // fields
+            logger.debug(`FIELD: detected that ${memberName} is a field of ${uid.resource}`);
+            const fieldUid = traverseTSType(memberType, true, memberTypeNode, typeSubstitutionMap).uid;
+            let isOptional = false;
+            let isPrivate = false;
+            if (memberSymbol) {
+                const decl = memberSymbol.valueDeclaration || memberSymbol.declarations?.[0];
+                if (decl && (ts.isPropertySignature(decl) || ts.isPropertyDeclaration(decl))) {
+                    isOptional = decl.questionToken !== undefined;
+                    isPrivate =
+                        memberName.startsWith('#') ||
+                            (decl.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.PrivateKeyword) ?? false);
+                }
+            }
+            fields.push({
+                name: memberName,
+                type: ClassMsg.createClassRefMsg(fieldUid),
+                is_static: isStatic,
+                is_optional: isOptional,
+                is_private: isPrivate,
+            });
+            if (isStatic && !isInterface) {
+                const maybeMsg = records.get(fieldUid);
+                if (maybeMsg && maybeMsg.msg.kind === 'obj') {
+                    maybeMsg.__accessorPath = [className, memberName];
+                }
+            }
+        }
+    }
+    // Instance members
+    // Skip instance members for enums - they duplicate the static members
+    if (!isEnum(t)) {
+        for (const prop of checker.getPropertiesOfType(t)) {
+            const propName = prop.getName();
+            // Skip TypeScript internals and global augmentations
+            if (isBuiltinConcept(propName)) {
+                logger.debug(`Skipping internal/global member: ${propName}`);
+                continue;
+            }
+            logger.debug(`Adding instance member ${propName}`);
+            const propDecl = prop.valueDeclaration || (prop.declarations && prop.declarations[0]);
+            if (!propDecl)
+                continue;
+            const propType = checker.getTypeOfSymbolAtLocation(prop, propDecl);
+            addClassMember(propName, propType, false, prop);
+        }
+    }
+    // Static (class) members
+    if (classDecl && constructorFunctionType) {
+        for (const sprop of checker.getPropertiesOfType(constructorFunctionType)) {
+            const sname = sprop.getName();
+            if (sname === 'prototype' || sname === 'length' || sname === 'name')
+                continue;
+            const sdecl = (sprop.valueDeclaration || (sprop.declarations && sprop.declarations[0]));
+            if (!sdecl)
+                continue;
+            const stype = checker.getTypeOfSymbolAtLocation(sprop, sdecl);
+            addClassMember(sname, stype, true, sprop);
+        }
+    }
+    // Base classes and implemented interfaces
+    let bases = undefined;
+    const allBases = [];
+    // Get extended base classes
+    const baseTypes = t.getBaseTypes && t.getBaseTypes();
+    if (baseTypes) {
+        allBases.push(...baseTypes);
+    }
+    // Get implemented interfaces from heritage clauses
+    if (classDecl && ts.isClassDeclaration(classDecl) && classDecl.heritageClauses) {
+        for (const heritageClause of classDecl.heritageClauses) {
+            if (heritageClause.token === ts.SyntaxKind.ImplementsKeyword) {
+                for (const typeExpr of heritageClause.types) {
+                    const interfaceType = checker.getTypeAtLocation(typeExpr);
+                    // Only add if not already in baseTypes (avoid duplicates)
+                    if (!baseTypes?.some((bt) => bt === interfaceType)) {
+                        allBases.push(interfaceType);
+                    }
+                }
+            }
+        }
+    }
+    if (allBases.length > 0) {
+        bases = allBases.map((baseType) => {
+            const baseSym = baseType.getSymbol?.();
+            const baseName = baseSym?.getName();
+            logger.debug(`BASE CLASS: detected that ${baseName} is a base class of ${uid.resource}`);
+            // Use compiler signals: instance-side built-ins (e.g., Error) have no constructor declarations
+            if (baseName && !hasConstructor(baseType) && SystemContext.isSystemResourceName(baseName)) {
+                const sysRef = SystemContext.getClassRefByName(World.Client, baseName);
+                if (sysRef)
+                    return sysRef;
+            }
+            const baseUuid = traverseTSType(baseType, false).uid;
+            return ClassMsg.createClassRefMsg(baseUuid);
+        });
+    }
+    // Build constructor parameter mapping
+    let ctor_args;
+    if (constructorFunctionType) {
+        const constructSigs = checker.getSignaturesOfType(constructorFunctionType, ts.SignatureKind.Construct);
+        const ctorSig = constructSigs && constructSigs[0];
+        if (ctorSig) {
+            const argMap = [];
+            for (const param of ctorSig.getParameters()) {
+                const decl = (param.valueDeclaration || param.declarations?.[0]);
+                if (!decl)
+                    continue;
+                const paramType = checker.getTypeOfSymbolAtLocation(param, decl);
+                argMap.push(parseParameterArgument(param, checker, traverseTSType, paramType, typeSubstitutionMap));
+            }
+            if (Object.keys(argMap).length > 0)
+                ctor_args = argMap;
+        }
+    }
+    // Check for index signatures and record metadata
+    // (works for both interfaces and classes)
+    const obj = t;
+    const infos = obj.indexInfos;
+    let indexSignature;
+    if (infos && infos.length > 0) {
+        if (infos.length > 1) {
+            throw new Error(`Type ${className} has multiple index signatures (e.g., both [key: string] and [index: number]). ` +
+                `This is currently not supported during type analysis.`);
+        }
+        const indexInfo = infos[0];
+        const keyTypeUid = traverseTSType(indexInfo.keyType, true, undefined, typeSubstitutionMap).uid;
+        const valueTypeUid = traverseTSType(indexInfo.type, true, undefined, typeSubstitutionMap).uid;
+        logger.debug(`${isInterface ? 'Interface' : 'Class'} has index signature [${indexInfo.keyType.flags}]: ${indexInfo.type.flags} - recording metadata`);
+        // Create or reuse Map<K,V> type for this index signature
+        const mapTypeRef = getOrCreateMapType(ctx, keyTypeUid, valueTypeUid);
+        // Record index signature metadata
+        indexSignature = {
+            key_type: ClassMsg.createClassRefMsg(keyTypeUid),
+            value_type: ClassMsg.createClassRefMsg(valueTypeUid),
+            map_type: mapTypeRef,
+        };
+    }
+    // Construct final message
+    if (isInterface) {
+        const meta = {
+            name: className,
+            fields: fields.length ? fields : [],
+            methods: methods.length ? methods : [],
+            module: t.getSymbol()?.declarations?.[0]?.getSourceFile()?.fileName,
+            bases: undefined, // NOTE: interfaces don't inherit
+            doc: doc || undefined,
+            index_signature: indexSignature,
+        };
+        return ClassMsg.createInterfaceMsg(uid, meta);
+    }
+    else {
+        const payload = {
+            name: className,
+            fields: fields.length ? fields : [],
+            methods: methods.length ? methods : [],
+            module: t.getSymbol()?.declarations?.[0]?.getSourceFile()?.fileName,
+            bases,
+            supplied_type_args,
+            ctor_args,
+            doc: doc || undefined,
+            system_resource: false,
+            index_signature: indexSignature,
+        };
+        const msg = new ClassMsg(uid, payload);
+        return msg;
+    }
+}

package/dist-transformer/transformer/traverser/function-traversal.d.ts

@@ -0,0 +1,7 @@
+import { FunctionMsg } from '../../warpc/msg-protocol/concept/resource/function-msg.js';
+import { DefnUID } from '../../warpc/msg-protocol/kinds.js';
+import * as ts from 'typescript';
+import { TypeSubstitutionMap } from './traversal-utils.js';
+import { TraversalCtx } from './traverser.js';
+export declare function traverseThroughFunction(name: string | undefined, ctx: TraversalCtx, t: ts.Type, uid: DefnUID, typeSubstitutionMap?: TypeSubstitutionMap): FunctionMsg;
+//# sourceMappingURL=function-traversal.d.ts.map

package/dist-transformer/transformer/traverser/function-traversal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-traversal.d.ts","sourceRoot":"","sources":["../../../src/transformer/traverser/function-traversal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAmB,MAAM,mDAAmD,CAAC;AACjG,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAE,mBAAmB,EAA8C,MAAM,mBAAmB,CAAC;AACpG,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAgB,uBAAuB,CACnC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,GAAG,EAAE,YAAY,EACjB,CAAC,EAAE,EAAE,CAAC,IAAI,EACV,GAAG,EAAE,OAAO,EACZ,mBAAmB,CAAC,EAAE,mBAAmB,GAC1C,WAAW,CA+Bb"}

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

@@ -0,0 +1,28 @@
+import { extractDocstringFromSymbol } from '../processor/processor-utils.js';
+import { ClassMsg } from '../../warpc/msg-protocol/concept/resource/class-msg.js';
+import { FunctionMsg } from '../../warpc/msg-protocol/concept/resource/function-msg.js';
+import * as ts from 'typescript';
+import { deriveFunctionName, parseParameterArgument } from './traversal-utils.js';
+export function traverseThroughFunction(name, ctx, t, uid, typeSubstitutionMap) {
+    const { checker, traverseTSType } = ctx;
+    const signatures = checker.getSignaturesOfType(t, ts.SignatureKind.Call);
+    const sig = signatures[0];
+    name = name ?? deriveFunctionName(t, sig);
+    const symbol = t.getSymbol();
+    const doc = symbol ? extractDocstringFromSymbol(symbol) : undefined;
+    const argumentDescriptors = sig
+        .getParameters()
+        .map((param) => parseParameterArgument(param, checker, traverseTSType, undefined, typeSubstitutionMap));
+    const payload = {
+        name,
+        doc: doc || undefined,
+        arguments: argumentDescriptors,
+        returnType: ClassMsg.createClassRefMsg(traverseTSType(checker.getReturnTypeOfSignature(sig), true, sig.declaration &&
+            (ts.isMethodSignature(sig.declaration) ||
+                ts.isMethodDeclaration(sig.declaration) ||
+                ts.isFunctionDeclaration(sig.declaration))
+            ? sig.declaration.type
+            : undefined).uid),
+    };
+    return new FunctionMsg(uid, payload);
+}

package/dist-transformer/transformer/traverser/system-traversal.d.ts

@@ -0,0 +1,13 @@
+import { AnnotationMsg } from '../../warpc/msg-protocol/concept/annotations/annotation-msg.js';
+import { ClassMsg } from '../../warpc/msg-protocol/concept/resource/class-msg.js';
+import { DefnUID } from '../../warpc/msg-protocol/kinds.js';
+import * as ts from 'typescript';
+import { TraversalCtx } from './traverser.js';
+export declare function tryPrimitiveType(t: ts.Type, ctx: TraversalCtx): ClassMsg | undefined;
+/**
+ * Detect direct references to built-in global classes (e.g., String, Number, Boolean, Array, Function, Error, Promise, Map, Set)
+ * and return their system ClassMsg. This is an early-path akin to primitives, avoiding creation of new definitions.
+ */
+export declare function tryPlainSystemType(t: ts.Type, ctx: TraversalCtx): ClassMsg | undefined;
+export declare function tryGenericSystemType(ctx: TraversalCtx, t: ts.Type, uid: DefnUID, typeNode?: ts.TypeNode): AnnotationMsg | undefined;
+//# sourceMappingURL=system-traversal.d.ts.map

package/dist-transformer/transformer/traverser/system-traversal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-traversal.d.ts","sourceRoot":"","sources":["../../../src/transformer/traverser/system-traversal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA6B,MAAM,wDAAwD,CAAC;AAClH,OAAO,EAAE,QAAQ,EAAE,MAAM,gDAAgD,CAAC;AAE1E,OAAO,EAAE,OAAO,EAAS,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAIjC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,YAAY,GAAG,QAAQ,GAAG,SAAS,CA8BpF;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,YAAY,GAAG,QAAQ,GAAG,SAAS,CA2BtF;AAED,wBAAgB,oBAAoB,CAChC,GAAG,EAAE,YAAY,EACjB,CAAC,EAAE,EAAE,CAAC,IAAI,EACV,GAAG,EAAE,OAAO,EACZ,QAAQ,CAAC,EAAE,EAAE,CAAC,QAAQ,GACvB,aAAa,GAAG,SAAS,CA+M3B"}