@volter/supercode-interchange 0.1.21 → 0.1.22

package/discovery.mjs

@@ -10,7 +10,7 @@ export async function enrichDescriptor(query, descriptor, { codexTopics, metrics
   const row = { ...descriptor };
   const take = async (read) => {
     try { return await read(); }
-    catch (error) { previewFailure?.(row.locator, error); return []; }
+    catch (error) { if (metrics) metrics.preview_failures = (metrics.preview_failures ?? 0) + 1; previewFailure?.(row.locator, error); return []; }
   };
   if (query.include_topic_candidates) {
     const history = row.locator.harness === 'codex' ? codexTopics?.get(row.locator.session_id) : null;
@@ -30,8 +30,19 @@ export async function enrichDescriptor(query, descriptor, { codexTopics, metrics
 export const readsPreviews = (query) => query.include_latest_candidates !== false || Boolean(query.include_topic_candidates);
 
 export async function enrichIndexPage(query, rows, options) {
-  const result = [];
-  for (const row of rows) result.push(await enrichDescriptor(query, row, options));
+  // A page used to await every open/read/stat/close before starting the next row. Keep a small number of
+  // independent reads in flight, preserve row order and retain every fingerprint/failure check. Never fan out
+  // with Promise.all(rows): a whole-index request can contain thousands of transcripts and expanded tails.
+  const result = new Array(rows.length);
+  let next = 0;
+  const read = async () => {
+    while (next < rows.length) {
+      const at = next++;
+      result[at] = await enrichDescriptor(query, rows[at], options);
+    }
+  };
+  const finished = await Promise.allSettled(Array.from({ length: Math.min(4, rows.length) }, read));
+  for (const worker of finished) if (worker.status === 'rejected') throw worker.reason;
   return result;
 }
 
@@ -46,9 +57,10 @@ export function namesWholeSessionId(query) {
  * title supplier chooses one id by source mtime, before applying the other
  * query filters, as native claude_session_named does. Neither is caller proof. */
 export async function discoverFromIndex(query, descriptors, options = {}) {
+  const step = options.step ?? ((_name, work) => work());
   const raw = [...descriptors];
-  if (query.search_previews) return previewPage(query, raw, options);
-  const page = projectMetadataPage(query, raw, options);
+  if (query.search_previews) return step('preview search', () => previewPage(query, raw, options));
+  const page = await step('metadata projection', () => projectMetadataPage(query, raw, options));
   const name = queryName(query);
   if (query.cursor == null && name) {
     const selected = query.harnesses;
@@ -78,7 +90,7 @@ export async function discoverFromIndex(query, descriptors, options = {}) {
   }
   // Keep the native receipt from projection: its counts precede the exact-name
   // post-filter and late-name fallback. Do not silently rewrite that contract.
-  page.sessions = await enrichIndexPage(query, page.sessions, options);
+  page.sessions = await step('preview reads', () => enrichIndexPage(query, page.sessions, options));
   return page;
 }
 

package/index.d.ts

@@ -108,6 +108,8 @@ export interface DiscoveryEnrichmentOptions extends MetadataProjectionOptions {
   previewFailure?: (locator: SessionLocator, error: Error) => void;
   liveClaudeName?: (name: string) => Promise<{ id: string; name: string } | null>;
   lateClaudeName?: (name: string) => Promise<string | null>;
+  /** Optional request-local stage timing; it must preserve the work's value and errors. */
+  step?: <T>(name: string, work: () => T | Promise<T>) => T | Promise<T>;
 }
 export function enrichDescriptor(query: DiscoveryQuery, descriptor: SessionDescriptor, options?: DiscoveryEnrichmentOptions): Promise<SessionDescriptor>;
 export function readsPreviews(query: DiscoveryQuery): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-interchange",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "type": "module",
   "description": "Read-only harness metadata, transcript codecs and session projections for Supercode",
   "license": "MIT OR Apache-2.0",

package/previews.mjs

@@ -66,6 +66,30 @@ function codexMessage(native) {
 
 function parseLine(text) { try { return parseNativeJson(text); } catch { return null; } }
 
+// Walk boundaries only as far as the eight candidates need. Splitting a validated 512 KiB/4 MiB window built
+// an array of every progress/tool line for each returned session, even when its newest eight messages came first.
+function* linesIn(text, latest) {
+  if (!text.length) return;
+  const limit = text.endsWith('\n') ? text.length - 1 : text.length;
+  if (latest) {
+    let end = limit;
+    for (;;) {
+      const newline = end === 0 ? -1 : text.lastIndexOf('\n', end - 1);
+      yield text.slice(newline + 1, end);
+      if (newline < 0) return;
+      end = newline;
+    }
+  } else {
+    let from = 0;
+    for (;;) {
+      const newline = text.indexOf('\n', from);
+      if (newline < 0 || newline >= limit) { yield text.slice(from, limit); return; }
+      yield text.slice(from, newline);
+      from = newline + 1;
+    }
+  }
+}
+
 function codexCandidates(lines, latest) {
   const candidates = [];
   let pending = null;
@@ -90,9 +114,7 @@ function candidatesIn(bytes, harness, latest) {
   // Validate the entire window before selecting eight records, matching the
   // native String::from_utf8 refusal even for unused later preview bytes.
   const text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
-  const lines = text.split('\n');
-  if (lines.at(-1) === '') lines.pop();
-  if (latest) lines.reverse();
+  const lines = linesIn(text, latest);
   if (harness === 'codex') return codexCandidates(lines, latest);
   const candidates = [];
   for (const line of lines) {