@synergenius/flow-weaver 0.22.9 → 0.22.10

package/dist/agent/index.d.ts

@@ -11,6 +11,8 @@ export type { AnthropicProviderOptions } from './providers/anthropic.js';
 export { ClaudeCliProvider, createClaudeCliProvider } from './providers/claude-cli.js';
 export { OpenAICompatProvider, createOpenAICompatProvider } from './providers/openai-compat.js';
 export type { OpenAICompatProviderOptions } from './providers/openai-compat.js';
+export { PlatformProvider, createPlatformProvider } from './providers/platform.js';
+export type { PlatformProviderOptions } from './providers/platform.js';
 export { createMcpBridge } from './mcp-bridge.js';
 export { CliSession, getOrCreateCliSession, killCliSession, killAllCliSessions, } from './cli-session.js';
 export { buildSafeEnv, buildSafeSpawnOpts, MINIMAL_PATH, ENV_ALLOWLIST } from './env-allowlist.js';

package/dist/agent/index.js

@@ -10,6 +10,7 @@ export { runAgentLoop } from './agent-loop.js';
 export { AnthropicProvider, createAnthropicProvider } from './providers/anthropic.js';
 export { ClaudeCliProvider, createClaudeCliProvider } from './providers/claude-cli.js';
 export { OpenAICompatProvider, createOpenAICompatProvider } from './providers/openai-compat.js';
+export { PlatformProvider, createPlatformProvider } from './providers/platform.js';
 // MCP bridge
 export { createMcpBridge } from './mcp-bridge.js';
 // CLI session (warm persistent sessions)

package/dist/agent/providers/platform.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Platform AI provider — routes AI calls through the Flow Weaver platform.
+ * Uses the platform's AI credits, no local API key needed.
+ * Connects to POST /ai-chat/stream and parses SSE events.
+ */
+import type { AgentProvider, AgentMessage, ToolDefinition, StreamEvent, StreamOptions } from '../types.js';
+export interface PlatformProviderOptions {
+    /** JWT token or API key for platform auth */
+    token: string;
+    /** Platform base URL */
+    platformUrl: string;
+    /** Model override (optional — platform selects default) */
+    model?: string;
+}
+export declare class PlatformProvider implements AgentProvider {
+    private token;
+    private baseUrl;
+    private model;
+    constructor(options: PlatformProviderOptions);
+    stream(messages: AgentMessage[], _tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;
+}
+export declare function createPlatformProvider(options: PlatformProviderOptions): PlatformProvider;
+//# sourceMappingURL=platform.d.ts.map

package/dist/agent/providers/platform.js

@@ -0,0 +1,130 @@
+/**
+ * Platform AI provider — routes AI calls through the Flow Weaver platform.
+ * Uses the platform's AI credits, no local API key needed.
+ * Connects to POST /ai-chat/stream and parses SSE events.
+ */
+export class PlatformProvider {
+    token;
+    baseUrl;
+    model;
+    constructor(options) {
+        if (!options.token)
+            throw new Error('PlatformProvider requires a token');
+        if (!options.platformUrl)
+            throw new Error('PlatformProvider requires a platformUrl');
+        this.token = options.token;
+        this.baseUrl = options.platformUrl.replace(/\/+$/, '');
+        this.model = options.model;
+    }
+    async *stream(messages, _tools, options) {
+        // Format the last user message as the prompt
+        // The platform's agent loop handles tools internally
+        const lastUserMsg = [...messages].reverse().find(m => m.role === 'user');
+        const message = lastUserMsg
+            ? (typeof lastUserMsg.content === 'string' ? lastUserMsg.content : JSON.stringify(lastUserMsg.content))
+            : '';
+        if (!message) {
+            yield { type: 'message_stop', finishReason: 'stop' };
+            return;
+        }
+        const isApiKey = this.token.startsWith('fw_');
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(isApiKey
+                ? { 'X-API-Key': this.token }
+                : { Authorization: `Bearer ${this.token}` }),
+        };
+        const body = { message };
+        if (options?.systemPrompt) {
+            // Platform doesn't accept system prompt directly via API — embed in message
+            body.message = `[System context: ${options.systemPrompt.slice(0, 2000)}]\n\n${message}`;
+        }
+        const response = await fetch(`${this.baseUrl}/ai-chat/stream`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal: options?.signal,
+        });
+        if (!response.ok) {
+            const errText = await response.text().catch(() => '');
+            yield { type: 'text_delta', text: `Platform error ${response.status}: ${errText.slice(0, 300)}` };
+            yield { type: 'message_stop', finishReason: 'error' };
+            return;
+        }
+        if (!response.body) {
+            yield { type: 'message_stop', finishReason: 'error' };
+            return;
+        }
+        // Parse SSE stream from platform
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    let event;
+                    try {
+                        event = JSON.parse(line.slice(6));
+                    }
+                    catch {
+                        continue;
+                    }
+                    // Map platform SSE events to canonical StreamEvent
+                    switch (event.type) {
+                        case 'text_delta':
+                            yield { type: 'text_delta', text: String(event.content ?? '') };
+                            break;
+                        case 'thinking_delta':
+                            yield { type: 'thinking_delta', text: String(event.content ?? '') };
+                            break;
+                        case 'tool_call_start':
+                            yield {
+                                type: 'tool_use_start',
+                                id: String(event.toolCallId ?? ''),
+                                name: String(event.name ?? ''),
+                            };
+                            break;
+                        case 'tool_call_result':
+                            yield {
+                                type: 'tool_result',
+                                id: String(event.toolCallId ?? ''),
+                                result: String(event.result ?? ''),
+                                isError: !!event.isError,
+                            };
+                            break;
+                        case 'usage':
+                            yield {
+                                type: 'usage',
+                                promptTokens: event.promptTokens ?? 0,
+                                completionTokens: event.completionTokens ?? 0,
+                            };
+                            break;
+                        case 'done':
+                            yield { type: 'message_stop', finishReason: 'stop' };
+                            return;
+                        case 'error':
+                            yield { type: 'text_delta', text: `Error: ${event.message ?? 'Unknown error'}` };
+                            yield { type: 'message_stop', finishReason: 'error' };
+                            return;
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        yield { type: 'message_stop', finishReason: 'stop' };
+    }
+}
+export function createPlatformProvider(options) {
+    return new PlatformProvider(options);
+}
+//# sourceMappingURL=platform.js.map

package/dist/cli/commands/auth.d.ts

@@ -0,0 +1,8 @@
+export declare function loginCommand(options: {
+    email?: string;
+    apiKey?: string;
+    platformUrl?: string;
+}): Promise<void>;
+export declare function logoutCommand(): Promise<void>;
+export declare function authStatusCommand(): Promise<void>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/cli/commands/auth.js

@@ -0,0 +1,137 @@
+import * as readline from 'node:readline';
+import { loadCredentials, saveCredentials, clearCredentials, getPlatformUrl } from '../config/credentials.js';
+import { PlatformClient } from '../config/platform-client.js';
+export async function loginCommand(options) {
+    const platformUrl = options.platformUrl ?? getPlatformUrl();
+    console.log('');
+    console.log('  \x1b[1mFlow Weaver Login\x1b[0m');
+    console.log(`  \x1b[2mPlatform: ${platformUrl}\x1b[0m`);
+    console.log('');
+    // Validate platform reachable
+    try {
+        const resp = await fetch(`${platformUrl}/ready`);
+        if (!resp.ok)
+            throw new Error();
+    }
+    catch {
+        console.error('  \x1b[31m✗\x1b[0m Cannot connect to platform');
+        console.error(`    Check: ${platformUrl}`);
+        process.exit(1);
+    }
+    let token;
+    let email;
+    let plan;
+    let userId;
+    if (options.apiKey) {
+        // API key auth
+        token = options.apiKey;
+        const client = new PlatformClient({ token, email: '', plan: 'free', platformUrl, expiresAt: Infinity });
+        try {
+            const user = await client.getUser();
+            email = user.email;
+            plan = user.plan;
+            userId = user.id;
+        }
+        catch {
+            console.error('  \x1b[31m✗\x1b[0m Invalid API key');
+            process.exit(1);
+            return;
+        }
+    }
+    else {
+        // Email/password auth
+        email = options.email ?? await prompt('  Email: ');
+        const password = await prompt('  Password: ', true);
+        try {
+            const resp = await fetch(`${platformUrl}/auth/login`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ email, password }),
+            });
+            if (!resp.ok) {
+                const err = await resp.json().catch(() => ({ error: 'Login failed' }));
+                console.error(`\n  \x1b[31m✗\x1b[0m ${err.error}`);
+                process.exit(1);
+                return;
+            }
+            const data = await resp.json();
+            token = data.token;
+            email = data.user.email;
+            plan = data.user.plan;
+            userId = data.user.id;
+        }
+        catch (err) {
+            console.error(`\n  \x1b[31m✗\x1b[0m ${err instanceof Error ? err.message : 'Login failed'}`);
+            process.exit(1);
+            return;
+        }
+    }
+    const expiresAt = options.apiKey
+        ? Date.now() + 365 * 24 * 60 * 60 * 1000 // 1 year for API keys
+        : Date.now() + 7 * 24 * 60 * 60 * 1000; // 7 days for JWT
+    saveCredentials({ token, email, plan: plan, platformUrl, expiresAt, userId });
+    console.log('');
+    console.log(`  \x1b[32m✓\x1b[0m Logged in as \x1b[1m${email}\x1b[0m (${plan} plan)`);
+    console.log('');
+    console.log('  What\'s unlocked:');
+    console.log('    \x1b[36mfw deploy src/workflow.ts\x1b[0m   \x1b[2m# deploy to cloud\x1b[0m');
+    console.log('    \x1b[36mfw status\x1b[0m                   \x1b[2m# see deployments + usage\x1b[0m');
+    console.log('    \x1b[36mweaver assistant\x1b[0m             \x1b[2m# AI with platform credits\x1b[0m');
+    console.log('');
+}
+export async function logoutCommand() {
+    clearCredentials();
+    console.log('  \x1b[32m✓\x1b[0m Logged out');
+}
+export async function authStatusCommand() {
+    const creds = loadCredentials();
+    if (!creds) {
+        console.log('');
+        console.log('  Not logged in.');
+        console.log('  Run: \x1b[36mfw login\x1b[0m');
+        console.log('');
+        return;
+    }
+    const expiresIn = Math.floor((creds.expiresAt - Date.now()) / 1000 / 60 / 60);
+    console.log('');
+    console.log(`  \x1b[32m✓\x1b[0m Logged in as \x1b[1m${creds.email}\x1b[0m`);
+    console.log(`  Plan: ${creds.plan}`);
+    console.log(`  Platform: ${creds.platformUrl}`);
+    console.log(`  Token expires in: ${expiresIn}h`);
+    console.log('');
+}
+function prompt(message, hidden = false) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+        if (hidden && process.stdin.isTTY) {
+            // Hide password input
+            process.stderr.write(message);
+            process.stdin.setRawMode(true);
+            let input = '';
+            const handler = (key) => {
+                const ch = key.toString();
+                if (ch === '\r' || ch === '\n') {
+                    process.stdin.setRawMode(false);
+                    process.stdin.removeListener('data', handler);
+                    process.stderr.write('\n');
+                    rl.close();
+                    resolve(input);
+                }
+                else if (ch === '\x03') { // Ctrl+C
+                    process.exit(1);
+                }
+                else if (ch === '\x7f') { // Backspace
+                    input = input.slice(0, -1);
+                }
+                else {
+                    input += ch;
+                }
+            };
+            process.stdin.on('data', handler);
+        }
+        else {
+            rl.question(message, (answer) => { rl.close(); resolve(answer); });
+        }
+    });
+}
+//# sourceMappingURL=auth.js.map

package/dist/cli/commands/deploy.d.ts

@@ -0,0 +1,6 @@
+export declare function deployCommand(filePath: string, options?: {
+    name?: string;
+}): Promise<void>;
+export declare function undeployCommand(slug: string): Promise<void>;
+export declare function cloudStatusCommand(): Promise<void>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/cli/commands/deploy.js

@@ -0,0 +1,97 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { loadCredentials } from '../config/credentials.js';
+import { PlatformClient } from '../config/platform-client.js';
+export async function deployCommand(filePath, options = {}) {
+    const creds = loadCredentials();
+    if (!creds) {
+        console.error('  \x1b[31m✗\x1b[0m Not logged in. Run: fw login');
+        process.exit(1);
+        return;
+    }
+    const absPath = path.resolve(filePath);
+    if (!fs.existsSync(absPath)) {
+        console.error(`  \x1b[31m✗\x1b[0m File not found: ${filePath}`);
+        process.exit(1);
+        return;
+    }
+    const source = fs.readFileSync(absPath, 'utf-8');
+    const name = options.name ?? path.basename(filePath, path.extname(filePath));
+    const client = new PlatformClient(creds);
+    console.log('');
+    console.log(`  \x1b[2mPushing ${name}...\x1b[0m`);
+    try {
+        const workflow = await client.pushWorkflow(name, source);
+        console.log(`  \x1b[32m✓\x1b[0m Pushed (v${workflow.version})`);
+        console.log(`  \x1b[2mDeploying...\x1b[0m`);
+        const deployment = await client.deploy(workflow.slug);
+        console.log(`  \x1b[32m✓\x1b[0m Deployed: ${deployment.slug}`);
+        console.log('');
+        console.log(`  Endpoint: ${creds.platformUrl}/run/${deployment.slug}`);
+        console.log('');
+        console.log('  Test it:');
+        console.log(`    curl -X POST ${creds.platformUrl}/run/${deployment.slug} \\`);
+        console.log(`      -H "X-API-Key: <your-api-key>" \\`);
+        console.log(`      -H "Content-Type: application/json" \\`);
+        console.log(`      -d '{"input": "hello"}'`);
+        console.log('');
+    }
+    catch (err) {
+        console.error(`  \x1b[31m✗\x1b[0m ${err instanceof Error ? err.message : 'Deploy failed'}`);
+        process.exit(1);
+    }
+}
+export async function undeployCommand(slug) {
+    const creds = loadCredentials();
+    if (!creds) {
+        console.error('  \x1b[31m✗\x1b[0m Not logged in.');
+        process.exit(1);
+        return;
+    }
+    const client = new PlatformClient(creds);
+    try {
+        await client.undeploy(slug);
+        console.log(`  \x1b[32m✓\x1b[0m Undeployed: ${slug}`);
+    }
+    catch (err) {
+        console.error(`  \x1b[31m✗\x1b[0m ${err instanceof Error ? err.message : 'Undeploy failed'}`);
+    }
+}
+export async function cloudStatusCommand() {
+    const creds = loadCredentials();
+    if (!creds) {
+        console.log('');
+        console.log('  Not logged in. Run: \x1b[36mfw login\x1b[0m');
+        console.log('');
+        return;
+    }
+    const client = new PlatformClient(creds);
+    console.log('');
+    console.log(`  \x1b[1m${creds.email}\x1b[0m \x1b[2m(${creds.plan} plan)\x1b[0m`);
+    console.log('');
+    try {
+        const deployments = await client.listDeployments();
+        if (deployments.length === 0) {
+            console.log('  No deployments.');
+        }
+        else {
+            console.log('  Deployments:');
+            for (const d of deployments) {
+                const icon = d.status === 'active' ? '\x1b[32m●\x1b[0m' : '\x1b[33m○\x1b[0m';
+                console.log(`    ${icon} ${d.slug.padEnd(25)} ${d.status}`);
+            }
+        }
+    }
+    catch {
+        console.log('  \x1b[33m⚠\x1b[0m Could not fetch deployments');
+    }
+    try {
+        const usage = await client.getUsage();
+        console.log('');
+        console.log(`  AI Credits: ${usage.aiCalls} calls this month`);
+        console.log(`  Executions: ${usage.executions} this month`);
+    }
+    catch { /* usage not available */ }
+    console.log('');
+}
+//# sourceMappingURL=deploy.js.map

package/dist/cli/commands/init.d.ts

@@ -32,6 +32,7 @@ export interface InitConfig {
     /** Free-text description when user picked "Something else" */
     useCaseDescription?: string;
     mcp: boolean;
+    installWeaver: boolean;
 }
 export interface InitReport {
     projectDir: string;
@@ -55,7 +56,7 @@ export declare function validateProjectName(name: string): string | true;
 export declare function toWorkflowName(projectName: string): string;
 export declare function isNonInteractive(): boolean;
 export declare function resolveInitConfig(dirArg: string | undefined, options: InitOptions): Promise<InitConfig>;
-export declare function generateProjectFiles(projectName: string, template: string, format?: TModuleFormat, persona?: PersonaId): Record<string, string>;
+export declare function generateProjectFiles(projectName: string, template: string, format?: TModuleFormat, persona?: PersonaId, installWeaver?: boolean): Record<string, string>;
 export declare function scaffoldProject(targetDir: string, files: Record<string, string>, options: {
     force: boolean;
 }): {

package/dist/cli/commands/init.js

@@ -183,6 +183,17 @@ export async function resolveInitConfig(dirArg, options) {
         if (!useCaseDescription)
             useCaseDescription = undefined;
     }
+    // 3c. Weaver AI assistant opt-in
+    let installWeaver;
+    if (skipPrompts) {
+        installWeaver = false;
+    }
+    else {
+        installWeaver = await confirm({
+            message: 'Install Weaver AI assistant? (Recommended)\n  Weaver helps you create, modify, and manage workflows with AI.',
+            default: true,
+        });
+    }
     // 4. MCP setup (nocode, vibecoder, lowcode: prompt; expert: skip unless --mcp)
     let mcp;
     if (options.mcp !== undefined) {
@@ -255,10 +266,11 @@ export async function resolveInitConfig(dirArg, options) {
         useCase,
         useCaseDescription,
         mcp,
+        installWeaver,
     };
 }
 // ── Pure file generation ─────────────────────────────────────────────────────
-export function generateProjectFiles(projectName, template, format = 'esm', persona = 'expert') {
+export function generateProjectFiles(projectName, template, format = 'esm', persona = 'expert', installWeaver = false) {
     const workflowName = toWorkflowName(projectName);
     const workflowFile = `${projectName}-workflow.ts`;
     const tmpl = getWorkflowTemplate(template);
@@ -284,6 +296,7 @@ export function generateProjectFiles(projectName, template, format = 'esm', pers
         scripts,
         dependencies: {
             '@synergenius/flow-weaver': 'latest',
+            ...(installWeaver ? { '@synergenius/flow-weaver-pack-weaver': 'latest' } : {}),
         },
         devDependencies: {
             typescript: '^5.3.0',
@@ -382,6 +395,10 @@ export function generateProjectFiles(projectName, template, format = 'esm', pers
     if (persona === 'lowcode') {
         files['examples/example-workflow.ts'] = generateExampleWorkflow(projectName);
     }
+    // Add Weaver config if opted in
+    if (installWeaver) {
+        files['.weaver.json'] = JSON.stringify({ provider: 'auto', approval: 'auto' }, null, 2) + '\n';
+    }
     return files;
 }
 // ── Filesystem writer ────────────────────────────────────────────────────────
@@ -502,7 +519,7 @@ export async function initCommand(dirArg, options) {
             throw new Error(`${config.targetDir} already contains a package.json. Use --force to overwrite.`);
         }
         // Generate and scaffold
-        const files = generateProjectFiles(config.projectName, config.template, config.format, config.persona);
+        const files = generateProjectFiles(config.projectName, config.template, config.format, config.persona, config.installWeaver);
         const { filesCreated, filesSkipped } = scaffoldProject(config.targetDir, files, {
             force: config.force,
         });
@@ -622,6 +639,15 @@ export async function initCommand(dirArg, options) {
                 logger.warn(`Compile failed: ${compileResult.error}`);
             }
         }
+        if (config.installWeaver) {
+            logger.success('Weaver AI assistant installed');
+            logger.newline();
+            logger.log('  Weaver installed. Try:');
+            logger.log('    flow-weaver weaver assistant      # AI assistant');
+            logger.log('    flow-weaver weaver bot "..."      # create workflows with AI');
+            logger.log('    flow-weaver weaver examples       # see what\'s possible');
+            logger.newline();
+        }
         // Read the workflow code for preview
         const workflowCode = files[`src/${workflowFile}`] ?? null;
         // Persona-specific rich output

package/dist/cli/config/credentials.d.ts

@@ -0,0 +1,15 @@
+export interface StoredCredentials {
+    token: string;
+    email: string;
+    plan: 'free' | 'pro' | 'business';
+    platformUrl: string;
+    expiresAt: number;
+    userId?: string;
+}
+export declare function loadCredentials(): StoredCredentials | null;
+export declare function saveCredentials(creds: StoredCredentials): void;
+export declare function clearCredentials(): void;
+export declare function isTokenExpired(creds: StoredCredentials): boolean;
+export declare function getPlatformUrl(): string;
+export declare function isLoggedIn(): boolean;
+//# sourceMappingURL=credentials.d.ts.map

package/dist/cli/config/credentials.js

@@ -0,0 +1,43 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+const FW_CONFIG_DIR = path.join(os.homedir(), '.fw');
+const CREDENTIALS_FILE = path.join(FW_CONFIG_DIR, 'credentials.json');
+export function loadCredentials() {
+    if (!fs.existsSync(CREDENTIALS_FILE))
+        return null;
+    try {
+        const data = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, 'utf-8'));
+        if (isTokenExpired(data))
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveCredentials(creds) {
+    fs.mkdirSync(FW_CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), 'utf-8');
+    try {
+        fs.chmodSync(CREDENTIALS_FILE, 0o600);
+    }
+    catch { /* Windows */ }
+}
+export function clearCredentials() {
+    try {
+        fs.unlinkSync(CREDENTIALS_FILE);
+    }
+    catch { /* not found */ }
+}
+export function isTokenExpired(creds) {
+    return Date.now() > creds.expiresAt;
+}
+export function getPlatformUrl() {
+    const creds = loadCredentials();
+    return creds?.platformUrl ?? process.env.FW_PLATFORM_URL ?? 'https://app.synergenius.pt';
+}
+export function isLoggedIn() {
+    return loadCredentials() !== null;
+}
+//# sourceMappingURL=credentials.js.map

package/dist/cli/config/platform-client.d.ts

@@ -0,0 +1,36 @@
+import type { StoredCredentials } from './credentials.js';
+export declare class PlatformClient {
+    private baseUrl;
+    private token;
+    constructor(creds: StoredCredentials);
+    private fetch;
+    getUser(): Promise<{
+        id: string;
+        email: string;
+        name: string;
+        plan: string;
+    }>;
+    pushWorkflow(name: string, source: string): Promise<{
+        slug: string;
+        version: number;
+    }>;
+    deploy(slug: string): Promise<{
+        slug: string;
+        status: string;
+    }>;
+    undeploy(slug: string): Promise<void>;
+    listDeployments(): Promise<Array<{
+        slug: string;
+        status: string;
+        workflowName?: string;
+    }>>;
+    getUsage(): Promise<{
+        executions: number;
+        aiCalls: number;
+        plan: string;
+    }>;
+    streamChat(message: string, conversationId?: string): AsyncGenerator<Record<string, unknown>>;
+    validate(): Promise<boolean>;
+}
+export declare function createPlatformClient(creds: StoredCredentials): PlatformClient;
+//# sourceMappingURL=platform-client.d.ts.map