@ai-setting/roy-agent-cli 1.3.18 → 1.3.22

package/dist/core/src/env/workflow/utils/recovery-validator.test.js

@@ -1,401 +0,0 @@
-import { describe, it, expect, beforeEach } from 'bun:test';
-import { RecoveryValidator } from "./recovery-validator.js";
-import { ValidationErrorType } from "./validation-rules.js";
-/**
- * Helper to create workflow node call message
- */
-function createNodeCallMsg(nodeId, sessionId) {
-    return {
-        id: `call_${nodeId}`,
-        sessionID: sessionId,
-        role: 'workflow.node.call',
-        content: JSON.stringify({}),
-        timestamp: Date.now(),
-        metadata: { type: 'workflow.node.call', workflowNodeId: nodeId },
-    };
-}
-/**
- * Helper to create workflow node result message
- * For the ExecutionStateBuilder to work correctly,
- * the result message must immediately follow the call message
- */
-function createNodeResultMsg(nodeId, sessionId, output) {
-    return {
-        id: `result_${nodeId}`,
-        sessionID: sessionId,
-        role: 'workflow.node.result',
-        content: JSON.stringify(output),
-        timestamp: Date.now(),
-        metadata: { type: 'workflow.node.result', workflowNodeId: nodeId },
-    };
-}
-describe("RecoveryValidator", () => {
-    let validator;
-    beforeEach(() => {
-        // 清除环境变量中的 trace context，避免继承外部上下文
-        delete process.env['TRACEPARENT'];
-        delete process.env['TRACE_ID'];
-        delete process.env['LOG_TRACE_REQUEST_ID'];
-        validator = new RecoveryValidator();
-    });
-    describe("validate", () => {
-        describe("state integrity checks", () => {
-            it("should validate when workflow has no variables", async () => {
-                // Given
-                const sessionId = 'test_session';
-                const definition = {
-                    name: 'test-workflow',
-                    nodes: [
-                        { id: 'node_a', type: 'tool' },
-                        { id: 'node_b', type: 'tool' },
-                    ],
-                    edges: [
-                        { source: 'node_a', target: 'node_b' },
-                    ],
-                    entry: 'node_a',
-                };
-                // Messages with proper call-result pairing
-                const messages = [
-                    createNodeCallMsg('node_a', sessionId),
-                    createNodeResultMsg('node_a', sessionId, { output: 'result_a' }),
-                    createNodeCallMsg('node_b', sessionId),
-                ];
-                // When
-                const result = await validator.validate(messages, definition);
-                // Then - should be valid since no missing variables
-                expect(result.isValid).toBe(true);
-                expect(result.errors).toHaveLength(0);
-            });
-            it("should detect missing variables when pending nodes are tracked", async () => {
-                // Note: This test validates the validator's ability to check variables.
-                // The actual detection depends on ExecutionStateBuilder correctly tracking pending nodes.
-                // Given the current implementation, we test the validator API works correctly.
-                // Given
-                const sessionId = 'test_session';
-                const definition = {
-                    name: 'test-workflow',
-                    nodes: [
-                        { id: 'node_a', type: 'tool' },
-                        { id: 'node_b', type: 'tool', config: { value: '{{missing_var}}' } },
-                    ],
-                    edges: [
-                        { source: 'node_a', target: 'node_b' },
-                    ],
-                    entry: 'node_a',
-                };
-                const messages = [
-                    createNodeCallMsg('node_a', sessionId),
-                    createNodeResultMsg('node_a', sessionId, { output: 'result_a' }),
-                    createNodeCallMsg('node_b', sessionId),
-                ];
-                // When
-                const result = await validator.validate(messages, definition);
-                // Then - verify the validator returned a valid result structure
-                expect(result).toBeDefined();
-                expect(typeof result.isValid).toBe('boolean');
-                expect(Array.isArray(result.errors)).toBe(true);
-                expect(Array.isArray(result.warnings)).toBe(true);
-            });
-            it("should handle multiple variable references", async () => {
-                // Given
-                const sessionId = 'test_session';
-                const definition = {
-                    name: 'multi-var-workflow',
-                    nodes: [
-                        { id: 'start', type: 'tool' },
-                        { id: 'process', type: 'tool', config: { input: '{{start.result}} and {{start.status}}' } },
-                    ],
-                    edges: [
-                        { source: 'start', target: 'process' },
-                    ],
-                    entry: 'start',
-                };
-                const messages = [
-                    createNodeCallMsg('start', sessionId),
-                    createNodeResultMsg('start', sessionId, { result: 'value', status: 'ok' }),
-                    createNodeCallMsg('process', sessionId),
-                ];
-                // When
-                const result = await validator.validate(messages, definition);
-                // Then - should be valid when variables exist
-                expect(result.isValid).toBe(true);
-                expect(result.errors).toHaveLength(0);
-            });
-        });
-        describe("parallel branch validation", () => {
-            it("should detect incomplete parallel branches", async () => {
-                // Given
-                const sessionId = 'test_session';
-                const definition = {
-                    name: 'parallel-workflow',
-                    nodes: [
-                        { id: 'start', type: 'tool' },
-                        { id: 'branch_a', type: 'tool' },
-                        { id: 'branch_b', type: 'tool' },
-                        { id: 'branch_c', type: 'tool' },
-                        { id: 'merge', type: 'tool' },
-                    ],
-                    edges: [
-                        { source: 'start', target: 'branch_a' },
-                        { source: 'start', target: 'branch_b' },
-                        { source: 'start', target: 'branch_c' },
-                        { source: 'branch_a', target: 'merge' },
-                        { source: 'branch_b', target: 'merge' },
-                        { source: 'branch_c', target: 'merge' },
-                    ],
-                    entry: 'start',
-                };
-                // Only branch_a and branch_b completed, branch_c is missing
-                const messages = [
-                    createNodeCallMsg('start', sessionId),
-                    createNodeResultMsg('start', sessionId, { output: 'done' }),
-                    createNodeCallMsg('branch_a', sessionId),
-                    createNodeResultMsg('branch_a', sessionId, { output: 'done' }),
-                    createNodeCallMsg('branch_b', sessionId),
-                    createNodeResultMsg('branch_b', sessionId, { output: 'done' }),
-                    // branch_c is not called - incomplete parallel
-                ];
-                // When
-                const result = await validator.validate(messages, definition);
-                // Then
-                expect(result.isValid).toBe(false);
-                expect(result.errors.some(e => e.type === ValidationErrorType.INCOMPLETE_PARALLEL)).toBe(true);
-            });
-            it("should pass when all parallel branches complete", async () => {
-                // Given
-                const sessionId = 'test_session';
-                const definition = {
-                    name: 'parallel-workflow',
-                    nodes: [
-                        { id: 'start', type: 'tool' },
-                        { id: 'branch_a', type: 'tool' },
-                        { id: 'branch_b', type: 'tool' },
-                        { id: 'branch_c', type: 'tool' },
-                        { id: 'merge', type: 'tool' },
-                    ],
-                    edges: [
-                        { source: 'start', target: 'branch_a' },
-                        { source: 'start', target: 'branch_b' },
-                        { source: 'start', target: 'branch_c' },
-                        { source: 'branch_a', target: 'merge' },
-                        { source: 'branch_b', target: 'merge' },
-                        { source: 'branch_c', target: 'merge' },
-                    ],
-                    entry: 'start',
-                };
-                // All branches completed
-                const messages = [
-                    createNodeCallMsg('start', sessionId),
-                    createNodeResultMsg('start', sessionId, { output: 'done' }),
-                    createNodeCallMsg('branch_a', sessionId),
-                    createNodeResultMsg('branch_a', sessionId, { output: 'done' }),
-                    createNodeCallMsg('branch_b', sessionId),
-                    createNodeResultMsg('branch_b', sessionId, { output: 'done' }),
-                    createNodeCallMsg('branch_c', sessionId),
-                    createNodeResultMsg('branch_c', sessionId, { output: 'done' }),
-                ];
-                // When
-                const result = await validator.validate(messages, definition);
-                // Then
-                expect(result.isValid).toBe(true);
-            });
-        });
-        describe("empty state validation", () => {
-            it("should be valid with empty messages", async () => {
-                // Given
-                const definition = {
-                    name: 'test-workflow',
-                    nodes: [
-                        { id: 'node_a', type: 'tool' },
-                    ],
-                    edges: [],
-                    entry: 'node_a',
-                };
-                const messages = [];
-                // When
-                const result = await validator.validate(messages, definition);
-                // Then
-                expect(result.isValid).toBe(true);
-            });
-        });
-    });
-    describe("generatePlan", () => {
-        it("should generate plan for completed and pending nodes", async () => {
-            // Given
-            const sessionId = 'test_session';
-            const definition = {
-                name: 'test',
-                nodes: [
-                    { id: 'a', type: 'tool' },
-                    { id: 'b', type: 'tool' },
-                ],
-                edges: [{ source: 'a', target: 'b' }],
-                entry: 'a',
-            };
-            const messages = [
-                createNodeCallMsg('a', sessionId),
-                createNodeResultMsg('a', sessionId, { output: 'a_done' }),
-                createNodeCallMsg('b', sessionId),
-            ];
-            // When
-            const plan = await validator.generatePlan(messages, definition);
-            // Then
-            expect(plan).toBeDefined();
-            expect(plan.resumePoint).toBeTruthy();
-            expect(plan.completedNodes).toBeDefined();
-            expect(plan.pendingNodes).toBeDefined();
-            expect(Array.isArray(plan.completedNodes)).toBe(true);
-            expect(Array.isArray(plan.pendingNodes)).toBe(true);
-        });
-        it("should include validation errors in plan", async () => {
-            // Given
-            const sessionId = 'test_session';
-            const definition = {
-                name: 'test',
-                nodes: [
-                    { id: 'a', type: 'tool' },
-                    { id: 'b', type: 'tool', config: { val: '{{missing}}' } },
-                ],
-                edges: [{ source: 'a', target: 'b' }],
-                entry: 'a',
-            };
-            const messages = [
-                createNodeCallMsg('a', sessionId),
-                createNodeResultMsg('a', sessionId, { output: 'done' }),
-                createNodeCallMsg('b', sessionId),
-            ];
-            // When
-            const plan = await validator.generatePlan(messages, definition);
-            // Then
-            expect(plan.validationErrors).toBeDefined();
-            expect(Array.isArray(plan.validationErrors)).toBe(true);
-        });
-        it("should determine resume point", async () => {
-            // Given
-            const sessionId = 'test_session';
-            const definition = {
-                name: 'test',
-                nodes: [
-                    { id: 'a', type: 'tool' },
-                    { id: 'b', type: 'tool' },
-                    { id: 'c', type: 'tool' },
-                ],
-                edges: [
-                    { source: 'a', target: 'b' },
-                    { source: 'b', target: 'c' },
-                ],
-                entry: 'a',
-            };
-            const messages = [
-                createNodeCallMsg('a', sessionId),
-                createNodeResultMsg('a', sessionId, { output: 'done' }),
-            ];
-            // When
-            const plan = await validator.generatePlan(messages, definition);
-            // Then
-            expect(plan.resumePoint).toBeTruthy();
-            expect(typeof plan.resumePoint).toBe('string');
-        });
-        it("should handle fully completed workflow", async () => {
-            // Given
-            const sessionId = 'test_session';
-            const definition = {
-                name: 'test',
-                nodes: [
-                    { id: 'a', type: 'tool' },
-                    { id: 'b', type: 'tool' },
-                ],
-                edges: [{ source: 'a', target: 'b' }],
-                entry: 'a',
-            };
-            const messages = [
-                createNodeCallMsg('a', sessionId),
-                createNodeResultMsg('a', sessionId, { output: 'done' }),
-                createNodeCallMsg('b', sessionId),
-                createNodeResultMsg('b', sessionId, { output: 'done' }),
-            ];
-            // When
-            const plan = await validator.generatePlan(messages, definition);
-            // Then
-            expect(plan.canResume).toBe(true);
-            expect(plan.completedNodes.length).toBeGreaterThanOrEqual(0);
-        });
-        it("should generate summary text", async () => {
-            // Given
-            const sessionId = 'test_session';
-            const definition = {
-                name: 'test',
-                nodes: [
-                    { id: 'a', type: 'tool' },
-                    { id: 'b', type: 'tool' },
-                ],
-                edges: [{ source: 'a', target: 'b' }],
-                entry: 'a',
-            };
-            const messages = [
-                createNodeCallMsg('a', sessionId),
-                createNodeResultMsg('a', sessionId, { output: 'done' }),
-            ];
-            // When
-            const plan = await validator.generatePlan(messages, definition);
-            // Then
-            expect(plan.summary).toBeTruthy();
-            expect(typeof plan.summary).toBe('string');
-            expect(plan.summary.length).toBeGreaterThan(0);
-        });
-        it("should track skipped nodes array", async () => {
-            // Given
-            const sessionId = 'test_session';
-            const definition = {
-                name: 'test',
-                nodes: [
-                    { id: 'a', type: 'tool' },
-                    { id: 'b', type: 'tool' },
-                    { id: 'c', type: 'tool' },
-                ],
-                edges: [
-                    { source: 'a', target: 'b' },
-                    { source: 'a', target: 'c' },
-                ],
-                entry: 'a',
-            };
-            const messages = [
-                createNodeCallMsg('a', sessionId),
-                createNodeResultMsg('a', sessionId, { output: 'done' }),
-                createNodeCallMsg('b', sessionId),
-                createNodeResultMsg('b', sessionId, { output: 'done' }),
-            ];
-            // When
-            const plan = await validator.generatePlan(messages, definition);
-            // Then
-            expect(plan.skippedNodes).toBeDefined();
-            expect(Array.isArray(plan.skippedNodes)).toBe(true);
-        });
-        it("should report canResume based on validation errors", async () => {
-            // Given - workflow with conditional edge that can't be evaluated
-            const sessionId = 'test_session';
-            const definition = {
-                name: 'conditional-workflow',
-                nodes: [
-                    { id: 'start', type: 'tool' },
-                    { id: 'branch_a', type: 'tool' },
-                    { id: 'branch_b', type: 'tool' },
-                ],
-                edges: [
-                    { source: 'start', target: 'branch_a', condition: '{{unknown_condition}}' },
-                    { source: 'start', target: 'branch_b' },
-                ],
-                entry: 'start',
-            };
-            const messages = [
-                createNodeCallMsg('start', sessionId),
-                createNodeResultMsg('start', sessionId, { output: 'done' }),
-            ];
-            // When
-            const plan = await validator.generatePlan(messages, definition);
-            // Then
-            expect(typeof plan.canResume).toBe('boolean');
-        });
-    });
-});
-//# sourceMappingURL=recovery-validator.test.js.map

package/dist/core/src/env/workflow/utils/session-parser.d.ts

@@ -1,22 +0,0 @@
-import type { SessionMessage } from '../../session/types';
-/**
- * 查找最后一个 workflow.node.interrupt 消息
- */
-export declare function findLastInterruptMessage(messages: SessionMessage[]): SessionMessage | null;
-/**
- * 解析节点输出
- */
-export declare function parseNodeOutputs(messages: SessionMessage[]): Map<string, unknown>;
-/**
- * 获取下一个待执行的节点
- */
-export declare function getNextPendingNode(messages: SessionMessage[]): string | null;
-/**
- * 从 interrupt 消息获取 agentSessionId
- */
-export declare function getAgentSessionIdFromInterrupt(interruptMessage: SessionMessage): string | undefined;
-/**
- * 检查 session 是否在等待用户
- */
-export declare function isWaitingForUser(messages: SessionMessage[]): boolean;
-//# sourceMappingURL=session-parser.d.ts.map

package/dist/core/src/env/workflow/utils/session-parser.js

@@ -1,72 +0,0 @@
-/**
- * 查找最后一个 workflow.node.interrupt 消息
- */
-export function findLastInterruptMessage(messages) {
-    const interrupts = messages.filter(m => m.metadata?.type === 'workflow.node.interrupt');
-    return interrupts[interrupts.length - 1] || null;
-}
-/**
- * 解析节点输出
- */
-export function parseNodeOutputs(messages) {
-    const outputs = new Map();
-    let lastCallNodeId = null;
-    for (const msg of messages) {
-        if (msg.metadata?.type === 'workflow.node.call') {
-            const metadata = msg.metadata;
-            lastCallNodeId = metadata.workflowNodeId;
-        }
-        else if (msg.metadata?.type === 'workflow.node.result') {
-            if (lastCallNodeId) {
-                try {
-                    outputs.set(lastCallNodeId, JSON.parse(msg.content));
-                }
-                catch {
-                    outputs.set(lastCallNodeId, msg.content);
-                }
-            }
-            lastCallNodeId = null;
-        }
-    }
-    return outputs;
-}
-/**
- * 获取下一个待执行的节点
- */
-export function getNextPendingNode(messages) {
-    const outputs = parseNodeOutputs(messages);
-    const completedNodes = new Set(outputs.keys());
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.metadata?.type === 'workflow.node.call') {
-            const metadata = msg.metadata;
-            const nodeId = metadata.workflowNodeId;
-            if (!completedNodes.has(nodeId)) {
-                return nodeId;
-            }
-        }
-    }
-    return null;
-}
-/**
- * 从 interrupt 消息获取 agentSessionId
- */
-export function getAgentSessionIdFromInterrupt(interruptMessage) {
-    if (interruptMessage.metadata?.type === 'workflow.node.interrupt') {
-        const metadata = interruptMessage.metadata;
-        return metadata.agentSessionId;
-    }
-    return undefined;
-}
-/**
- * 检查 session 是否在等待用户
- */
-export function isWaitingForUser(messages) {
-    const lastInterrupt = findLastInterruptMessage(messages);
-    if (!lastInterrupt)
-        return false;
-    const interruptIndex = messages.indexOf(lastInterrupt);
-    const afterInterrupt = messages.slice(interruptIndex + 1);
-    return !afterInterrupt.some(m => m.metadata?.type === 'workflow.node.resume');
-}
-//# sourceMappingURL=session-parser.js.map

package/dist/core/src/env/workflow/utils/session-parser.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=session-parser.test.d.ts.map

package/dist/core/src/env/workflow/utils/session-parser.test.js

@@ -1,89 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-import { findLastInterruptMessage, parseNodeOutputs, getNextPendingNode, getAgentSessionIdFromInterrupt, isWaitingForUser, } from "./session-parser.js";
-describe('session-parser', () => {
-    const createMessage = (metadata, content = '{}') => ({
-        id: `msg_${Math.random()}`,
-        sessionID: 'workflow_test',
-        role: 'user',
-        content,
-        timestamp: Date.now(),
-        metadata,
-    });
-    describe('findLastInterruptMessage', () => {
-        it('should return last interrupt message', () => {
-            const messages = [
-                createMessage({ type: 'workflow.node.call', workflowNodeId: 'n1' }),
-                createMessage({ type: 'workflow.node.result', workflowNodeId: 'n1' }),
-                createMessage({ type: 'workflow.node.call', workflowNodeId: 'n2' }),
-                createMessage({ type: 'workflow.node.interrupt', workflowNodeId: 'n2', query: 'Q1' }),
-                createMessage({ type: 'workflow.node.call', workflowNodeId: 'n3' }),
-                createMessage({ type: 'workflow.node.interrupt', workflowNodeId: 'n3', query: 'Q2' }),
-            ];
-            const result = findLastInterruptMessage(messages);
-            expect(result?.metadata?.workflowNodeId).toBe('n3');
-        });
-        it('should return null if no interrupt', () => {
-            const messages = [
-                createMessage({ type: 'workflow.node.call', workflowNodeId: 'n1' }),
-                createMessage({ type: 'workflow.node.result', workflowNodeId: 'n1' }),
-            ];
-            expect(findLastInterruptMessage(messages)).toBeNull();
-        });
-    });
-    describe('parseNodeOutputs', () => {
-        it('should parse all node outputs', () => {
-            const messages = [
-                createMessage({ type: 'workflow.node.call', workflowNodeId: 'n1' }),
-                createMessage({ type: 'workflow.node.result', workflowNodeId: 'n1' }, '{"result":"output1"}'),
-                createMessage({ type: 'workflow.node.call', workflowNodeId: 'n2' }),
-                createMessage({ type: 'workflow.node.result', workflowNodeId: 'n2' }, '{"result":"output2"}'),
-            ];
-            const outputs = parseNodeOutputs(messages);
-            expect(outputs.get('n1')).toEqual({ result: 'output1' });
-            expect(outputs.get('n2')).toEqual({ result: 'output2' });
-        });
-    });
-    describe('getNextPendingNode', () => {
-        it('should return last incomplete node', () => {
-            const messages = [
-                createMessage({ type: 'workflow.node.call', workflowNodeId: 'n1' }),
-                createMessage({ type: 'workflow.node.result', workflowNodeId: 'n1' }, '{"o":"1"}'),
-                createMessage({ type: 'workflow.node.call', workflowNodeId: 'n2' }),
-                // n2 没有 result，所以是 pending
-            ];
-            expect(getNextPendingNode(messages)).toBe('n2');
-        });
-    });
-    describe('getAgentSessionIdFromInterrupt', () => {
-        it('should return agentSessionId from interrupt', () => {
-            const msg = createMessage({
-                type: 'workflow.node.interrupt',
-                workflowNodeId: 'n1',
-                agentSessionId: 'agent_123',
-            });
-            expect(getAgentSessionIdFromInterrupt(msg)).toBe('agent_123');
-        });
-        it('should return undefined if not interrupt', () => {
-            const msg = createMessage({ type: 'workflow.node.call' });
-            expect(getAgentSessionIdFromInterrupt(msg)).toBeUndefined();
-        });
-    });
-    describe('isWaitingForUser', () => {
-        it('should return true if interrupt without resume', () => {
-            const messages = [
-                createMessage({ type: 'workflow.node.call', workflowNodeId: 'n1' }),
-                createMessage({ type: 'workflow.node.interrupt', workflowNodeId: 'n1' }),
-            ];
-            expect(isWaitingForUser(messages)).toBe(true);
-        });
-        it('should return false if resume exists', () => {
-            const messages = [
-                createMessage({ type: 'workflow.node.call', workflowNodeId: 'n1' }),
-                createMessage({ type: 'workflow.node.interrupt', workflowNodeId: 'n1' }),
-                createMessage({ type: 'workflow.node.resume' }),
-            ];
-            expect(isWaitingForUser(messages)).toBe(false);
-        });
-    });
-});
-//# sourceMappingURL=session-parser.test.js.map

package/dist/core/src/env/workflow/utils/session-recovery.d.ts

@@ -1,62 +0,0 @@
-/**
- * Session Recovery Utilities
- *
- * Utilities for inferring the next execution point from session messages.
- * This is the core of the unified run/resume mechanism.
- */
-import type { SessionMessage } from '../../session/types';
-/**
- * Represents a resume point - where to continue execution from
- */
-export interface ResumePoint {
-    /** Type of resume point */
-    type: 'entry_node' | 'resume_node' | 'ask_user' | 'next_nodes';
-    /** Node ID (for single node resume) */
-    nodeId?: string;
-    /** Node IDs (for multiple next nodes) */
-    nodeIds?: string[];
-    /** Agent sub-session ID (for agent node resume) */
-    agentSessionId?: string;
-    /** Input for the node */
-    input?: unknown;
-}
-/**
- * Infer the next node to execute based on session messages
- *
- * Decision logic:
- * - No messages → execute entry node
- * - Last = workflow.node.call → resume this node (incomplete)
- * - Last = workflow.node.interrupt → resume this node (ask_user)
- * - Last = workflow.node.result → execute next nodes from DAG
- * - Unknown → find last call, resume it, or fallback to entry
- */
-export declare function inferNextNode(messages: SessionMessage[], definition: {
-    entryNode?: string;
-    edges?: Array<{
-        from: string;
-        to: string;
-    }>;
-}): ResumePoint;
-/**
- * Find the last interrupt message in the session
- */
-export declare function findLastInterruptMessage(messages: SessionMessage[]): SessionMessage | null;
-/**
- * Find the last call message in the session
- */
-export declare function findLastCallMessage(messages: SessionMessage[]): SessionMessage | null;
-/**
- * Parse node outputs from session messages
- *
- * Extracts outputs by matching workflow.node.call with workflow.node.result pairs
- */
-export declare function parseNodeOutputs(messages: SessionMessage[]): Map<string, unknown>;
-/**
- * Check if session has pending ask_user interrupt
- */
-export declare function hasPendingAskUser(messages: SessionMessage[]): boolean;
-/**
- * Get agent session ID from last interrupt message
- */
-export declare function getAgentSessionIdFromInterrupt(messages: SessionMessage[]): string | null;
-//# sourceMappingURL=session-recovery.d.ts.map