@remnic/core 1.1.31 → 9.3.515

package/dist/chunk-ZPKBYX2F.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/dashboard-runtime.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { createServer, type IncomingMessage, type ServerResponse } from \"node:http\";\nimport { watch, type FSWatcher } from \"node:fs\";\nimport { readFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport type { Duplex } from \"node:stream\";\nimport { graphSnapshotFromMemoryDir, type GraphSnapshot } from \"./graph-dashboard-parser.js\";\nimport { diffGraphSnapshots } from \"./graph-dashboard-diff.js\";\n\nexport interface DashboardServerOptions {\n  memoryDir: string;\n  host?: string;\n  port?: number;\n  publicDir?: string;\n  watchDebounceMs?: number;\n}\n\nexport interface DashboardStatus {\n  running: boolean;\n  host: string;\n  port: number;\n  watching: boolean;\n  lastUpdatedAt?: string;\n  graphNodeCount: number;\n  graphEdgeCount: number;\n}\n\ntype WsClient = {\n  id: string;\n  socket: Duplex;\n};\n\nconst LOOPBACK_HOSTS = new Set([\"127.0.0.1\", \"localhost\", \"::1\"]);\n\nfunction normalizeOriginHostname(hostname: string): string {\n  if (hostname.startsWith(\"[\") && hostname.endsWith(\"]\")) {\n    return hostname.slice(1, -1);\n  }\n  return hostname;\n}\n\nfunction websocketAcceptKey(clientKey: string): string {\n  return createHash(\"sha1\")\n    .update(`${clientKey}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`)\n    .digest(\"base64\");\n}\n\nfunction encodeTextFrame(payload: string): Buffer {\n  const payloadBuffer = Buffer.from(payload, \"utf-8\");\n  const len = payloadBuffer.length;\n  const header: number[] = [0x81];\n  if (len <= 125) {\n    header.push(len);\n  } else if (len <= 0xffff) {\n    header.push(126, (len >> 8) & 0xff, len & 0xff);\n  } else {\n    const high = Math.floor(len / 2 ** 32);\n    const low = len >>> 0;\n    header.push(127, (high >> 24) & 0xff, (high >> 16) & 0xff, (high >> 8) & 0xff, high & 0xff, (low >> 24) & 0xff, (low >> 16) & 0xff, (low >> 8) & 0xff, low & 0xff);\n  }\n  return Buffer.concat([Buffer.from(header), payloadBuffer]);\n}\n\nexport class GraphDashboardServer {\n  private readonly memoryDir: string;\n  private readonly host: string;\n  private readonly requestedPort: number;\n  private readonly publicDir: string;\n  private readonly watchDebounceMs: number;\n  private server: ReturnType<typeof createServer> | null = null;\n  private watcher: FSWatcher | null = null;\n  private clients = new Map<string, WsClient>();\n  private graphSnapshot: GraphSnapshot = {\n    generatedAt: new Date(0).toISOString(),\n    nodes: [],\n    edges: [],\n    stats: { nodes: 0, edges: 0, malformedLines: 0, filesMissing: [] },\n  };\n  private debounceTimer: NodeJS.Timeout | null = null;\n  private lastError: string | null = null;\n  private boundPort = 0;\n\n  constructor(options: DashboardServerOptions) {\n    this.memoryDir = options.memoryDir;\n    this.host = options.host?.trim() || \"127.0.0.1\";\n    this.requestedPort = Number.isFinite(options.port) ? Math.max(0, Math.floor(options.port ?? 0)) : 0;\n    this.publicDir = options.publicDir ?? path.join(process.cwd(), \"dashboard\", \"public\");\n    this.watchDebounceMs = Math.max(50, Math.floor(options.watchDebounceMs ?? 300));\n  }\n\n  async start(): Promise<DashboardStatus> {\n    if (this.server) {\n      return this.status();\n    }\n\n    await this.rebuildSnapshot();\n    const candidate = createServer((req, res) => {\n      void this.handleHttp(req, res);\n    });\n    candidate.on(\"upgrade\", (req, socket) => {\n      this.handleUpgrade(req, socket);\n    });\n    try {\n      await new Promise<void>((resolve, reject) => {\n        const onError = (err: Error) => {\n          candidate.off(\"listening\", onListening);\n          reject(err);\n        };\n        const onListening = () => {\n          candidate.off(\"error\", onError);\n          resolve();\n        };\n        candidate.once(\"error\", onError);\n        candidate.once(\"listening\", onListening);\n        candidate.listen(this.requestedPort, this.host);\n      });\n    } catch (err) {\n      this.lastError = err instanceof Error ? err.message : String(err);\n      try {\n        candidate.close();\n      } catch {\n        // no-op\n      }\n      throw err;\n    }\n    this.server = candidate;\n    const addr = candidate.address();\n    this.boundPort = typeof addr === \"object\" && addr ? addr.port : this.requestedPort;\n    this.startWatcher();\n    return this.status();\n  }\n\n  async stop(): Promise<void> {\n    const closeServer = this.server;\n    this.server = null;\n    this.boundPort = 0;\n\n    if (this.debounceTimer) {\n      clearTimeout(this.debounceTimer);\n      this.debounceTimer = null;\n    }\n    if (this.watcher) {\n      this.watcher.close();\n      this.watcher = null;\n    }\n    for (const client of this.clients.values()) {\n      try {\n        client.socket.destroy();\n      } catch {\n        // no-op\n      }\n    }\n    this.clients.clear();\n\n    if (closeServer) {\n      await new Promise<void>((resolve, reject) => {\n        closeServer.close((err) => {\n          if (err) reject(err);\n          else resolve();\n        });\n      });\n    }\n  }\n\n  status(): DashboardStatus {\n    return {\n      running: this.server !== null,\n      host: this.host,\n      port: this.boundPort,\n      watching: this.watcher !== null,\n      lastUpdatedAt: this.graphSnapshot.generatedAt,\n      graphNodeCount: this.graphSnapshot.stats.nodes,\n      graphEdgeCount: this.graphSnapshot.stats.edges,\n    };\n  }\n\n  private async handleHttp(req: IncomingMessage, res: ServerResponse): Promise<void> {\n    const url = req.url ?? \"/\";\n    if (req.method === \"GET\" && url === \"/api/health\") {\n      this.respondJson(res, 200, {\n        ok: true,\n        running: this.server !== null,\n        watching: this.watcher !== null,\n        graph: this.graphSnapshot.stats,\n        clients: this.clients.size,\n        lastError: this.lastError ?? undefined,\n      });\n      return;\n    }\n    if (req.method === \"GET\" && url === \"/api/graph\") {\n      this.respondJson(res, 200, this.graphSnapshot);\n      return;\n    }\n    if (req.method === \"GET\" && url === \"/app.js\") {\n      await this.respondStatic(res, path.join(this.publicDir, \"app.js\"), \"application/javascript; charset=utf-8\");\n      return;\n    }\n    if (req.method === \"GET\" && (url === \"/\" || url === \"/index.html\")) {\n      await this.respondStatic(res, path.join(this.publicDir, \"index.html\"), \"text/html; charset=utf-8\");\n      return;\n    }\n    this.respondJson(res, 404, { error: \"Not found\" });\n  }\n\n  private respondJson(res: ServerResponse, status: number, payload: unknown): void {\n    const body = JSON.stringify(payload, null, 2);\n    res.statusCode = status;\n    res.setHeader(\"content-type\", \"application/json; charset=utf-8\");\n    res.setHeader(\"content-length\", String(Buffer.byteLength(body)));\n    res.end(body);\n  }\n\n  private async respondStatic(res: ServerResponse, filePath: string, contentType: string): Promise<void> {\n    try {\n      const body = await readFile(filePath, \"utf-8\");\n      res.statusCode = 200;\n      res.setHeader(\"content-type\", contentType);\n      res.setHeader(\"content-length\", String(Buffer.byteLength(body)));\n      res.end(body);\n    } catch {\n      this.respondJson(res, 404, { error: \"Not found\" });\n    }\n  }\n\n  private handleUpgrade(req: IncomingMessage, socket: Duplex): void {\n    const upgrade = typeof req.headers.upgrade === \"string\" ? req.headers.upgrade.toLowerCase() : \"\";\n    const key = req.headers[\"sec-websocket-key\"];\n    const origin = typeof req.headers.origin === \"string\" ? req.headers.origin : \"\";\n    if (upgrade !== \"websocket\" || typeof key !== \"string\") {\n      socket.write(\"HTTP/1.1 400 Bad Request\\r\\n\\r\\n\");\n      socket.destroy();\n      return;\n    }\n    if (!this.isAllowedOrigin(origin)) {\n      socket.write(\"HTTP/1.1 403 Forbidden\\r\\n\\r\\n\");\n      socket.destroy();\n      return;\n    }\n    const accept = websocketAcceptKey(key);\n    socket.write(\n      [\n        \"HTTP/1.1 101 Switching Protocols\",\n        \"Upgrade: websocket\",\n        \"Connection: Upgrade\",\n        `Sec-WebSocket-Accept: ${accept}`,\n        \"\",\n        \"\",\n      ].join(\"\\r\\n\"),\n    );\n    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;\n    this.clients.set(id, { id, socket });\n    socket.on(\"close\", () => {\n      this.clients.delete(id);\n    });\n    socket.on(\"error\", () => {\n      this.clients.delete(id);\n    });\n\n    const hello = JSON.stringify({\n      type: \"hello\",\n      graph: this.graphSnapshot,\n    });\n    socket.write(encodeTextFrame(hello));\n  }\n\n  private isAllowedOrigin(origin: string): boolean {\n    if (!origin) return false;\n    try {\n      const parsed = new URL(origin);\n      const hostname = normalizeOriginHostname(parsed.hostname);\n      if (!LOOPBACK_HOSTS.has(hostname)) return false;\n      if (parsed.protocol !== \"http:\") return false;\n      const originPort = parsed.port ? Number(parsed.port) : 80;\n      return Number.isFinite(originPort) && originPort === this.boundPort;\n    } catch {\n      return false;\n    }\n  }\n\n  private broadcast(payload: unknown): void {\n    const frame = encodeTextFrame(JSON.stringify(payload));\n    for (const [id, client] of this.clients.entries()) {\n      try {\n        client.socket.write(frame);\n      } catch {\n        this.clients.delete(id);\n      }\n    }\n  }\n\n  private startWatcher(): void {\n    const graphDir = path.join(this.memoryDir, \"state\", \"graphs\");\n    try {\n      this.watcher = watch(graphDir, { persistent: false }, () => {\n        this.scheduleRebuild();\n      });\n      this.watcher.on(\"error\", (err) => {\n        this.lastError = err instanceof Error ? err.message : String(err);\n      });\n    } catch (err) {\n      this.lastError = err instanceof Error ? err.message : String(err);\n      this.watcher = null;\n    }\n  }\n\n  private scheduleRebuild(): void {\n    if (this.debounceTimer) clearTimeout(this.debounceTimer);\n    this.debounceTimer = setTimeout(() => {\n      this.debounceTimer = null;\n      void this.rebuildAndBroadcast();\n    }, this.watchDebounceMs);\n  }\n\n  private async rebuildAndBroadcast(): Promise<void> {\n    const previous = this.graphSnapshot;\n    await this.rebuildSnapshot();\n    const patch = diffGraphSnapshots(previous, this.graphSnapshot);\n    if (patch.addedEdges.length === 0 && patch.removedEdges.length === 0 && patch.addedNodes.length === 0 && patch.removedNodes.length === 0) {\n      return;\n    }\n    this.broadcast({\n      type: \"graph_patch\",\n      generatedAt: new Date().toISOString(),\n      patch,\n      graph: this.graphSnapshot,\n    });\n  }\n\n  private async rebuildSnapshot(): Promise<void> {\n    try {\n      this.graphSnapshot = await graphSnapshotFromMemoryDir(this.memoryDir);\n      this.lastError = null;\n    } catch (err) {\n      this.lastError = err instanceof Error ? err.message : String(err);\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-ZTFCYYEZ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/lcm/recall.ts"],"sourcesContent":["import type { LcmDag, SummaryNode } from \"./dag.js\";\nimport type { LcmArchive } from \"./archive.js\";\nimport { log } from \"../logger.js\";\n\nexport interface LcmRecallConfig {\n  freshTailTurns: number;\n  budgetChars: number;\n}\n\n/**\n * Assemble a compressed session history section from the summary DAG.\n *\n * Strategy:\n * 1. For the \"fresh tail\" (most recent N turns), use leaf-level summaries for maximum detail.\n * 2. For older portions, use the deepest available summary nodes (most compressed).\n * 3. Fill within budget, prioritizing recent content.\n */\nexport function assembleCompressedHistory(\n  dag: LcmDag,\n  archive: LcmArchive,\n  sessionId: string,\n  config: LcmRecallConfig,\n): string {\n  const maxTurn = archive.getMaxTurnIndex(sessionId);\n  if (maxTurn < 0) return \"\";\n\n  const allNodes = dag.getAllNodes(sessionId);\n  if (allNodes.length === 0) return \"\";\n\n  const freshTailStart = Math.max(0, maxTurn - config.freshTailTurns + 1);\n  const sections: string[] = [];\n  let usedChars = 0;\n\n  // Collect nodes covering the \"old\" portion (before fresh tail)\n  if (freshTailStart > 0) {\n    const oldNodes = selectBestCoverage(allNodes, 0, freshTailStart - 1);\n    for (const node of oldNodes) {\n      const label = formatRangeLabel(node, maxTurn);\n      const entry = `**${label}** (depth ${node.depth}):\\n${node.summary_text}`;\n      if (usedChars + entry.length > config.budgetChars) break;\n      sections.push(entry);\n      usedChars += entry.length;\n    }\n  }\n\n  // Collect leaf nodes that overlap with the fresh tail region.\n  // The old section uses deep nodes (depth > 0), so leaf nodes included here\n  // won't duplicate old-section content. Use msg_end >= freshTailStart to\n  // include straddling leaf nodes that partially cover the fresh region.\n  const freshNodes = allNodes\n    .filter(\n      (n) => n.depth === 0 && n.msg_end >= freshTailStart && n.msg_end <= maxTurn,\n    )\n    .sort((a, b) => a.msg_start - b.msg_start);\n\n  for (const node of freshNodes) {\n    const label = `Recent (turns ${node.msg_start}-${node.msg_end})`;\n    const entry = `**${label}**:\\n${node.summary_text}`;\n    if (usedChars + entry.length > config.budgetChars) break;\n    sections.push(entry);\n    usedChars += entry.length;\n  }\n\n  if (sections.length === 0) return \"\";\n\n  return `## Session History (Compressed)\\n\\n${sections.join(\"\\n\\n\")}`;\n}\n\n/**\n * Select the best coverage for a turn range.\n * Prefers deeper (more compressed) nodes. Avoids overlapping coverage.\n */\nfunction selectBestCoverage(\n  allNodes: SummaryNode[],\n  fromTurn: number,\n  toTurn: number,\n): SummaryNode[] {\n  // Filter to nodes that overlap with the requested range\n  const candidates = allNodes.filter(\n    (n) => n.msg_start <= toTurn && n.msg_end >= fromTurn,\n  );\n\n  if (candidates.length === 0) return [];\n\n  // Sort by msg_start ascending, then depth descending (prefer deeper at same position)\n  candidates.sort((a, b) => {\n    if (a.msg_start !== b.msg_start) return a.msg_start - b.msg_start;\n    return b.depth - a.depth;\n  });\n\n  // Greedily select non-overlapping nodes, preferring deeper coverage.\n  // Clamp msg_end to toTurn to prevent deep nodes from extending\n  // past the requested range (e.g., into the fresh tail region).\n  const selected: SummaryNode[] = [];\n  let coveredUpTo = fromTurn - 1;\n\n  for (const node of candidates) {\n    if (node.msg_start > coveredUpTo) {\n      selected.push(node);\n      coveredUpTo = Math.min(node.msg_end, toTurn);\n      if (coveredUpTo >= toTurn) break;\n    }\n  }\n\n  // Re-sort selected by msg_start for chronological output\n  selected.sort((a, b) => a.msg_start - b.msg_start);\n  return selected;\n}\n\nfunction formatRangeLabel(node: SummaryNode, maxTurn: number): string {\n  const startPct = Math.round((node.msg_start / Math.max(1, maxTurn)) * 100);\n  const endPct = Math.round((node.msg_end / Math.max(1, maxTurn)) * 100);\n\n  if (startPct < 33) return `Early session (turns ${node.msg_start}-${node.msg_end})`;\n  if (endPct < 66) return `Mid session (turns ${node.msg_start}-${node.msg_end})`;\n  return `Later session (turns ${node.msg_start}-${node.msg_end})`;\n}\n"],"mappings":";AAiBO,SAAS,0BACd,KACA,SACA,WACA,QACQ;AACR,QAAM,UAAU,QAAQ,gBAAgB,SAAS;AACjD,MAAI,UAAU,EAAG,QAAO;AAExB,QAAM,WAAW,IAAI,YAAY,SAAS;AAC1C,MAAI,SAAS,WAAW,EAAG,QAAO;AAElC,QAAM,iBAAiB,KAAK,IAAI,GAAG,UAAU,OAAO,iBAAiB,CAAC;AACtE,QAAM,WAAqB,CAAC;AAC5B,MAAI,YAAY;AAGhB,MAAI,iBAAiB,GAAG;AACtB,UAAM,WAAW,mBAAmB,UAAU,GAAG,iBAAiB,CAAC;AACnE,eAAW,QAAQ,UAAU;AAC3B,YAAM,QAAQ,iBAAiB,MAAM,OAAO;AAC5C,YAAM,QAAQ,KAAK,KAAK,aAAa,KAAK,KAAK;AAAA,EAAO,KAAK,YAAY;AACvE,UAAI,YAAY,MAAM,SAAS,OAAO,YAAa;AACnD,eAAS,KAAK,KAAK;AACnB,mBAAa,MAAM;AAAA,IACrB;AAAA,EACF;AAMA,QAAM,aAAa,SAChB;AAAA,IACC,CAAC,MAAM,EAAE,UAAU,KAAK,EAAE,WAAW,kBAAkB,EAAE,WAAW;AAAA,EACtE,EACC,KAAK,CAAC,GAAG,MAAM,EAAE,YAAY,EAAE,SAAS;AAE3C,aAAW,QAAQ,YAAY;AAC7B,UAAM,QAAQ,iBAAiB,KAAK,SAAS,IAAI,KAAK,OAAO;AAC7D,UAAM,QAAQ,KAAK,KAAK;AAAA,EAAQ,KAAK,YAAY;AACjD,QAAI,YAAY,MAAM,SAAS,OAAO,YAAa;AACnD,aAAS,KAAK,KAAK;AACnB,iBAAa,MAAM;AAAA,EACrB;AAEA,MAAI,SAAS,WAAW,EAAG,QAAO;AAElC,SAAO;AAAA;AAAA,EAAsC,SAAS,KAAK,MAAM,CAAC;AACpE;AAMA,SAAS,mBACP,UACA,UACA,QACe;AAEf,QAAM,aAAa,SAAS;AAAA,IAC1B,CAAC,MAAM,EAAE,aAAa,UAAU,EAAE,WAAW;AAAA,EAC/C;AAEA,MAAI,WAAW,WAAW,EAAG,QAAO,CAAC;AAGrC,aAAW,KAAK,CAAC,GAAG,MAAM;AACxB,QAAI,EAAE,cAAc,EAAE,UAAW,QAAO,EAAE,YAAY,EAAE;AACxD,WAAO,EAAE,QAAQ,EAAE;AAAA,EACrB,CAAC;AAKD,QAAM,WAA0B,CAAC;AACjC,MAAI,cAAc,WAAW;AAE7B,aAAW,QAAQ,YAAY;AAC7B,QAAI,KAAK,YAAY,aAAa;AAChC,eAAS,KAAK,IAAI;AAClB,oBAAc,KAAK,IAAI,KAAK,SAAS,MAAM;AAC3C,UAAI,eAAe,OAAQ;AAAA,IAC7B;AAAA,EACF;AAGA,WAAS,KAAK,CAAC,GAAG,MAAM,EAAE,YAAY,EAAE,SAAS;AACjD,SAAO;AACT;AAEA,SAAS,iBAAiB,MAAmB,SAAyB;AACpE,QAAM,WAAW,KAAK,MAAO,KAAK,YAAY,KAAK,IAAI,GAAG,OAAO,IAAK,GAAG;AACzE,QAAM,SAAS,KAAK,MAAO,KAAK,UAAU,KAAK,IAAI,GAAG,OAAO,IAAK,GAAG;AAErE,MAAI,WAAW,GAAI,QAAO,wBAAwB,KAAK,SAAS,IAAI,KAAK,OAAO;AAChF,MAAI,SAAS,GAAI,QAAO,sBAAsB,KAAK,SAAS,IAAI,KAAK,OAAO;AAC5E,SAAO,wBAAwB,KAAK,SAAS,IAAI,KAAK,OAAO;AAC/D;","names":[]}

package/dist/chunk-ZYVPLJ4T.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/transfer/capsule-import.ts"],"sourcesContent":["import { lstat, mkdir, readFile, realpath, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { createHash, randomUUID } from \"node:crypto\";\nimport { gunzipSync } from \"node:zlib\";\nimport {\n  createVersion,\n  type VersioningConfig,\n  type VersioningLogger,\n} from \"../page-versioning.js\";\nimport {\n  assertIsDirectoryNotSymlink,\n  assertRealpathInsideRoot,\n  fromPosixRelPath,\n  isPathInsideRoot,\n  sha256String,\n} from \"./fs-utils.js\";\nimport {\n  parseExportBundle,\n  type CapsuleBlock,\n  type ExportManifestV2,\n  type ExportMemoryRecordV1,\n} from \"./types.js\";\nimport { isEncryptedCapsuleFile, decryptCapsuleFileInMemory } from \"./capsule-crypto.js\";\n\n/**\n * Conflict-resolution mode for {@link importCapsule}. Inverse of the\n * `mode` selector in PR 4/6's CLI surface.\n *\n *  - `\"skip\"` (default) — when a target file already exists at the same\n *    relative path, leave it untouched. The corresponding record is reported\n *    via {@link ImportCapsuleResult.skipped}.\n *  - `\"overwrite\"` — when a target file exists, snapshot the prior content\n *    via {@link createVersion} (gotcha #54: write-before-delete; gotcha #25:\n *    don't destroy old state until new state is confirmed), then write the\n *    incoming content. The snapshot's `note` includes the source capsule id.\n *  - `\"fork\"` — never overwrite. Every record is rebased under\n *    `forks/<capsule-id>/<original-path>` and any YAML-frontmatter `id:`\n *    field is rewritten to a new fork-scoped value. The original tree is\n *    not touched.\n *\n * The mode is selected once per call and applied uniformly to every record\n * in the bundle. Mixed-mode imports are not supported by design — that\n * would let a single corrupted manifest silently land partial state.\n */\nexport type ImportCapsuleMode = \"skip\" | \"overwrite\" | \"fork\";\n\n/**\n * Options accepted by {@link importCapsule}.\n *\n * `archivePath` — absolute or cwd-relative path to a `.capsule.json.gz`\n * archive produced by `exportCapsule`. The archive must contain a V2\n * bundle (`schemaVersion: 2`); V1 archives are rejected.\n *\n * `root` — absolute or cwd-relative path to the memory directory that\n * will receive the records. Must be an existing directory.\n *\n * `mode` — see {@link ImportCapsuleMode}. Defaults to `\"skip\"`.\n *\n * `versioning` — optional page-versioning config used by `mode: \"overwrite\"`\n * to snapshot prior content before replacing it. Snapshots are skipped when\n * not provided or when `enabled === false`. Tests pass an enabled config\n * to assert snapshot creation; production callers thread the\n * orchestrator's resolved versioning config.\n *\n * `log` — optional logger forwarded to {@link createVersion}.\n *\n * `now` — optional clock override (ms epoch) used to derive deterministic\n * fork ids in tests. Production callers omit this.\n */\nexport interface ImportCapsuleOptions {\n  archivePath: string;\n  root: string;\n  mode?: ImportCapsuleMode;\n  versioning?: VersioningConfig;\n  log?: VersioningLogger;\n  now?: number;\n  /**\n   * Memory directory whose secure-store keyring is used when the archive is\n   * encrypted. Required when `archivePath` ends with `.enc` or when the file\n   * starts with the REMNIC-ENC magic header. If `memoryDir` is omitted and the\n   * archive turns out to be encrypted, `importCapsule` throws a clear error\n   * rather than silently failing.\n   *\n   * When provided and the archive is NOT encrypted, the value is ignored.\n   */\n  memoryDir?: string;\n}\n\nexport interface ImportCapsuleSkippedRecord {\n  /** Original record path (capsule-relative, posix). */\n  path: string;\n  /**\n   * Why this record was not written.\n   *\n   * `\"exists\"` — the target path already existed and the mode was `\"skip\"`,\n   * OR the computed fork path already existed in fork mode.\n   *\n   * `\"checksum_mismatch\"` is intentionally absent: a checksum failure aborts\n   * the import entirely (fail-closed) rather than skipping the offending\n   * record, so no `ImportCapsuleSkippedRecord` is ever produced for it.\n   */\n  reason: \"exists\";\n}\n\nexport interface ImportCapsuleImportedRecord {\n  /** Capsule-relative posix path the record carried. */\n  sourcePath: string;\n  /** Memory-dir-relative posix path the file was written to. */\n  targetPath: string;\n  /** Whether a prior version snapshot was taken (overwrite-mode only). */\n  snapshotted: boolean;\n  /** Whether the frontmatter `id:` field was rewritten (fork-mode only). */\n  rewroteId: boolean;\n}\n\nexport interface ImportCapsuleResult {\n  /** Records that landed on disk. */\n  imported: ImportCapsuleImportedRecord[];\n  /** Records that were not written. */\n  skipped: ImportCapsuleSkippedRecord[];\n  /** The manifest decoded from the archive. */\n  manifest: ExportManifestV2;\n}\n\n/**\n * Pure async function that imports a capsule archive into a memory\n * directory. Inverse of {@link import(\"./capsule-export.js\").exportCapsule}.\n *\n * Sequence:\n *   1. Read + gunzip + JSON.parse the archive.\n *   2. Validate the bundle through `parseExportBundle` (V1 rejected).\n *   3. Verify each record's content sha256 against the manifest entry.\n *      Any mismatch aborts the import BEFORE any file is written —\n *      partial-write recovery would require a full rollback we cannot\n *      offer cheaply, so we fail closed (gotcha #25).\n *   4. Apply the selected {@link ImportCapsuleMode} to every record.\n *\n * Determinism guarantees:\n *  - Imported records are returned sorted by `sourcePath`.\n *  - Skipped records are returned sorted by `path`.\n *  - Fork-mode rebases under a stable `forks/<capsule-id>/` prefix so\n *    repeated fork imports of the same capsule shape land in predictable\n *    locations (subsequent fork imports still skip-on-exist because the\n *    target tree is computed from the source path).\n */\nexport async function importCapsule(\n  opts: ImportCapsuleOptions,\n): Promise<ImportCapsuleResult> {\n  const archiveAbs = path.resolve(opts.archivePath);\n  const rootAbs = path.resolve(opts.root);\n  await assertIsDirectoryNotSymlink(rootAbs, \"importCapsule\", \"root\");\n\n  const mode: ImportCapsuleMode = opts.mode ?? \"skip\";\n  // Reject unknown mode values up-front (rule 51). TypeScript callers get a\n  // compile-time check via the union type; JS/CLI callers get a runtime error\n  // here before any write begins — not a silent destructive fallback.\n  if (mode !== \"skip\" && mode !== \"overwrite\" && mode !== \"fork\") {\n    throw new Error(\n      `importCapsule: unknown mode ${JSON.stringify(mode)}; expected \"skip\", \"overwrite\", or \"fork\"`,\n    );\n  }\n\n  // Auto-detect encrypted archives. If the file ends with `.enc` or starts\n  // with the REMNIC-ENC magic header, decrypt it first before gunzip+parse.\n  // Rule 48: default is \"not encrypted\"; we only attempt decryption when the\n  // header is definitively present, never on ambiguous content.\n  const encrypted = await isEncryptedCapsuleFile(archiveAbs);\n  let raw: Buffer;\n  if (encrypted) {\n    if (!opts.memoryDir) {\n      throw new Error(\n        `importCapsule: archive is encrypted but 'memoryDir' was not provided. ` +\n          `Pass the memory directory so the secure-store key can be retrieved, ` +\n          `or run \\`remnic secure-store unlock\\` before importing.`,\n      );\n    }\n    raw = await decryptCapsuleFileInMemory(archiveAbs, opts.memoryDir);\n  } else {\n    raw = await readFile(archiveAbs);\n  }\n  const json = gunzipSync(raw).toString(\"utf-8\");\n  let parsedJson: unknown;\n  try {\n    parsedJson = JSON.parse(json);\n  } catch (cause) {\n    throw new Error(\n      `importCapsule: archive is not valid JSON after gunzip: ${archiveAbs}`,\n      { cause: cause as Error },\n    );\n  }\n\n  const parsed = parseExportBundle(parsedJson);\n  if (parsed.capsuleVersion !== 2) {\n    // PR 1/6 ships a V1 reader; capsule import is V2-only by design. A V1\n    // bundle does not carry a capsule block, so fork-mode (which depends on\n    // `capsule.id` for the rebase prefix) cannot work. Reject up-front per\n    // gotcha #51 instead of silently routing to a different code path.\n    throw new Error(\n      \"importCapsule: archive is V1; only V2 capsule archives are supported\",\n    );\n  }\n  const bundle = parsed.bundle as { manifest: ExportManifestV2; records: ExportMemoryRecordV1[] };\n  const manifest = bundle.manifest;\n  const capsule = manifest.capsule;\n\n  // Build a path → manifest-entry index for O(1) checksum lookup. The\n  // manifest is the source of truth; records-without-manifest-entries and\n  // manifest-entries-without-records are both treated as corruption.\n  const manifestIndex = new Map<string, ExportManifestV2[\"files\"][number]>();\n  for (const f of manifest.files) {\n    manifestIndex.set(f.path, f);\n  }\n  if (manifestIndex.size !== manifest.files.length) {\n    throw new Error(\n      \"importCapsule: manifest contains duplicate file paths\",\n    );\n  }\n  const recordPaths = new Set<string>();\n  for (const rec of bundle.records) {\n    if (recordPaths.has(rec.path)) {\n      throw new Error(\n        `importCapsule: bundle contains duplicate record path: ${rec.path}`,\n      );\n    }\n    recordPaths.add(rec.path);\n  }\n\n  // Phase 1: verify every record matches its manifest entry AND validate all\n  // target paths before any filesystem mutation.  We do both in a single pass\n  // so a corrupted or malicious archive cannot leave the memory dir partially\n  // written (fail-closed per gotcha #25).\n  //\n  // The real root is resolved once via realpath so the subsequent per-record\n  // inside-root checks are symlink-aware: a record path like `facts/a.md`\n  // cannot write outside the intended sandbox via a symlinked subdirectory\n  // (Codex P1 feedback).  If realpath fails (root does not exist) the earlier\n  // assertIsDirectoryNotSymlink call already threw, so this should always succeed.\n  const rootReal = await realpath(rootAbs).catch(() => rootAbs);\n\n  // Tracks normalized, case-folded target paths seen so far in phase 1.  Maps\n  // targetAbs.toLowerCase() → first source path so the collision error can name\n  // both offending entries.  Two manifest entries whose computed target paths\n  // normalize to the same absolute path (e.g. `subdir/file.md` and\n  // `subdir/./file.md`, or differing case on case-insensitive filesystems such\n  // as macOS and Windows) would both try to write the same inode — the second\n  // would silently overwrite the first.  We reject the import up-front before\n  // any write (Codex P2 thread on PR #741, line 283).\n  const seenTargetPaths = new Map<string, string>();\n\n  for (const rec of bundle.records) {\n    // Checksum validation.\n    const entry = manifestIndex.get(rec.path);\n    if (!entry) {\n      throw new Error(\n        `importCapsule: archive checksum mismatch (record without manifest entry: ${rec.path})`,\n      );\n    }\n    const { sha256, bytes } = sha256String(rec.content);\n    if (sha256 !== entry.sha256 || bytes !== entry.bytes) {\n      throw new Error(\n        `importCapsule: archive checksum mismatch for ${rec.path}: ` +\n          `expected sha256=${entry.sha256} bytes=${entry.bytes}, ` +\n          `got sha256=${sha256} bytes=${bytes}`,\n      );\n    }\n\n    // Source path validation: reject any record whose posix source path\n    // contains a `..` segment, an absolute prefix, or any component that would\n    // let fork-mode bypass its isolation invariant.  This check runs before\n    // `computeTargetPath` so that fork mode's `forks/<id>/` rebase cannot be\n    // bypassed by a path like `../../profile.md` (which `path.join` would\n    // silently collapse, landing the file inside root but outside the fork\n    // prefix — Cursor medium thread #741).  Rejecting `..` up-front is simpler\n    // and more robust than normalising after the fact.\n    //\n    // Extended guard (Codex P1 #741 round 5): also reject paths containing\n    // backslash separators (`\\`), which are Windows path separators. On Windows\n    // a path like `..\\\\escape.md` or `subdir\\\\..\\\\..\\\\escape.md` would resolve\n    // to a parent traversal but would bypass a purely posix-split check.\n    // Additionally, after posix-normalizing the path we re-check for a leading\n    // `..` or `/` — this catches edge-cases such as `subdir/../..` where the\n    // individual split segments are not `..` but the normalized result is.\n    if (rec.path.includes(\"\\\\\")) {\n      throw new Error(\n        `importCapsule: record path contains backslash separators (Windows-style paths are not allowed): ${rec.path}`,\n      );\n    }\n    const posixNormalized = path.posix.normalize(rec.path);\n    if (\n      rec.path.startsWith(\"/\") ||\n      rec.path.split(\"/\").some((seg) => seg === \"..\") ||\n      posixNormalized.startsWith(\"..\") ||\n      posixNormalized.startsWith(\"/\")\n    ) {\n      throw new Error(\n        `importCapsule: record path escapes target root: ${rec.path}`,\n      );\n    }\n\n    // Path-traversal validation (moved here from phase 2 per Cursor feedback:\n    // the traversal check must run before ANY write so a malicious archive\n    // with an escaping path that sorts last cannot land partial writes).\n    //\n    // We build targetAbs relative to the real-resolved root (rootReal) so\n    // that the inside-root check is symlink-aware: if `rootReal !== rootAbs`\n    // (the import root is itself behind a symlink), we still compare against\n    // the canonical path (Codex P1).\n    const targetRel = computeTargetPath(rec.path, mode, capsule.id);\n    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));\n    if (!isPathInsideRoot(rootReal, targetAbs)) {\n      throw new Error(\n        `importCapsule: record path escapes target root: ${rec.path}`,\n      );\n    }\n\n    // Symlink-aware containment check (Cursor thread #741 line 247/264).\n    // The lexical check above handles `..`-traversal but cannot detect\n    // symlinked subdirectories that point outside the root. We resolve the\n    // nearest existing ancestor of the target via realpath to catch symlinks\n    // anywhere in the path components. If any resolved prefix escapes rootReal,\n    // the import is rejected before any write. This applies to ALL modes,\n    // including fork mode whose rebase prefix may itself traverse a symlink.\n    await assertRealpathInsideRoot(rootReal, targetAbs, rec.path, \"importCapsule\");\n\n    // Target-file symlink check (Codex P1 #741 round 4, line 260).\n    // `assertRealpathInsideRoot` resolves the nearest existing *ancestor* to\n    // catch symlinked parent directories, but if the TARGET FILE itself already\n    // exists and is a symlink, that check passes (the parent is real) while the\n    // write would silently follow the symlink to a path outside root.  We\n    // therefore lstat the target directly: if it exists and is a symlink we\n    // reject the record up-front.  For new files the parent-canonicalization\n    // performed above is sufficient; no realpath of a non-existent file is\n    // needed.\n    const targetLstat = await lstat(targetAbs).catch(() => null);\n    if (targetLstat !== null && targetLstat.isSymbolicLink()) {\n      throw new Error(\n        `importCapsule: record target is a symlink and cannot be written to safely: ${rec.path}`,\n      );\n    }\n\n    // Duplicate normalized target path detection (Codex P2 #741, line 283).\n    // `path.join` already normalises `.` segments (e.g. `subdir/./file.md` →\n    // `subdir/file.md`).  On case-insensitive filesystems (macOS default,\n    // Windows), two paths that differ only in case would resolve to the same\n    // inode.  We fold the dedup key to lowercase so that `subdir/File.md` and\n    // `subdir/file.md` are detected as duplicates before any write occurs.\n    // This is intentionally unconditional: the cost of an extra `.toLowerCase()`\n    // on case-sensitive filesystems is negligible, and a defensive lowercase\n    // is far simpler than probing filesystem case-sensitivity at runtime.\n    const dedupKey = targetAbs.toLowerCase();\n    const firstSourcePath = seenTargetPaths.get(dedupKey);\n    if (firstSourcePath !== undefined) {\n      throw new Error(\n        `importCapsule: manifest contains two entries that resolve to the same target path: ` +\n          `\"${firstSourcePath}\" and \"${rec.path}\" both map to \"${targetRel}\"`,\n      );\n    }\n    seenTargetPaths.set(dedupKey, rec.path);\n  }\n  // Detect manifest-only entries (missing record). Treat as corruption.\n  for (const f of manifest.files) {\n    if (!recordPaths.has(f.path)) {\n      throw new Error(\n        `importCapsule: archive checksum mismatch (manifest entry without record: ${f.path})`,\n      );\n    }\n  }\n\n  // Phase 2: apply the mode. All records were validated in phase 1; we now\n  // write to disk. Per-record errors propagate; each individual write is\n  // atomic (mkdir + writeFile pair).\n  const imported: ImportCapsuleImportedRecord[] = [];\n  const skipped: ImportCapsuleSkippedRecord[] = [];\n\n  // Sort by source path so the imported/skipped lists are deterministic\n  // regardless of bundle order. (`exportCapsule` already sorts; we re-sort\n  // defensively in case a hand-edited archive ships records in another order.)\n  const sortedRecords = [...bundle.records].sort((a, b) =>\n    a.path.localeCompare(b.path),\n  );\n\n  for (const rec of sortedRecords) {\n    const targetRel = computeTargetPath(rec.path, mode, capsule.id);\n    // Use rootReal (realpath-resolved) to stay consistent with phase 1's\n    // traversal validation and avoid writing through stale symlinks.\n    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));\n\n    const exists = await fileExistsAt(targetAbs);\n\n    // Skip logic applies to both `skip` mode (explicit) and `fork` mode\n    // (Cursor medium: fork mode must also be skip-on-exist for the computed\n    // fork path, because production imports generate non-deterministic IDs —\n    // so re-importing the same capsule should not overwrite user edits in the\n    // fork tree or silently change file identities by generating new IDs).\n    if ((mode === \"skip\" || mode === \"fork\") && exists) {\n      skipped.push({ path: rec.path, reason: \"exists\" });\n      continue;\n    }\n\n    let snapshotted = false;\n    if (mode === \"overwrite\" && exists) {\n      // Gotcha #54: snapshot BEFORE overwriting. If snapshot creation fails\n      // we abort this record's import rather than silently destroying\n      // history. The page-versioning module is responsible for atomic\n      // sidecar writes; we just call it.\n      if (opts.versioning && opts.versioning.enabled) {\n        const prior = await readFile(targetAbs, \"utf-8\").catch(() => \"\");\n        await createVersion(\n          targetAbs,\n          prior,\n          \"manual\",\n          opts.versioning,\n          opts.log,\n          `capsule-import: ${capsule.id}`,\n          rootReal,\n        );\n        snapshotted = true;\n      }\n    }\n\n    let contentToWrite = rec.content;\n    let rewroteId = false;\n    if (mode === \"fork\") {\n      const forked = rewriteFrontmatterIdForFork(rec.content, capsule.id, opts.now);\n      contentToWrite = forked.content;\n      rewroteId = forked.rewrote;\n    }\n\n    await mkdir(path.dirname(targetAbs), { recursive: true });\n    await writeFile(targetAbs, contentToWrite, \"utf-8\");\n    imported.push({\n      sourcePath: rec.path,\n      targetPath: targetRel,\n      snapshotted,\n      rewroteId,\n    });\n  }\n\n  // Sort skipped for stable output (see comment above).\n  skipped.sort((a, b) => a.path.localeCompare(b.path));\n\n  return { imported, skipped, manifest };\n}\n\n// ---------------------------------------------------------------------------\n// Path helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Compute the destination relative path for a record under the chosen\n * mode.\n *\n *  - `skip` / `overwrite` — identity: the record's posix path is used as-is.\n *  - `fork` — rebased under `forks/<capsule-id>/<original-path>` so the\n *    original tree is never modified.\n */\nfunction computeTargetPath(\n  sourcePosix: string,\n  mode: ImportCapsuleMode,\n  capsuleId: string,\n): string {\n  if (mode === \"fork\") return `forks/${capsuleId}/${sourcePosix}`;\n  return sourcePosix;\n}\n\nasync function fileExistsAt(absPath: string): Promise<boolean> {\n  const st = await stat(absPath).catch(() => null);\n  return st !== null && st.isFile();\n}\n\n// ---------------------------------------------------------------------------\n// Fork-mode id rewriting\n// ---------------------------------------------------------------------------\n\n/**\n * Rewrite a YAML-frontmatter `id:` field to a fork-scoped value.\n *\n * Strategy: we deliberately do NOT parse the entire YAML — memory files\n * use a deterministic top-of-file frontmatter delimited by `---` lines,\n * and the orchestrator's `parseFrontmatter` reads `id` as a top-level\n * key with a single-line scalar value. We mirror that contract:\n *\n *   - Detect a leading `---\\n` … `\\n---` block at the top of the file.\n *   - Within that block, locate the first `id:` line that is not nested\n *     under another key (cheap heuristic: line starts at column 0).\n *   - Replace its value with a new fork-id derived from `capsuleId` and\n *     a short random suffix (or {@link opts.now} when provided for tests).\n *\n * Files without a frontmatter block, or without an `id:` key inside one,\n * are returned unchanged with `rewrote: false`. This keeps non-memory\n * artifacts (READMEs, transcripts) byte-identical to the source.\n */\nfunction rewriteFrontmatterIdForFork(\n  content: string,\n  capsuleId: string,\n  now: number | undefined,\n): { content: string; rewrote: boolean } {\n  // Detect the dominant line ending in the file so we can preserve it when\n  // rebuilding the frontmatter delimiters. Splitting/joining on `\\n` silently\n  // drops `\\r` from CRLF files, changing the byte content (Cursor thread #741\n  // line 467). We detect the ending of the very first line (the opening `---`)\n  // and use that as the canonical separator for the reconstructed delimiters.\n  // All three cases are covered: CRLF (\\r\\n), LF (\\n), and bare CR (\\r).\n  const crlfMatch = /^---(\\r\\n|\\r|\\n)/.exec(content);\n  // Fall back to LF if the file starts with `---` but has no newline (EOF).\n  const eol = crlfMatch ? crlfMatch[1] : \"\\n\";\n\n  // Frontmatter block detection: `---` on its own line at the very start,\n  // followed by content, followed by `---` on its own line. The closing\n  // delimiter must be at column 0. We capture the trailing terminator\n  // (`\\r?\\n` or end-of-string) as a separate group so we can re-emit it\n  // verbatim, preserving CRLF/LF/EOF shape from the original file.\n  const fmMatch = /^---\\r?\\n([\\s\\S]*?)\\r?\\n---(\\r?\\n|$)/.exec(content);\n  if (!fmMatch) return { content, rewrote: false };\n  const fmBody = fmMatch[1];\n  const fmTrailer = fmMatch[2];\n  const fmStart = fmMatch.index;\n  const fmEnd = fmStart + fmMatch[0].length;\n\n  // Find a top-level `id:` line. Top-level means the line begins at\n  // column 0 inside the frontmatter body (no leading whitespace) and the\n  // key is exactly `id`. We deliberately accept `id:` and `id : ` shapes\n  // but reject `nested_id:` to avoid touching unrelated keys.\n  const idLineRe = /^id:[ \\t]*([^\\r\\n]*)$/m;\n  const idMatch = idLineRe.exec(fmBody);\n  if (!idMatch) return { content, rewrote: false };\n\n  const newId = mintForkId(capsuleId, idMatch[1]?.trim() ?? \"\", now);\n  const replacedBody = fmBody.replace(idLineRe, `id: ${newId}`);\n  // Reconstruct the file: original prefix (always empty here, fmStart === 0\n  // by the `^` anchor) + frontmatter delimiters around the rewritten body.\n  // Use the detected `eol` for the opening/closing `---` lines so that CRLF\n  // files remain CRLF and LF files remain LF, preserving byte-content fidelity\n  // (Cursor thread #741 line 467).  The captured `fmTrailer` (the newline\n  // immediately after the closing `---`, or end-of-string) is re-emitted\n  // verbatim so the byte immediately after the closing fence is unchanged.\n  const prefix = content.slice(0, fmStart);\n  const tail = content.slice(fmEnd);\n  const rebuilt = `${prefix}---${eol}${replacedBody}${eol}---${fmTrailer}${tail}`;\n  return { content: rebuilt, rewrote: true };\n}\n\n/**\n * Derive a deterministic-when-`now`-is-set fork id from the capsule id and\n * the original record id. Production callers omit `now` and get a UUID\n * suffix; tests pass `now` for byte-stable assertions.\n */\nfunction mintForkId(capsuleId: string, originalId: string, now: number | undefined): string {\n  const base = originalId.length > 0 ? originalId : \"fork\";\n  if (now === undefined) {\n    const suffix = randomUUID().slice(0, 8);\n    return `${base}-fork-${capsuleId}-${suffix}`;\n  }\n  // Deterministic suffix: short hash of (capsuleId, originalId, now). Using\n  // sha256 over a sorted-key serialization (gotcha #38) so the suffix does\n  // not depend on Object.entries order.\n  const payload = JSON.stringify({ c: capsuleId, i: originalId, n: now });\n  const suffix = createHash(\"sha256\").update(payload, \"utf-8\").digest(\"hex\").slice(0, 8);\n  return `${base}-fork-${capsuleId}-${suffix}`;\n}\n\n// Note: `CapsuleBlock` is re-exported here purely so callers that want to\n// inspect the manifest block don't have to deep-import from `./types.js`.\nexport type { CapsuleBlock };\n"],"mappings":"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","names":["suffix"]}

package/dist/path-MR5JPYOP.js

@@ -1,9 +0,0 @@
-import {
-  expandTildePath
-} from "./chunk-QRNI5JBH.js";
-import "./chunk-XIG5PDM7.js";
-import "./chunk-PZ5AY32C.js";
-export {
-  expandTildePath
-};
-//# sourceMappingURL=path-MR5JPYOP.js.map

package/dist/state-store-VZU2IA53.js

@@ -1,16 +0,0 @@
-import {
-  _connectorStatePathForTest,
-  listConnectorStates,
-  readConnectorState,
-  writeConnectorState
-} from "./chunk-LPMVBPA3.js";
-import "./chunk-QRNI5JBH.js";
-import "./chunk-XIG5PDM7.js";
-import "./chunk-PZ5AY32C.js";
-export {
-  _connectorStatePathForTest,
-  listConnectorStates,
-  readConnectorState,
-  writeConnectorState
-};
-//# sourceMappingURL=state-store-VZU2IA53.js.map

package/dist/trace-C5ETWBEF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/console/trace.ts"],"sourcesContent":["/**\n * Trace recording + replay for the operator console (issue #688 PR 3/3).\n *\n * This module is the I/O layer that bridges the live console surface\n * (PR 2/3, `runConsoleTui`) with an offline replay mode. Operators can:\n *\n *   - `remnic console --record-trace <path>`: append every refresh\n *     cycle's `ConsoleStateSnapshot` to a JSONL file at `<path>` (one\n *     snapshot per line), so the engine state can be reviewed later.\n *\n *   - `remnic console --trace <path> [--speed N]`: read the JSONL file\n *     frame-by-frame, recompute the inter-frame delay from the\n *     captured `capturedAt` timestamps (divided by `speed`), and feed\n *     each frame into the same `renderFrame` function the live TUI\n *     uses. EOF exits cleanly.\n *\n * Design contract:\n *   - Replay reuses `renderFrame` (NOT a parallel reimplementation).\n *     Live and replay must look identical for the same snapshot.\n *   - Replay is fully sandboxed: no orchestrator instance is required,\n *     no filesystem reads beyond the trace file itself.\n *   - Recording is cheap: one `JSON.stringify` + a single\n *     `\\n`-delimited append per snapshot. A failed write logs once and\n *     disables further writes; the live loop must NOT crash.\n *   - Speed multiplier `N`: positive finite. `N=2` halves the delay,\n *     `N=0.5` doubles it. `Infinity` is permitted and means \"no\n *     delay\" (back-to-back frames).\n */\n\nimport { promises as fs } from \"node:fs\";\nimport path from \"node:path\";\nimport readline from \"node:readline\";\nimport { createReadStream } from \"node:fs\";\nimport type { Writable } from \"node:stream\";\n\nimport { renderFrame } from \"./tui.js\";\nimport type { ConsoleStateSnapshot } from \"./state.js\";\n\n/** ANSI: clear screen + move cursor to home (top-left). Same constant the TUI uses. */\nconst ANSI_CLEAR_HOME = \"\\x1b[2J\\x1b[H\";\n/** ANSI: hide / show the cursor during replay. */\nconst ANSI_HIDE_CURSOR = \"\\x1b[?25l\";\nconst ANSI_SHOW_CURSOR = \"\\x1b[?25h\";\n\n/**\n * Default delay (ms) used when the trace file has fewer than two\n * frames OR the captured timestamps don't yield a valid delta. Mirrors\n * the live TUI's default refresh interval for visual consistency.\n */\nconst DEFAULT_REPLAY_DELAY_MS = 2000;\n\n/**\n * Maximum allowed delay between replay frames. A pathological trace\n * with hour-long gaps would otherwise stall replay indefinitely; cap\n * at one minute so a tester running `--trace` always sees progress.\n */\nconst MAX_REPLAY_DELAY_MS = 60_000;\n\n/** Minimum delay between replay frames (ms) — prevents starving the loop. */\nconst MIN_REPLAY_DELAY_MS = 0;\n\nexport interface TraceRecorder {\n  /**\n   * Append a snapshot to the trace file. Returns a promise that\n   * resolves once the line is flushed. Errors are surfaced via\n   * `getLastError()` rather than thrown — the live TUI must never\n   * crash because tracing failed.\n   */\n  append: (snapshot: ConsoleStateSnapshot) => Promise<void>;\n  /**\n   * Close the underlying file handle. Idempotent.\n   *\n   * The optional `signal` parameter is forwarded from\n   * `flushWithTimeout` when the deadline wins the race. When the\n   * signal fires, the pending write-chain drain is abandoned and the\n   * file handle is closed immediately, releasing OS resources instead\n   * of leaving the handle open until the orphaned writeChain resolves.\n   */\n  close: (signal?: AbortSignal) => Promise<void>;\n  /** Returns the most recent error (or null) without throwing. */\n  getLastError: () => string | null;\n}\n\nexport interface OpenTraceRecorderOptions {\n  /**\n   * If true (default), `path` is created with `mkdir -p` on its\n   * parent directory before the first append. Set to false in tests\n   * that pre-create the parent.\n   */\n  ensureParentDir?: boolean;\n}\n\n/**\n * Open (create or append to) a JSONL trace recorder at `filePath`.\n * Each call to `recorder.append(snapshot)` writes\n * `JSON.stringify(snapshot) + \"\\n\"`. Concurrent appends are\n * serialized through an internal write chain so partial-line\n * interleaving cannot occur.\n */\nexport async function openTraceRecorder(\n  filePath: string,\n  options: OpenTraceRecorderOptions = {},\n): Promise<TraceRecorder> {\n  const ensureParentDir = options.ensureParentDir ?? true;\n  if (ensureParentDir) {\n    const parent = path.dirname(filePath);\n    if (parent && parent !== \".\" && parent !== \"/\") {\n      await fs.mkdir(parent, { recursive: true });\n    }\n  }\n  const handle = await fs.open(filePath, \"a\");\n  let closed = false;\n  let lastError: string | null = null;\n  // Codex P0 (Common Gotcha #40): a serialized promise chain without\n  // `.catch()` recovery permanently poisons the chain after the first\n  // I/O error. Use `queueWrite` — it surfaces the error to the caller\n  // AND restores the chain to a resolved state for the next caller.\n  let writeChain: Promise<void> = Promise.resolve();\n  const queueWrite = (line: string): Promise<void> => {\n    const next = writeChain.then(async () => {\n      if (closed) return;\n      try {\n        await handle.write(line);\n      } catch (err) {\n        const msg = describeError(err);\n        lastError = msg;\n        // Re-throw so the caller's awaiter sees the failure, but\n        // recover the chain below so the next append can still run.\n        throw err;\n      }\n    });\n    writeChain = next.catch(() => {\n      // Recovery: reset the chain so a single transient failure does\n      // not poison every subsequent append. The original error is\n      // already captured in `lastError` AND was surfaced to the\n      // caller via the awaited `next` promise above.\n    });\n    return next;\n  };\n  return {\n    append: async (snapshot: ConsoleStateSnapshot) => {\n      if (closed) return;\n      let line: string;\n      try {\n        line = JSON.stringify(snapshot) + \"\\n\";\n      } catch (err) {\n        // A non-serializable snapshot is a bug, not a runtime\n        // condition we should crash on. Record + skip.\n        lastError = `serialize failed: ${describeError(err)}`;\n        return;\n      }\n      try {\n        await queueWrite(line);\n      } catch {\n        // already captured in lastError via queueWrite\n      }\n    },\n    close: async (signal?: AbortSignal) => {\n      if (closed) return;\n      // Codex P1: do NOT set `closed = true` before draining. Each\n      // queued write begins with `if (closed) return;`, so flipping the\n      // flag first would silently drop frames that callers already\n      // queued via `append()`. Drain the existing chain first so every\n      // already-queued write executes against the still-open handle,\n      // THEN flip `closed` to reject any further appends, THEN close\n      // the file handle. This honors the documented \"drain pending\n      // writes\" contract of `close()`.\n      //\n      // Codex P1 (PR #732 round 5): when `flushWithTimeout` races the\n      // drain against a deadline and the timeout wins, it fires the\n      // `signal` passed here. We race the writeChain drain against that\n      // signal so the file handle is closed promptly instead of being\n      // held open until the orphaned writeChain eventually resolves.\n      try {\n        if (signal) {\n          await Promise.race([\n            writeChain,\n            new Promise<void>((_, reject) => {\n              if (signal.aborted) {\n                reject(makeAbortError());\n                return;\n              }\n              signal.addEventListener(\"abort\", () => reject(makeAbortError()), {\n                once: true,\n              });\n            }),\n          ]);\n        } else {\n          await writeChain;\n        }\n      } catch {\n        // ignore — abort or I/O error already in lastError\n      }\n      closed = true;\n      try {\n        await handle.close();\n      } catch (err) {\n        lastError = describeError(err);\n      }\n    },\n    getLastError: () => lastError,\n  };\n}\n\nexport interface ReplayTraceOptions {\n  /** Output stream. Defaults to `process.stdout`. */\n  output?: Writable;\n  /**\n   * Speed multiplier. `1` = original cadence, `2` = twice as fast,\n   * `0.5` = half speed. `Infinity` is permitted and means \"no\n   * delay\" (back-to-back frames). Defaults to 1.\n   */\n  speed?: number;\n  /**\n   * Override the inter-frame delay function — primarily for tests so\n   * we can swap `setTimeout` for an instant resolver. The function\n   * receives the *raw* (already-speed-adjusted) delay in ms.\n   */\n  sleep?: (ms: number) => Promise<void>;\n  /**\n   * Hide / show the terminal cursor during replay. Defaults to true.\n   * Tests typically pass false so they don't pollute captured output\n   * with cursor-control escapes.\n   */\n  manageCursor?: boolean;\n  /**\n   * Optional clock injection — feeds `renderFrame`'s \"current time\"\n   * value during replay. By default, replay uses the snapshot's own\n   * `capturedAt` so the rendered timestamp matches the original\n   * frame. Tests override this for determinism.\n   */\n  now?: (snapshot: ConsoleStateSnapshot, frameIndex: number) => number;\n  /**\n   * Abort signal. If aborted mid-replay, the loop exits cleanly at\n   * the next frame boundary.\n   */\n  signal?: AbortSignal;\n}\n\nexport interface ReplayTraceResult {\n  /** Total frames rendered. */\n  framesRendered: number;\n  /** Frames skipped because they could not be parsed. */\n  framesSkipped: number;\n  /** Last snapshot that was rendered, or null if the file was empty. */\n  lastSnapshot: ConsoleStateSnapshot | null;\n}\n\n/**\n * Replay a JSONL trace file frame-by-frame. Each line is parsed,\n * optionally renders via `renderFrame`, then waits the speed-adjusted\n * delay before the next frame. Returns once EOF is reached or the\n * abort signal fires.\n */\nexport async function replayTrace(\n  filePath: string,\n  options: ReplayTraceOptions = {},\n): Promise<ReplayTraceResult> {\n  const output: Writable = options.output ?? process.stdout;\n  const speed = normalizeSpeed(options.speed);\n  // Codex P2 (PR #732 follow-up): the default sleeper now uses\n  // `sleepAbortable` which REJECTS with `AbortError` on signal abort\n  // (rather than resolving silently). The replay loop catches the\n  // AbortError and exits cleanly. Custom `sleep` implementations are\n  // responsible for their own abort wiring; if they reject with an\n  // AbortError-shaped error the loop will treat it as a clean exit.\n  const sleep =\n    options.sleep ?? ((ms: number) => sleepAbortable(ms, options.signal));\n  const manageCursor = options.manageCursor ?? true;\n  const nowFn =\n    options.now ??\n    ((snapshot: ConsoleStateSnapshot) => {\n      const ms = Date.parse(snapshot.capturedAt);\n      return Number.isFinite(ms) ? ms : Date.now();\n    });\n\n  const stream = createReadStream(filePath, { encoding: \"utf-8\" });\n  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });\n\n  let framesRendered = 0;\n  let framesSkipped = 0;\n  let lastSnapshot: ConsoleStateSnapshot | null = null;\n  let prevCapturedMs: number | null = null;\n\n  if (manageCursor) safeWrite(output, ANSI_HIDE_CURSOR);\n\n  try {\n    for await (const rawLine of rl) {\n      if (options.signal?.aborted) break;\n      const line = rawLine.trim();\n      if (line.length === 0) continue;\n      const snapshot = parseSnapshotLine(line);\n      if (snapshot === null) {\n        framesSkipped += 1;\n        continue;\n      }\n\n      // Compute the inter-frame delay from the captured timestamps.\n      // The first frame paints immediately; subsequent frames wait\n      // `(this.capturedAt - prev.capturedAt) / speed`.\n      const capturedMs = Date.parse(snapshot.capturedAt);\n      let waitMs = 0;\n      if (prevCapturedMs !== null && Number.isFinite(capturedMs)) {\n        const rawDelta = capturedMs - prevCapturedMs;\n        waitMs = computeReplayDelay(rawDelta, speed);\n      } else if (prevCapturedMs !== null) {\n        // No usable timestamp on this frame — fall back to the\n        // default refresh interval (also speed-adjusted).\n        waitMs = computeReplayDelay(DEFAULT_REPLAY_DELAY_MS, speed);\n      }\n      if (waitMs > 0) {\n        try {\n          await sleep(waitMs);\n        } catch (err) {\n          // Codex P2 (PR #732 follow-up): `sleepAbortable` rejects\n          // with AbortError when SIGINT fires mid-sleep. Treat any\n          // AbortError-shaped rejection as a clean early exit so\n          // Ctrl-C does not have to wait for the current `setTimeout`\n          // to elapse. Re-throw any other error so genuine bugs\n          // surface.\n          if (isAbortError(err) || options.signal?.aborted) break;\n          throw err;\n        }\n        if (options.signal?.aborted) break;\n      }\n\n      let frame: string;\n      try {\n        frame = renderFrame({\n          snapshot,\n          renderError: null,\n          now: () => nowFn(snapshot, framesRendered),\n        });\n      } catch (err) {\n        // Mirror the live loop's renderer-failure recovery: emit a\n        // minimal error frame and keep replaying.\n        frame = `remnic console replay: render failed: ${describeError(err)}\\n`;\n      }\n      safeWrite(output, ANSI_CLEAR_HOME);\n      safeWrite(output, frame);\n\n      framesRendered += 1;\n      lastSnapshot = snapshot;\n      if (Number.isFinite(capturedMs)) prevCapturedMs = capturedMs;\n    }\n  } finally {\n    rl.close();\n    stream.close();\n    if (manageCursor) safeWrite(output, ANSI_SHOW_CURSOR);\n  }\n\n  return { framesRendered, framesSkipped, lastSnapshot };\n}\n\n/**\n * Parse a single JSONL line into a `ConsoleStateSnapshot`. Returns\n * null for malformed lines so the replay loop can keep going. We\n * intentionally do NOT validate every nested field — the renderer is\n * already defensive about missing fields and the trace file format\n * is best-effort.\n */\nexport function parseSnapshotLine(line: string): ConsoleStateSnapshot | null {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(line);\n  } catch {\n    return null;\n  }\n  // Common Gotcha #18: JSON.parse('null') succeeds but null is not a\n  // valid snapshot. Always check the result type.\n  if (typeof parsed !== \"object\" || parsed === null || Array.isArray(parsed)) {\n    return null;\n  }\n  // Best-effort cast: the renderer is tolerant of missing fields.\n  return parsed as ConsoleStateSnapshot;\n}\n\n/**\n * Compute the speed-adjusted, clamped inter-frame delay. Exposed for\n * tests so we can assert the speed math without a real timer.\n *\n * - `rawDeltaMs` is the captured-time difference between two frames\n *   (may be negative if the trace went back in time — clamped to 0).\n * - `speed` must be a positive finite number OR `Infinity` (treated\n *   as \"no delay\"). Non-positive / NaN values are normalized to 1\n *   upstream so this function never sees them.\n */\nexport function computeReplayDelay(rawDeltaMs: number, speed: number): number {\n  if (!Number.isFinite(rawDeltaMs)) return 0;\n  if (rawDeltaMs <= 0) return 0;\n  if (!Number.isFinite(speed)) return 0; // Infinity → no delay.\n  const adjusted = rawDeltaMs / speed;\n  if (!Number.isFinite(adjusted)) return 0;\n  if (adjusted <= MIN_REPLAY_DELAY_MS) return MIN_REPLAY_DELAY_MS;\n  if (adjusted > MAX_REPLAY_DELAY_MS) return MAX_REPLAY_DELAY_MS;\n  return adjusted;\n}\n\n/**\n * Coerce a user-provided `--speed` value into a valid positive\n * multiplier. Common Gotchas #28 / #36: CLI values arrive as strings,\n * and `\"false\"` / `\"0\"` are truthy. Always convert + validate at the\n * input boundary. Throws on invalid input so the CLI surfaces a\n * helpful error message instead of silently defaulting (Common\n * Gotcha #51).\n */\nexport function parseSpeedFlag(raw: unknown): number {\n  if (raw === undefined || raw === null) return 1;\n  const num = typeof raw === \"number\" ? raw : Number(raw);\n  if (!Number.isFinite(num) && num !== Infinity) {\n    throw new Error(\n      `invalid --speed value: ${JSON.stringify(raw)} (must be a positive number)`,\n    );\n  }\n  if (num <= 0) {\n    throw new Error(\n      `invalid --speed value: ${JSON.stringify(raw)} (must be > 0)`,\n    );\n  }\n  return num;\n}\n\nfunction normalizeSpeed(speed: number | undefined): number {\n  if (speed === undefined) return 1;\n  if (!Number.isFinite(speed) && speed !== Infinity) return 1;\n  if (speed <= 0) return 1;\n  return speed;\n}\n\n/**\n * Abortable sleep used by `replayTrace` between frames.\n *\n * Codex P2 (PR #732): unlike a plain `setTimeout` wrapper, this\n * variant REJECTS with `AbortError` when `signal` fires (or is\n * already aborted on entry). That gives callers a way to\n * *distinguish* timer-expiry from signal-driven early exit, instead\n * of silently resolving on both. The replay loop catches the\n * `AbortError` and exits cleanly so Ctrl-C does not have to wait for\n * the current inter-frame `setTimeout` (capped at 60s) to elapse.\n *\n * Resolves only on timer expiry. Rejects with `AbortError` (DOMException-\n * shaped: `name === \"AbortError\"`) on abort. Exported so callers in\n * tests and adjacent modules can reuse the same primitive.\n */\nexport function sleepAbortable(\n  ms: number,\n  signal?: AbortSignal,\n): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(makeAbortError());\n      return;\n    }\n    const timer = setTimeout(() => {\n      if (signal && onAbort) signal.removeEventListener(\"abort\", onAbort);\n      resolve();\n    }, ms);\n    let onAbort: (() => void) | null = null;\n    if (signal) {\n      onAbort = () => {\n        clearTimeout(timer);\n        reject(makeAbortError());\n      };\n      signal.addEventListener(\"abort\", onAbort, { once: true });\n    }\n  });\n}\n\n/**\n * Construct an `AbortError`-shaped error. Prefers the standard\n * `DOMException(\"...\", \"AbortError\")` when available (Node 18+);\n * falls back to a plain Error with `name = \"AbortError\"` for\n * environments without `DOMException`.\n */\nfunction makeAbortError(): Error {\n  if (typeof DOMException !== \"undefined\") {\n    return new DOMException(\"aborted\", \"AbortError\");\n  }\n  const err = new Error(\"aborted\");\n  err.name = \"AbortError\";\n  return err;\n}\n\n/**\n * Detect an AbortError-shaped rejection. Matches both\n * `DOMException(\"...\", \"AbortError\")` and plain `Error` with\n * `name === \"AbortError\"`. Exported for tests.\n */\nexport function isAbortError(err: unknown): boolean {\n  return (\n    typeof err === \"object\" &&\n    err !== null &&\n    \"name\" in err &&\n    (err as { name?: unknown }).name === \"AbortError\"\n  );\n}\n\nexport interface FlushWithTimeoutResult {\n  /** True if the flush completed before the deadline. */\n  flushed: boolean;\n  /** True if the deadline won. */\n  timedOut: boolean;\n  /** Error from the flush, if any. */\n  error: unknown;\n}\n\n/**\n * Bound a recorder flush against a wall-clock deadline (Codex P1, PR\n * #732 follow-up).\n *\n * The CLI shutdown path awaits `recorder.close()`. On a wedged\n * network-backed filesystem that drain can block indefinitely. This\n * helper races the drain against `timeoutMs` and returns a structured\n * result so the caller can decide whether to log a warning, retry, or\n * proceed silently. Returning a structured result (rather than\n * throwing) keeps shutdown ordering deterministic — the caller must\n * always reach the next teardown step.\n *\n * Errors raised by the flush are captured in `result.error` rather\n * than re-thrown.\n *\n * The `flush` factory receives an `AbortSignal` that fires when the\n * timeout wins the race. Callers should forward the signal into\n * whatever I/O the flush performs so the underlying operation is\n * actually cancelled rather than just orphaned. The signal is fired\n * exactly once, immediately after the timeout sentinel wins. The flush\n * promise is still awaited in the background; any subsequent error is\n * silently discarded (it was already abandoned by the caller).\n */\nexport async function flushWithTimeout(\n  flush: (signal: AbortSignal) => Promise<void>,\n  timeoutMs: number,\n): Promise<FlushWithTimeoutResult> {\n  const TIMEOUT_SENTINEL = Symbol(\"flush-timeout\");\n  let error: unknown = null;\n  let timeoutHandle: ReturnType<typeof setTimeout> | null = null;\n  // Codex P1 (PR #732 round 5): give the flush an AbortSignal so the\n  // underlying close() can stop holding resources when the timeout\n  // wins. Previously the close kept running silently after the race\n  // resolved — the AbortController lets callers wire cancellation into\n  // their I/O path (e.g., by aborting a stream or write chain) instead\n  // of merely abandoning the orphaned promise.\n  const ac = new AbortController();\n  const flushPromise = flush(ac.signal).then(\n    () => undefined,\n    (err) => {\n      error = err;\n      // Resolve so the race winner is \"flush\" — the caller inspects\n      // `result.error` to decide what to do.\n      return undefined;\n    },\n  );\n  const timeoutPromise = new Promise<symbol>((resolve) => {\n    timeoutHandle = setTimeout(() => resolve(TIMEOUT_SENTINEL), timeoutMs);\n    // Codex P1 (PR #732): unref the fallback timer so it does not\n    // hold the event loop open on its own. Belt-and-suspenders with\n    // the `clearTimeout` in the `finally` below: even if a future\n    // refactor accidentally drops the clear, an unref'd timer will\n    // not prevent process exit once the flush has resolved.\n    if (typeof timeoutHandle.unref === \"function\") {\n      timeoutHandle.unref();\n    }\n  });\n  try {\n    const winner = await Promise.race<symbol | void>([\n      flushPromise,\n      timeoutPromise,\n    ]);\n    if (winner === TIMEOUT_SENTINEL) {\n      // Fire the abort signal so the flush's underlying I/O can\n      // release its resources rather than staying open indefinitely.\n      ac.abort();\n      return { flushed: false, timedOut: true, error: null };\n    }\n    return { flushed: true, timedOut: false, error };\n  } finally {\n    // Codex P1 (PR #732): clear the fallback timer when the flush\n    // wins the race. Without this, Node keeps the ref'd timeout\n    // handle alive for the full `timeoutMs` and delays process exit\n    // by that interval on EVERY normal shutdown — turning a\n    // safety-net into a consistent user-visible hang.\n    if (timeoutHandle !== null) {\n      clearTimeout(timeoutHandle);\n    }\n  }\n}\n\nfunction safeWrite(output: Writable, chunk: string): void {\n  try {\n    output.write(chunk);\n  } catch {\n    // ignore — best effort\n  }\n}\n\nfunction describeError(err: unknown): string {\n  if (err instanceof Error) return err.message;\n  try {\n    return String(err);\n  } catch {\n    return \"unknown error\";\n  }\n}\n"],"mappings":"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","names":[]}