@synergenius/flow-weaver 0.2.0

package/dist/testing/replayer.js

@@ -0,0 +1,143 @@
+/**
+ * Replay LLM Provider — creates a mock provider from a recorded session.
+ *
+ * Usage:
+ * ```typescript
+ * import { createReplayProvider, loadRecording } from 'flow-weaver/testing';
+ *
+ * const recording = loadRecording(jsonFixture);
+ * const replay = createReplayProvider(recording);
+ *
+ * // Use as LLM provider — calls are replayed in order
+ * (globalThis as unknown as { __fw_llm_provider__?: LLMProvider }).__fw_llm_provider__ = replay;
+ *
+ * // Run workflow — LLM calls return recorded responses, no network calls
+ *
+ * // All MockLlmProvider methods work: getCalls(), getTotalTokens(), etc.
+ * expect(replay.getCallCount()).toBe(3);
+ * ```
+ */
+// ---------------------------------------------------------------------------
+// Replay provider factory
+// ---------------------------------------------------------------------------
+const ZERO_USAGE = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+/**
+ * Creates a MockLlmProvider that replays recorded LLM interactions in order.
+ *
+ * Each `chat()` call returns the next recorded response sequentially.
+ * The returned provider implements the full MockLlmProvider interface,
+ * so all existing assertion helpers and TokenTracker work out of the box.
+ *
+ * @param recording - The recording to replay (from createRecordingProvider or loadRecording)
+ * @param options - Replay configuration
+ * @returns A MockLlmProvider that replays recorded responses
+ */
+export function createReplayProvider(recording, options) {
+    const strict = options?.strict ?? true;
+    const defaultUsage = options?.defaultUsage ?? ZERO_USAGE;
+    const steps = [...recording.steps];
+    let callIndex = 0;
+    const calls = [];
+    return {
+        async chat(messages, chatOptions) {
+            if (callIndex >= steps.length) {
+                if (strict) {
+                    throw new Error(`Replay exhausted: recording has ${steps.length} step(s) but call #${callIndex} was attempted. ` +
+                        `Set strict: false to return a fallback response instead.`);
+                }
+                // Non-strict: return an empty response
+                const fallback = {
+                    content: `[Replay exhausted at call #${callIndex}]`,
+                    toolCalls: [],
+                    finishReason: 'stop',
+                    usage: defaultUsage,
+                };
+                calls.push({
+                    messages: [...messages],
+                    options: chatOptions,
+                    matchedIndex: -1,
+                    response: fallback,
+                    timestamp: Date.now(),
+                });
+                callIndex++;
+                return fallback;
+            }
+            const step = steps[callIndex];
+            const response = {
+                content: step.output.content,
+                toolCalls: step.output.toolCalls ?? [],
+                finishReason: step.output.finishReason ?? 'stop',
+                usage: step.output.usage ?? defaultUsage,
+            };
+            calls.push({
+                messages: [...messages],
+                options: chatOptions,
+                matchedIndex: callIndex,
+                response,
+                timestamp: Date.now(),
+            });
+            callIndex++;
+            return response;
+        },
+        getCalls() {
+            return [...calls];
+        },
+        getCallCount() {
+            return calls.length;
+        },
+        getTotalTokens() {
+            return calls.reduce((sum, call) => sum + (call.response.usage?.totalTokens ?? 0), 0);
+        },
+        getTokenUsage() {
+            return calls.map((call) => call.response.usage ?? defaultUsage);
+        },
+        reset() {
+            calls.length = 0;
+            callIndex = 0;
+        },
+        getCallsForResponse(index) {
+            return calls.filter((c) => c.matchedIndex === index);
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Loading helpers
+// ---------------------------------------------------------------------------
+/**
+ * Parse a recording from JSON data.
+ *
+ * Accepts either a parsed object or a JSON string.
+ * Validates the structure and returns a typed LlmRecording.
+ *
+ * @param data - JSON string or parsed object
+ * @returns A validated LlmRecording
+ */
+export function loadRecording(data) {
+    const parsed = typeof data === 'string' ? JSON.parse(data) : data;
+    if (!parsed || typeof parsed !== 'object') {
+        throw new Error('Invalid recording: expected an object');
+    }
+    const rec = parsed;
+    if (!Array.isArray(rec.steps)) {
+        throw new Error('Invalid recording: missing or invalid "steps" array');
+    }
+    // Validate each step has minimum required fields
+    for (let i = 0; i < rec.steps.length; i++) {
+        const step = rec.steps[i];
+        if (!step.output || typeof step.output !== 'object') {
+            throw new Error(`Invalid recording step ${i}: missing "output" object`);
+        }
+    }
+    return {
+        steps: rec.steps.map((step, i) => ({
+            index: step.index ?? i,
+            input: step.input ?? { messages: [] },
+            output: step.output,
+            timestamp: step.timestamp ?? '',
+            durationMs: step.durationMs ?? 0,
+        })),
+        metadata: rec.metadata ?? {},
+        createdAt: rec.createdAt ?? '',
+    };
+}
+//# sourceMappingURL=replayer.js.map

package/dist/testing/token-tracker.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Token usage tracker for agent workflow tests.
+ *
+ * Accumulates token usage across LLM calls and provides
+ * budget assertions for cost control testing.
+ *
+ * Usage:
+ * ```typescript
+ * import { TokenTracker, createMockLlmProvider } from 'flow-weaver/testing';
+ *
+ * const tracker = new TokenTracker();
+ * const mockLlm = createMockLlmProvider([...]);
+ *
+ * // After running workflow
+ * mockLlm.getCalls().forEach((call, i) => {
+ *   tracker.track(`step-${i}`, call.response.usage);
+ * });
+ *
+ * tracker.assertBelow(10000); // Fail if total exceeds budget
+ * ```
+ */
+import type { LLMTokenUsage } from './mock-llm.js';
+export interface TrackedStep {
+    /** Identifier for this step (e.g., node name, call index) */
+    step: string;
+    /** Token usage for this step */
+    usage: LLMTokenUsage;
+    /** Timestamp when tracked */
+    timestamp: number;
+}
+export declare class TokenTracker {
+    private steps;
+    /** Track token usage for a step */
+    track(step: string, usage?: LLMTokenUsage | {
+        totalTokens: number;
+    }): void;
+    /** Total tokens across all tracked steps */
+    get total(): number;
+    /** Total prompt tokens */
+    get promptTokens(): number;
+    /** Total completion tokens */
+    get completionTokens(): number;
+    /** Number of tracked steps */
+    get stepCount(): number;
+    /** Get all tracked steps */
+    getSteps(): TrackedStep[];
+    /** Get usage for a specific step by name */
+    getStep(step: string): TrackedStep | undefined;
+    /**
+     * Assert total tokens are below a budget.
+     * Throws with a descriptive message if exceeded.
+     */
+    assertBelow(maxTokens: number): void;
+    /**
+     * Assert total tokens are above a minimum.
+     * Useful to verify the LLM was actually called.
+     */
+    assertAbove(minTokens: number): void;
+    /** Reset all tracking data */
+    reset(): void;
+    /**
+     * Convenience: track all calls from a mock LLM provider.
+     * Uses call index as step name unless a nameResolver is provided.
+     */
+    trackFromCalls(calls: Array<{
+        response: {
+            usage?: LLMTokenUsage;
+        };
+    }>, nameResolver?: (index: number) => string): void;
+}
+//# sourceMappingURL=token-tracker.d.ts.map

package/dist/testing/token-tracker.js

@@ -0,0 +1,94 @@
+/**
+ * Token usage tracker for agent workflow tests.
+ *
+ * Accumulates token usage across LLM calls and provides
+ * budget assertions for cost control testing.
+ *
+ * Usage:
+ * ```typescript
+ * import { TokenTracker, createMockLlmProvider } from 'flow-weaver/testing';
+ *
+ * const tracker = new TokenTracker();
+ * const mockLlm = createMockLlmProvider([...]);
+ *
+ * // After running workflow
+ * mockLlm.getCalls().forEach((call, i) => {
+ *   tracker.track(`step-${i}`, call.response.usage);
+ * });
+ *
+ * tracker.assertBelow(10000); // Fail if total exceeds budget
+ * ```
+ */
+export class TokenTracker {
+    steps = [];
+    /** Track token usage for a step */
+    track(step, usage) {
+        const normalized = {
+            promptTokens: usage?.promptTokens ?? 0,
+            completionTokens: usage?.completionTokens ?? 0,
+            totalTokens: usage?.totalTokens ?? 0,
+        };
+        this.steps.push({ step, usage: normalized, timestamp: Date.now() });
+    }
+    /** Total tokens across all tracked steps */
+    get total() {
+        return this.steps.reduce((sum, s) => sum + s.usage.totalTokens, 0);
+    }
+    /** Total prompt tokens */
+    get promptTokens() {
+        return this.steps.reduce((sum, s) => sum + s.usage.promptTokens, 0);
+    }
+    /** Total completion tokens */
+    get completionTokens() {
+        return this.steps.reduce((sum, s) => sum + s.usage.completionTokens, 0);
+    }
+    /** Number of tracked steps */
+    get stepCount() {
+        return this.steps.length;
+    }
+    /** Get all tracked steps */
+    getSteps() {
+        return [...this.steps];
+    }
+    /** Get usage for a specific step by name */
+    getStep(step) {
+        return this.steps.find((s) => s.step === step);
+    }
+    /**
+     * Assert total tokens are below a budget.
+     * Throws with a descriptive message if exceeded.
+     */
+    assertBelow(maxTokens) {
+        if (this.total > maxTokens) {
+            const breakdown = this.steps
+                .map((s) => `  ${s.step}: ${s.usage.totalTokens} tokens`)
+                .join('\n');
+            throw new Error(`Token budget exceeded: ${this.total} > ${maxTokens}\n` +
+                `Breakdown (${this.steps.length} steps):\n${breakdown}`);
+        }
+    }
+    /**
+     * Assert total tokens are above a minimum.
+     * Useful to verify the LLM was actually called.
+     */
+    assertAbove(minTokens) {
+        if (this.total < minTokens) {
+            throw new Error(`Token usage too low: ${this.total} < ${minTokens}. Was the LLM actually called?`);
+        }
+    }
+    /** Reset all tracking data */
+    reset() {
+        this.steps.length = 0;
+    }
+    /**
+     * Convenience: track all calls from a mock LLM provider.
+     * Uses call index as step name unless a nameResolver is provided.
+     */
+    trackFromCalls(calls, nameResolver) {
+        calls.forEach((call, i) => {
+            const step = nameResolver ? nameResolver(i) : `call-${i}`;
+            this.track(step, call.response.usage);
+        });
+    }
+}
+//# sourceMappingURL=token-tracker.js.map

package/dist/type-checker.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Type Checker Module
+ *
+ * Provides TypeScript-level type compatibility checking using ts-morph and TypeScript's compiler API.
+ * This enables proper structural typing and subtype checking beyond simple string comparison.
+ */
+import type { Type, TypeChecker } from "ts-morph";
+import type { TTypeCompatibility } from "./ast/types.js";
+/**
+ * Check if a source type can be safely coerced to a target type at runtime.
+ *
+ * @param sourceText - The source type as a string
+ * @param targetText - The target type as a string
+ * @returns true if the coercion is safe
+ */
+export declare function isRuntimeCoercible(sourceText: string, targetText: string): boolean;
+/**
+ * Check type compatibility between two ts-morph Type objects.
+ *
+ * This uses TypeScript's actual type system for proper structural typing:
+ * - Structural typing (duck typing)
+ * - Inheritance (Admin extends User)
+ * - Generics (Array<T>, Promise<T>)
+ * - Union/Intersection types
+ * - Type narrowing
+ *
+ * @param sourceType - The source type (from output port)
+ * @param targetType - The target type (from input port)
+ * @param typeChecker - Optional ts-morph TypeChecker for advanced assignability checks
+ * @returns TTypeCompatibility result
+ */
+export declare function checkTypeCompatibility(sourceType: Type, targetType: Type, typeChecker?: TypeChecker): TTypeCompatibility;
+/**
+ * Check type compatibility using string representations.
+ * Fallback for JSON-loaded workflows without ts-morph Type objects.
+ *
+ * @param sourceText - The source type as a string
+ * @param targetText - The target type as a string
+ * @returns TTypeCompatibility result
+ */
+export declare function checkTypeCompatibilityFromStrings(sourceText: string, targetText: string): TTypeCompatibility;
+//# sourceMappingURL=type-checker.d.ts.map

package/dist/type-checker.js

@@ -0,0 +1,190 @@
+/**
+ * Type Checker Module
+ *
+ * Provides TypeScript-level type compatibility checking using ts-morph and TypeScript's compiler API.
+ * This enables proper structural typing and subtype checking beyond simple string comparison.
+ */
+/**
+ * Safe runtime coercions that JavaScript handles automatically.
+ * These are source -> target pairs where coercion is safe and predictable.
+ */
+const SAFE_COERCIONS = [
+    ["number", "string"], // Number.toString()
+    ["boolean", "string"], // Boolean.toString()
+];
+/**
+ * Check if a source type can be safely coerced to a target type at runtime.
+ *
+ * @param sourceText - The source type as a string
+ * @param targetText - The target type as a string
+ * @returns true if the coercion is safe
+ */
+export function isRuntimeCoercible(sourceText, targetText) {
+    const sourceLower = sourceText.toLowerCase();
+    const targetLower = targetText.toLowerCase();
+    for (const [from, to] of SAFE_COERCIONS) {
+        if (sourceLower === from && targetLower === to) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check type compatibility between two ts-morph Type objects.
+ *
+ * This uses TypeScript's actual type system for proper structural typing:
+ * - Structural typing (duck typing)
+ * - Inheritance (Admin extends User)
+ * - Generics (Array<T>, Promise<T>)
+ * - Union/Intersection types
+ * - Type narrowing
+ *
+ * @param sourceType - The source type (from output port)
+ * @param targetType - The target type (from input port)
+ * @param typeChecker - Optional ts-morph TypeChecker for advanced assignability checks
+ * @returns TTypeCompatibility result
+ */
+export function checkTypeCompatibility(sourceType, targetType, typeChecker) {
+    const sourceText = sourceType.getText();
+    const targetText = targetType.getText();
+    // Exact string match - fastest path
+    if (sourceText === targetText) {
+        return {
+            isCompatible: true,
+            reason: "exact",
+            sourceType: sourceText,
+            targetType: targetText,
+        };
+    }
+    // Try TypeScript's native assignability check if typeChecker is available
+    if (typeChecker) {
+        // Access the internal TypeScript compiler's type checker
+        const tsTypeChecker = typeChecker.compilerObject;
+        if (tsTypeChecker.isTypeAssignableTo) {
+            const isAssignable = tsTypeChecker.isTypeAssignableTo(sourceType.compilerType, targetType.compilerType);
+            if (isAssignable) {
+                return {
+                    isCompatible: true,
+                    reason: "assignable",
+                    sourceType: sourceText,
+                    targetType: targetText,
+                };
+            }
+        }
+    }
+    // Fallback: Check inheritance via base types
+    if (isSubtypeViaBaseTypes(sourceType, targetType)) {
+        return {
+            isCompatible: true,
+            reason: "assignable",
+            sourceType: sourceText,
+            targetType: targetText,
+        };
+    }
+    // Check for safe runtime coercions (NUMBER→STRING, BOOLEAN→STRING)
+    if (isRuntimeCoercible(sourceText, targetText)) {
+        return {
+            isCompatible: true,
+            reason: "coercible",
+            sourceType: sourceText,
+            targetType: targetText,
+        };
+    }
+    // Types are incompatible
+    return {
+        isCompatible: false,
+        reason: "incompatible",
+        sourceType: sourceText,
+        targetType: targetText,
+        errorMessage: `Type '${sourceText}' is not assignable to type '${targetText}'`,
+    };
+}
+/**
+ * Check if sourceType is a subtype of targetType via inheritance chain.
+ * Uses getBaseTypes() to traverse the type hierarchy.
+ */
+function isSubtypeViaBaseTypes(sourceType, targetType) {
+    const targetText = targetType.getText();
+    const visited = new Set();
+    function checkBaseTypes(type) {
+        const typeText = type.getText();
+        // Avoid infinite loops
+        if (visited.has(typeText))
+            return false;
+        visited.add(typeText);
+        // Check if this type matches target
+        if (typeText === targetText)
+            return true;
+        // Check base types recursively
+        try {
+            const baseTypes = type.getBaseTypes();
+            for (const baseType of baseTypes) {
+                if (checkBaseTypes(baseType))
+                    return true;
+            }
+        }
+        catch {
+            // Some types don't have base types
+        }
+        return false;
+    }
+    // Check if source's base types include target
+    try {
+        const baseTypes = sourceType.getBaseTypes();
+        for (const baseType of baseTypes) {
+            if (checkBaseTypes(baseType))
+                return true;
+        }
+    }
+    catch {
+        // Some types don't have base types
+    }
+    return false;
+}
+/**
+ * Check type compatibility using string representations.
+ * Fallback for JSON-loaded workflows without ts-morph Type objects.
+ *
+ * @param sourceText - The source type as a string
+ * @param targetText - The target type as a string
+ * @returns TTypeCompatibility result
+ */
+export function checkTypeCompatibilityFromStrings(sourceText, targetText) {
+    // Exact string match
+    if (sourceText === targetText) {
+        return {
+            isCompatible: true,
+            reason: "exact",
+            sourceType: sourceText,
+            targetType: targetText,
+        };
+    }
+    // any is compatible with everything
+    if (sourceText === "any" || targetText === "any") {
+        return {
+            isCompatible: true,
+            reason: "assignable",
+            sourceType: sourceText,
+            targetType: targetText,
+        };
+    }
+    // Check for safe runtime coercions
+    if (isRuntimeCoercible(sourceText, targetText)) {
+        return {
+            isCompatible: true,
+            reason: "coercible",
+            sourceType: sourceText,
+            targetType: targetText,
+        };
+    }
+    // String comparison can't determine structural compatibility
+    // Mark as incompatible, but the validator may want to be lenient
+    return {
+        isCompatible: false,
+        reason: "incompatible",
+        sourceType: sourceText,
+        targetType: targetText,
+        errorMessage: `Type '${sourceText}' is not assignable to type '${targetText}'`,
+    };
+}
+//# sourceMappingURL=type-checker.js.map

package/dist/type-mappings.d.ts

@@ -0,0 +1,29 @@
+import type { TDataType } from './ast/types.js';
+export type TypeScriptType = 'string' | 'number' | 'boolean' | 'unknown' | 'unknown[]' | 'void' | 'Function' | 'Record<string, unknown>' | '(...args: unknown[]) => unknown';
+export interface PortTypeMapping {
+    readonly typescript: TypeScriptType;
+    readonly description?: string;
+}
+export declare const PORT_TYPE_MAPPINGS: Record<TDataType, PortTypeMapping>;
+export declare function mapToTypeScript(portType: TDataType, tsType?: string): TypeScriptType | string;
+export declare function isValidPortType(type: string): type is TDataType;
+export declare function getAllPortTypes(): ReadonlyArray<TDataType>;
+export declare function getPortTypeDescription(portType: TDataType): string | undefined;
+/**
+ * Infer TDataType from a TypeScript type string.
+ * This is the reverse mapping: TypeScript type → Flow Weaver semantic type.
+ *
+ * @param tsType - The TypeScript type string (e.g., "string", "number[]", "User")
+ * @returns The corresponding TDataType for color/category mapping
+ *
+ * @example
+ * inferDataTypeFromTS("string") // → "STRING"
+ * inferDataTypeFromTS("number") // → "NUMBER"
+ * inferDataTypeFromTS("boolean") // → "BOOLEAN"
+ * inferDataTypeFromTS("User[]") // → "ARRAY"
+ * inferDataTypeFromTS("Array<number>") // → "ARRAY"
+ * inferDataTypeFromTS("Map<string, User>") // → "OBJECT"
+ * inferDataTypeFromTS("(x: number) => string") // → "FUNCTION"
+ */
+export declare function inferDataTypeFromTS(tsType: string): TDataType;
+//# sourceMappingURL=type-mappings.d.ts.map

package/dist/type-mappings.js

@@ -0,0 +1,125 @@
+export const PORT_TYPE_MAPPINGS = {
+    STRING: {
+        typescript: 'string',
+        description: 'Text value',
+    },
+    NUMBER: {
+        typescript: 'number',
+        description: 'Numeric value',
+    },
+    BOOLEAN: {
+        typescript: 'boolean',
+        description: 'True or false value',
+    },
+    ARRAY: {
+        typescript: 'unknown[]',
+        description: 'Array of values',
+    },
+    OBJECT: {
+        typescript: 'Record<string, unknown>',
+        description: 'Object with properties',
+    },
+    FUNCTION: {
+        typescript: '(...args: unknown[]) => unknown',
+        description: 'Function or callback',
+    },
+    ANY: {
+        typescript: 'unknown',
+        description: 'Any type of value',
+    },
+    STEP: {
+        typescript: 'boolean',
+        description: 'Control flow signal (boolean in public API)',
+    },
+};
+export function mapToTypeScript(portType, tsType) {
+    const mapping = PORT_TYPE_MAPPINGS[portType];
+    if (!mapping) {
+        console.warn(`Unknown port type: ${portType}, defaulting to 'unknown'`);
+        return 'unknown';
+    }
+    // For non-primitive types, use tsType if provided
+    if (tsType &&
+        (portType === 'OBJECT' || portType === 'ANY' || portType === 'ARRAY' || portType === 'FUNCTION')) {
+        return tsType;
+    }
+    return mapping.typescript;
+}
+export function isValidPortType(type) {
+    return type in PORT_TYPE_MAPPINGS;
+}
+export function getAllPortTypes() {
+    return Object.keys(PORT_TYPE_MAPPINGS);
+}
+export function getPortTypeDescription(portType) {
+    return PORT_TYPE_MAPPINGS[portType]?.description;
+}
+/**
+ * Infer TDataType from a TypeScript type string.
+ * This is the reverse mapping: TypeScript type → Flow Weaver semantic type.
+ *
+ * @param tsType - The TypeScript type string (e.g., "string", "number[]", "User")
+ * @returns The corresponding TDataType for color/category mapping
+ *
+ * @example
+ * inferDataTypeFromTS("string") // → "STRING"
+ * inferDataTypeFromTS("number") // → "NUMBER"
+ * inferDataTypeFromTS("boolean") // → "BOOLEAN"
+ * inferDataTypeFromTS("User[]") // → "ARRAY"
+ * inferDataTypeFromTS("Array<number>") // → "ARRAY"
+ * inferDataTypeFromTS("Map<string, User>") // → "OBJECT"
+ * inferDataTypeFromTS("(x: number) => string") // → "FUNCTION"
+ */
+export function inferDataTypeFromTS(tsType) {
+    const normalized = tsType.trim();
+    // Exact primitive matches
+    if (normalized === 'string')
+        return 'STRING';
+    if (normalized === 'number')
+        return 'NUMBER';
+    if (normalized === 'boolean')
+        return 'BOOLEAN';
+    // Any/unknown fallback
+    if (normalized === 'any' || normalized === 'unknown' || normalized === 'never') {
+        return 'ANY';
+    }
+    // Void (rare, but handle it)
+    if (normalized === 'void' || normalized === 'undefined' || normalized === 'null') {
+        return 'ANY';
+    }
+    // Array patterns: T[], Array<T>, ReadonlyArray<T>
+    if (normalized.endsWith('[]') ||
+        normalized.startsWith('Array<') ||
+        normalized.startsWith('ReadonlyArray<')) {
+        return 'ARRAY';
+    }
+    // Function patterns: () => T, (args) => T, Function
+    if (normalized.includes('=>') || normalized === 'Function' || normalized.startsWith('(')) {
+        return 'FUNCTION';
+    }
+    // Promise unwrapping: Promise<T> → infer from T
+    if (normalized.startsWith('Promise<') && normalized.endsWith('>')) {
+        const inner = normalized.slice(8, -1);
+        return inferDataTypeFromTS(inner);
+    }
+    // Union types: handle T | undefined and T | null as optional types
+    if (normalized.includes('|')) {
+        // Split by | and filter out undefined/null
+        const parts = normalized.split('|').map((p) => p.trim());
+        const nonNullParts = parts.filter((p) => p !== 'undefined' && p !== 'null');
+        if (nonNullParts.length === 1) {
+            // This is an optional type (T | undefined or T | null) - infer from T
+            return inferDataTypeFromTS(nonNullParts[0]);
+        }
+        // True union type - default to ANY
+        return 'ANY';
+    }
+    // Intersection types: if contains &, default to OBJECT
+    if (normalized.includes('&')) {
+        return 'OBJECT';
+    }
+    // Generic object types (Map, Set, Record, etc.) → OBJECT
+    // Any remaining complex type → OBJECT
+    return 'OBJECT';
+}
+//# sourceMappingURL=type-mappings.js.map