aoaoe 1.0.0 → 2.0.0

package/dist/multi-reasoner.js

@@ -0,0 +1,87 @@
+// multi-reasoner.ts — assign different LLM backends per session.
+// routes observations to the appropriate reasoner based on session config,
+// template, or difficulty. supports reasoner pools with load balancing.
+const DEFAULT_CONFIG = {
+    defaultBackend: "opencode",
+    sessionOverrides: {},
+    templateMappings: {},
+    difficultyThreshold: 7,
+    premiumBackend: "opencode",
+    economyBackend: "claude-code",
+};
+/**
+ * Determine which reasoner backend to use for each session.
+ */
+export function assignReasonerBackends(sessions, config = {}) {
+    const c = { ...DEFAULT_CONFIG, ...config };
+    return sessions.map((s) => {
+        // explicit override wins
+        if (c.sessionOverrides[s.title]) {
+            return { sessionTitle: s.title, backend: c.sessionOverrides[s.title], reason: "explicit override" };
+        }
+        // template mapping
+        if (s.template && c.templateMappings[s.template]) {
+            return { sessionTitle: s.title, backend: c.templateMappings[s.template], reason: `template: ${s.template}` };
+        }
+        // difficulty-based routing
+        if (s.difficultyScore !== undefined) {
+            if (s.difficultyScore >= c.difficultyThreshold) {
+                return { sessionTitle: s.title, backend: c.premiumBackend, reason: `high difficulty (${s.difficultyScore}/10)` };
+            }
+            return { sessionTitle: s.title, backend: c.economyBackend, reason: `low difficulty (${s.difficultyScore}/10)` };
+        }
+        return { sessionTitle: s.title, backend: c.defaultBackend, reason: "default" };
+    });
+}
+/**
+ * Split an observation into per-backend groups for routing.
+ */
+export function routeObservation(observation, assignments) {
+    const assignMap = new Map(assignments.map((a) => [a.sessionTitle, a.backend]));
+    const groups = new Map();
+    for (const snap of observation.sessions) {
+        const backend = assignMap.get(snap.session.title) ?? "opencode";
+        if (!groups.has(backend))
+            groups.set(backend, { sessions: [], changes: [] });
+        groups.get(backend).sessions.push(snap);
+    }
+    for (const change of observation.changes) {
+        const backend = assignMap.get(change.title) ?? "opencode";
+        if (groups.has(backend))
+            groups.get(backend).changes.push(change);
+    }
+    const result = new Map();
+    for (const [backend, data] of groups) {
+        result.set(backend, { timestamp: observation.timestamp, sessions: data.sessions, changes: data.changes });
+    }
+    return result;
+}
+/**
+ * Merge results from multiple reasoner backends into a single result.
+ */
+export function mergeReasonerResults(results) {
+    const allActions = results.flatMap((r) => r.actions);
+    // use lowest confidence across all results
+    const confidences = results.map((r) => r.confidence).filter(Boolean);
+    const confidence = confidences.length > 0
+        ? (confidences.includes("low") ? "low" : confidences.includes("medium") ? "medium" : "high")
+        : undefined;
+    return { actions: allActions, confidence: confidence };
+}
+/**
+ * Format assignments for TUI display.
+ */
+export function formatAssignments(assignments) {
+    if (assignments.length === 0)
+        return ["  (no sessions to assign)"];
+    const lines = [];
+    const backendCounts = new Map();
+    for (const a of assignments) {
+        backendCounts.set(a.backend, (backendCounts.get(a.backend) ?? 0) + 1);
+        lines.push(`  ${a.sessionTitle}: ${a.backend} (${a.reason})`);
+    }
+    const summary = [...backendCounts.entries()].map(([b, c]) => `${b}: ${c}`).join(", ");
+    lines.unshift(`  Multi-reasoner assignments (${summary}):`);
+    return lines;
+}
+//# sourceMappingURL=multi-reasoner.js.map

package/dist/output-archival.d.ts

@@ -0,0 +1,23 @@
+export interface ArchiveResult {
+    sessionTitle: string;
+    filepath: string;
+    originalLines: number;
+    compressedBytes: number;
+    archivedAt: number;
+}
+/**
+ * Archive session output to a gzipped file on disk.
+ */
+export declare function archiveSessionOutput(sessionTitle: string, output: string[], now?: number): ArchiveResult;
+/**
+ * List available archives.
+ */
+export declare function listArchives(): Array<{
+    filename: string;
+    sessionTitle: string;
+}>;
+/**
+ * Format archive list for TUI display.
+ */
+export declare function formatArchiveList(): string[];
+//# sourceMappingURL=output-archival.d.ts.map

package/dist/output-archival.js

@@ -0,0 +1,72 @@
+// output-archival.ts — compress and archive old session outputs to disk.
+// keeps the daemon's memory footprint manageable over long runs by
+// offloading old output to gzipped files.
+import { writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { gzipSync } from "node:zlib";
+const ARCHIVE_DIR = join(homedir(), ".aoaoe", "output-archive");
+const MAX_ARCHIVES = 200;
+/**
+ * Archive session output to a gzipped file on disk.
+ */
+export function archiveSessionOutput(sessionTitle, output, now = Date.now()) {
+    mkdirSync(ARCHIVE_DIR, { recursive: true });
+    const safe = sessionTitle.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const timestamp = new Date(now).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const filename = `${safe}_${timestamp}.txt.gz`;
+    const filepath = join(ARCHIVE_DIR, filename);
+    const content = output.join("\n");
+    const compressed = gzipSync(Buffer.from(content, "utf-8"));
+    writeFileSync(filepath, compressed);
+    pruneOldArchives();
+    return {
+        sessionTitle,
+        filepath,
+        originalLines: output.length,
+        compressedBytes: compressed.length,
+        archivedAt: now,
+    };
+}
+/**
+ * List available archives.
+ */
+export function listArchives() {
+    if (!existsSync(ARCHIVE_DIR))
+        return [];
+    return readdirSync(ARCHIVE_DIR)
+        .filter((f) => f.endsWith(".txt.gz"))
+        .sort()
+        .reverse()
+        .map((f) => ({
+        filename: f,
+        sessionTitle: f.split("_").slice(0, -2).join("_") || f,
+    }));
+}
+/**
+ * Format archive list for TUI display.
+ */
+export function formatArchiveList() {
+    const archives = listArchives();
+    if (archives.length === 0)
+        return ["  (no archived outputs)"];
+    const lines = [];
+    lines.push(`  Output archives: ${archives.length} files`);
+    for (const a of archives.slice(0, 10)) {
+        lines.push(`    ${a.filename}`);
+    }
+    if (archives.length > 10)
+        lines.push(`    ... and ${archives.length - 10} more`);
+    return lines;
+}
+function pruneOldArchives() {
+    try {
+        const files = readdirSync(ARCHIVE_DIR).filter((f) => f.endsWith(".txt.gz")).sort();
+        while (files.length > MAX_ARCHIVES) {
+            const oldest = files.shift();
+            unlinkSync(join(ARCHIVE_DIR, oldest));
+        }
+    }
+    catch { /* best-effort */ }
+}
+//# sourceMappingURL=output-archival.js.map

package/dist/runbook-generator.d.ts

@@ -0,0 +1,21 @@
+export interface RunbookStep {
+    action: string;
+    detail: string;
+    frequency: number;
+}
+export interface GeneratedRunbook {
+    title: string;
+    scenario: string;
+    steps: RunbookStep[];
+    basedOnEvents: number;
+    confidence: "low" | "medium" | "high";
+}
+/**
+ * Analyze audit trail and generate runbooks for common patterns.
+ */
+export declare function generateRunbooks(): GeneratedRunbook[];
+/**
+ * Format generated runbooks for TUI display.
+ */
+export declare function formatGeneratedRunbooks(runbooks: GeneratedRunbook[]): string[];
+//# sourceMappingURL=runbook-generator.d.ts.map

package/dist/runbook-generator.js

@@ -0,0 +1,104 @@
+// runbook-generator.ts — auto-generate operator runbooks from audit trail patterns.
+// analyzes recurring event sequences and produces step-by-step playbooks
+// for common scenarios (stuck sessions, budget overruns, error recovery).
+import { readRecentAuditEntries } from "./audit-trail.js";
+/**
+ * Analyze audit trail and generate runbooks for common patterns.
+ */
+export function generateRunbooks() {
+    const entries = readRecentAuditEntries(5_000);
+    if (entries.length < 10)
+        return [];
+    const runbooks = [];
+    // pattern 1: stuck session recovery
+    const stuckEntries = entries.filter((e) => e.type === "stuck_nudge" || e.type === "session_restart");
+    if (stuckEntries.length >= 3) {
+        const actions = countActions(stuckEntries);
+        runbooks.push({
+            title: "Stuck Session Recovery",
+            scenario: "Session has not made progress for >30 minutes",
+            steps: actions,
+            basedOnEvents: stuckEntries.length,
+            confidence: stuckEntries.length >= 10 ? "high" : stuckEntries.length >= 5 ? "medium" : "low",
+        });
+    }
+    // pattern 2: budget management
+    const budgetEntries = entries.filter((e) => e.type === "budget_pause");
+    if (budgetEntries.length >= 2) {
+        runbooks.push({
+            title: "Budget Overrun Response",
+            scenario: "Session cost exceeds configured budget",
+            steps: [
+                { action: "Review cost attribution", detail: "Use /cost-report to identify top spenders", frequency: budgetEntries.length },
+                { action: "Adjust budget or pause", detail: "Use /budget-predict to estimate remaining runway", frequency: budgetEntries.length },
+                { action: "Check for runaway loops", detail: "Use /drift to verify session is on-task", frequency: Math.ceil(budgetEntries.length * 0.5) },
+            ],
+            basedOnEvents: budgetEntries.length,
+            confidence: budgetEntries.length >= 5 ? "high" : "medium",
+        });
+    }
+    // pattern 3: error recovery
+    const errorEntries = entries.filter((e) => e.type === "session_error");
+    if (errorEntries.length >= 3) {
+        runbooks.push({
+            title: "Session Error Recovery",
+            scenario: "Session enters error state",
+            steps: [
+                { action: "Check session output", detail: "Use /session-replay to review recent activity", frequency: errorEntries.length },
+                { action: "Review recovery playbook", detail: "Use /recovery to see auto-recovery status", frequency: errorEntries.length },
+                { action: "Restart if needed", detail: "Recovery playbook auto-restarts at health <40", frequency: Math.ceil(errorEntries.length * 0.3) },
+            ],
+            basedOnEvents: errorEntries.length,
+            confidence: errorEntries.length >= 10 ? "high" : "medium",
+        });
+    }
+    // pattern 4: goal completion
+    const completionEntries = entries.filter((e) => e.type === "auto_complete" || e.type === "task_completed");
+    if (completionEntries.length >= 3) {
+        runbooks.push({
+            title: "Task Completion Workflow",
+            scenario: "Task auto-detected as complete",
+            steps: [
+                { action: "Verify completion", detail: "Check /goal-progress and /velocity for confirmation", frequency: completionEntries.length },
+                { action: "Review output", detail: "Use /session-replay to verify work quality", frequency: completionEntries.length },
+                { action: "Advance dependencies", detail: "Use /schedule to activate dependent tasks", frequency: Math.ceil(completionEntries.length * 0.5) },
+            ],
+            basedOnEvents: completionEntries.length,
+            confidence: completionEntries.length >= 10 ? "high" : "medium",
+        });
+    }
+    return runbooks;
+}
+/**
+ * Format generated runbooks for TUI display.
+ */
+export function formatGeneratedRunbooks(runbooks) {
+    if (runbooks.length === 0)
+        return ["  (insufficient audit data to generate runbooks — need 10+ events)"];
+    const lines = [];
+    for (const rb of runbooks) {
+        const conf = rb.confidence === "high" ? "●" : rb.confidence === "medium" ? "◐" : "○";
+        lines.push(`  ${conf} ${rb.title} (based on ${rb.basedOnEvents} events)`);
+        lines.push(`    Scenario: ${rb.scenario}`);
+        for (let i = 0; i < rb.steps.length; i++) {
+            lines.push(`    ${i + 1}. ${rb.steps[i].action} — ${rb.steps[i].detail}`);
+        }
+        lines.push("");
+    }
+    return lines;
+}
+function countActions(entries) {
+    const counts = new Map();
+    for (const e of entries) {
+        const key = e.type;
+        const existing = counts.get(key);
+        if (existing)
+            existing.count++;
+        else
+            counts.set(key, { detail: e.detail.slice(0, 80), count: 1 });
+    }
+    return [...counts.entries()].map(([action, { detail, count }]) => ({
+        action, detail, frequency: count,
+    })).sort((a, b) => b.frequency - a.frequency);
+}
+//# sourceMappingURL=runbook-generator.js.map

package/dist/service-generator.d.ts

@@ -0,0 +1,32 @@
+export interface ServiceConfig {
+    name: string;
+    description: string;
+    execPath: string;
+    workingDir: string;
+    configPath?: string;
+    user?: string;
+    restartSec: number;
+    logPath?: string;
+}
+/**
+ * Generate a systemd unit file for Linux.
+ */
+export declare function generateSystemdUnit(config?: Partial<ServiceConfig>): string;
+/**
+ * Generate a launchd plist file for macOS.
+ */
+export declare function generateLaunchdPlist(config?: Partial<ServiceConfig>): string;
+/**
+ * Detect the current platform and generate the appropriate service file.
+ */
+export declare function generateServiceFile(config?: Partial<ServiceConfig>): {
+    content: string;
+    filename: string;
+    installPath: string;
+    platform: string;
+};
+/**
+ * Write the service file and return install instructions.
+ */
+export declare function installService(config?: Partial<ServiceConfig>): string[];
+//# sourceMappingURL=service-generator.d.ts.map

package/dist/service-generator.js

@@ -0,0 +1,132 @@
+// service-generator.ts — generate systemd/launchd service files for daemon
+// auto-start on boot and crash restart. supports both Linux (systemd) and
+// macOS (launchd) platforms.
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+const DEFAULT_CONFIG = {
+    name: "aoaoe",
+    description: "aoaoe — autonomous supervisor daemon for agent-of-empires",
+    execPath: "aoaoe",
+    workingDir: process.cwd(),
+    restartSec: 5,
+};
+/**
+ * Generate a systemd unit file for Linux.
+ */
+export function generateSystemdUnit(config = {}) {
+    const c = { ...DEFAULT_CONFIG, ...config };
+    const execStart = c.configPath
+        ? `${c.execPath} --config ${c.configPath}`
+        : c.execPath;
+    return `[Unit]
+Description=${c.description}
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+WorkingDirectory=${c.workingDir}
+Restart=on-failure
+RestartSec=${c.restartSec}
+${c.user ? `User=${c.user}` : ""}
+${c.logPath ? `StandardOutput=append:${c.logPath}\nStandardError=append:${c.logPath}` : "StandardOutput=journal\nStandardError=journal"}
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=multi-user.target
+`.replace(/\n{3,}/g, "\n\n").trim() + "\n";
+}
+/**
+ * Generate a launchd plist file for macOS.
+ */
+export function generateLaunchdPlist(config = {}) {
+    const c = { ...DEFAULT_CONFIG, ...config };
+    const logPath = c.logPath ?? join(homedir(), "Library", "Logs", "aoaoe.log");
+    const errPath = c.logPath ? c.logPath.replace(".log", ".err.log") : join(homedir(), "Library", "Logs", "aoaoe.err.log");
+    const args = c.configPath
+        ? [`${c.execPath}`, "--config", c.configPath]
+        : [c.execPath];
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.aoaoe.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+${args.map((a) => `    <string>${escXml(a)}</string>`).join("\n")}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${escXml(c.workingDir)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>${c.restartSec}</integer>
+  <key>StandardOutPath</key>
+  <string>${escXml(logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escXml(errPath)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>NODE_ENV</key>
+    <string>production</string>
+  </dict>
+</dict>
+</plist>
+`;
+}
+/**
+ * Detect the current platform and generate the appropriate service file.
+ */
+export function generateServiceFile(config = {}) {
+    const os = platform();
+    if (os === "darwin") {
+        const filename = "com.aoaoe.daemon.plist";
+        const installPath = join(homedir(), "Library", "LaunchAgents", filename);
+        return { content: generateLaunchdPlist(config), filename, installPath, platform: "launchd" };
+    }
+    // Linux + fallback
+    const filename = `${config.name ?? "aoaoe"}.service`;
+    const installPath = join("/etc", "systemd", "system", filename);
+    return { content: generateSystemdUnit(config), filename, installPath, platform: "systemd" };
+}
+/**
+ * Write the service file and return install instructions.
+ */
+export function installService(config = {}) {
+    const { content, filename, installPath, platform: plat } = generateServiceFile(config);
+    const outDir = join(homedir(), ".aoaoe");
+    mkdirSync(outDir, { recursive: true });
+    const outPath = join(outDir, filename);
+    writeFileSync(outPath, content);
+    const lines = [];
+    lines.push(`Generated ${plat} service file: ${outPath}`);
+    lines.push("");
+    if (plat === "systemd") {
+        lines.push("Install with:");
+        lines.push(`  sudo cp ${outPath} ${installPath}`);
+        lines.push("  sudo systemctl daemon-reload");
+        lines.push(`  sudo systemctl enable ${filename}`);
+        lines.push(`  sudo systemctl start ${filename.replace(".service", "")}`);
+    }
+    else {
+        lines.push("Install with:");
+        lines.push(`  cp ${outPath} ${installPath}`);
+        lines.push(`  launchctl load ${installPath}`);
+        lines.push("");
+        lines.push("Uninstall with:");
+        lines.push(`  launchctl unload ${installPath}`);
+        lines.push(`  rm ${installPath}`);
+    }
+    return lines;
+}
+function escXml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+//# sourceMappingURL=service-generator.js.map

package/dist/session-checkpoint.d.ts

@@ -0,0 +1,55 @@
+export interface DaemonCheckpoint {
+    version: number;
+    savedAt: number;
+    graduation: Record<string, {
+        mode: string;
+        successes: number;
+        failures: number;
+        rate: number;
+    }>;
+    escalation: Record<string, {
+        level: string;
+        notifyCount: number;
+    }>;
+    velocitySamples: Record<string, Array<{
+        timestamp: number;
+        percent: number;
+    }>>;
+    nudgeRecords: Array<{
+        session: string;
+        sentAt: number;
+        effective: boolean;
+    }>;
+    budgetSamples: Record<string, Array<{
+        timestamp: number;
+        costUsd: number;
+    }>>;
+    cacheStats: {
+        hits: number;
+        misses: number;
+    };
+    slaHistory: number[];
+    pollInterval: number;
+}
+/**
+ * Save daemon state to a checkpoint file.
+ */
+export declare function saveCheckpoint(checkpoint: DaemonCheckpoint): string;
+/**
+ * Load the most recent checkpoint. Returns null if none exists.
+ */
+export declare function loadCheckpoint(): DaemonCheckpoint | null;
+/**
+ * Build a checkpoint from current module states.
+ * This is a generic serialization — callers extract state from each module.
+ */
+export declare function buildCheckpoint(state: Omit<DaemonCheckpoint, "version" | "savedAt">): DaemonCheckpoint;
+/**
+ * Format checkpoint info for TUI display.
+ */
+export declare function formatCheckpointInfo(): string[];
+/**
+ * Check if a checkpoint exists and is recent enough to restore.
+ */
+export declare function shouldRestoreCheckpoint(maxAgeMs?: number): boolean;
+//# sourceMappingURL=session-checkpoint.d.ts.map

package/dist/session-checkpoint.js

@@ -0,0 +1,69 @@
+// session-checkpoint.ts — save + resume session state across daemon restarts.
+// serializes all transient module state (graduation, escalation, velocity,
+// nudge tracker, etc.) to disk so the daemon can pick up where it left off.
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const CHECKPOINT_DIR = join(homedir(), ".aoaoe", "checkpoints");
+const CHECKPOINT_FILE = join(CHECKPOINT_DIR, "daemon-state.json");
+/**
+ * Save daemon state to a checkpoint file.
+ */
+export function saveCheckpoint(checkpoint) {
+    mkdirSync(CHECKPOINT_DIR, { recursive: true });
+    checkpoint.savedAt = Date.now();
+    checkpoint.version = 1;
+    writeFileSync(CHECKPOINT_FILE, JSON.stringify(checkpoint, null, 2) + "\n");
+    return CHECKPOINT_FILE;
+}
+/**
+ * Load the most recent checkpoint. Returns null if none exists.
+ */
+export function loadCheckpoint() {
+    if (!existsSync(CHECKPOINT_FILE))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(CHECKPOINT_FILE, "utf-8"));
+        if (data.version !== 1)
+            return null; // incompatible version
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build a checkpoint from current module states.
+ * This is a generic serialization — callers extract state from each module.
+ */
+export function buildCheckpoint(state) {
+    return { version: 1, savedAt: Date.now(), ...state };
+}
+/**
+ * Format checkpoint info for TUI display.
+ */
+export function formatCheckpointInfo() {
+    const cp = loadCheckpoint();
+    if (!cp)
+        return ["  (no checkpoint found)"];
+    const age = Math.round((Date.now() - cp.savedAt) / 60_000);
+    const lines = [];
+    lines.push(`  Checkpoint: saved ${age}min ago`);
+    lines.push(`  Graduation: ${Object.keys(cp.graduation).length} sessions`);
+    lines.push(`  Escalation: ${Object.keys(cp.escalation).length} active`);
+    lines.push(`  Velocity: ${Object.keys(cp.velocitySamples).length} tracked`);
+    lines.push(`  Nudges: ${cp.nudgeRecords.length} records`);
+    lines.push(`  Cache: ${cp.cacheStats.hits} hits / ${cp.cacheStats.misses} misses`);
+    lines.push(`  SLA history: ${cp.slaHistory.length} ticks`);
+    return lines;
+}
+/**
+ * Check if a checkpoint exists and is recent enough to restore.
+ */
+export function shouldRestoreCheckpoint(maxAgeMs = 30 * 60_000) {
+    const cp = loadCheckpoint();
+    if (!cp)
+        return false;
+    return (Date.now() - cp.savedAt) <= maxAgeMs;
+}
+//# sourceMappingURL=session-checkpoint.js.map

package/dist/session-replay.d.ts

@@ -0,0 +1,25 @@
+export interface ReplayEvent {
+    timestamp: number;
+    timeLabel: string;
+    type: string;
+    detail: string;
+}
+export interface SessionReplay {
+    sessionTitle: string;
+    events: ReplayEvent[];
+    totalDurationMs: number;
+    eventCount: number;
+}
+/**
+ * Build a replay timeline for a session from the audit trail.
+ */
+export declare function buildSessionReplay(sessionTitle: string, maxEvents?: number): SessionReplay;
+/**
+ * Format replay as a chronological narrative.
+ */
+export declare function formatReplay(replay: SessionReplay): string[];
+/**
+ * Generate a summary of the replay (for quick review).
+ */
+export declare function summarizeReplay(replay: SessionReplay): string[];
+//# sourceMappingURL=session-replay.d.ts.map