@yaklabs-ai/plugin-sdk 0.15.3 → 0.26.3

package/dist/transcript-review.js

@@ -533,43 +533,98 @@ function createTranscriptReview(options = {}) {
     }
     starts.sort((left, right) => left.boundary - right.boundary);
     const runStarts = [...finalRuns.values()].map((run) => ({ runId: run.runId, boundary: run.boundary })).sort((left, right) => left.boundary - right.boundary);
+    const runEndAt = Array.from({ length: runStarts.length });
+    for (let at = runStarts.length - 1; at >= 0; at -= 1) {
+      const next = runStarts[at + 1];
+      runEndAt[at] = next === void 0 ? endPosition : next.boundary > runStarts[at].boundary ? next.boundary : runEndAt[at + 1];
+    }
+    const runStartIndex = /* @__PURE__ */ new Map();
+    runStarts.forEach((run, at) => runStartIndex.set(run.runId, at));
+    const lastProseBefore = [];
+    let lastProse;
+    for (const record of records) {
+      lastProseBefore.push(lastProse);
+      if (record.hasProse)
+        lastProse = record.position;
+    }
     const previousProse = (before) => {
-      let index = byPosition.get(before);
-      if (index === void 0)
+      const index = byPosition.get(before);
+      return index === void 0 ? void 0 : lastProseBefore[index];
+    };
+    const spanIndexAt = (position) => {
+      if (position >= endPosition)
         return void 0;
-      for (index -= 1; index >= 0; index -= 1) {
-        if (records[index].hasProse)
-          return records[index].position;
+      let low = 0;
+      let high = starts.length - 1;
+      let found;
+      while (low <= high) {
+        const middle = low + high >> 1;
+        if (starts[middle].boundary <= position) {
+          found = middle;
+          low = middle + 1;
+        } else {
+          high = middle - 1;
+        }
       }
-      return void 0;
+      return found;
+    };
+    const ownRunsOf = starts.map(() => ({
+      ids: [],
+      seen: /* @__PURE__ */ new Set()
+    }));
+    const addOwnRun = (span, runId) => {
+      const own = ownRunsOf[span];
+      if (own.seen.has(runId))
+        return;
+      own.seen.add(runId);
+      own.ids.push(runId);
+    };
+    for (const run of runStarts) {
+      const started = finalRuns.get(run.runId).startedPosition;
+      if (started === void 0)
+        continue;
+      const span = spanIndexAt(started);
+      if (span !== void 0)
+        addOwnRun(span, run.runId);
+    }
+    const joinedOf = starts.map(() => []);
+    for (const input of inputs) {
+      if (input.runId === void 0)
+        continue;
+      const span = spanIndexAt(input.position);
+      if (span === void 0)
+        continue;
+      addOwnRun(span, input.runId);
+      if (input.human && !input.opensRun)
+        joinedOf[span].push(input);
+    }
+    const firstInputAtOrAfter = (position) => {
+      let low = 0;
+      let high = inputs.length;
+      while (low < high) {
+        const middle = low + high >> 1;
+        if (inputs[middle].position < position)
+          low = middle + 1;
+        else
+          high = middle;
+      }
+      return low;
     };
     const spans = starts.map((start, index) => {
       const next = starts[index + 1];
       const end = next?.boundary ?? endPosition;
       const closingEnd = next?.opener !== void 0 ? Math.max(end, next.opener.position + 1) : end;
-      const ownRuns = [];
+      const ownRuns = ownRunsOf[index].ids;
       const closingRuns = [];
-      for (const run of runStarts) {
-        const started = finalRuns.get(run.runId).startedPosition;
-        if (started !== void 0 && started >= start.boundary && started < end) {
-          if (!ownRuns.includes(run.runId))
-            ownRuns.push(run.runId);
-        }
-      }
-      const joined = [];
-      for (const input of inputs) {
-        if (input.runId === void 0)
-          continue;
-        if (input.position >= start.boundary && input.position < end) {
-          if (!ownRuns.includes(input.runId))
-            ownRuns.push(input.runId);
-          if (input.human && !input.opensRun)
-            joined.push(input);
-        } else if (input.position >= end && input.position < closingEnd) {
-          if (!closingRuns.includes(input.runId))
-            closingRuns.push(input.runId);
+      const closingSeen = /* @__PURE__ */ new Set();
+      for (let at = firstInputAtOrAfter(end); at < inputs.length && inputs[at].position < closingEnd; at += 1) {
+        const runId = inputs[at].runId;
+        if (runId !== void 0 && !closingSeen.has(runId)) {
+          closingSeen.add(runId);
+          closingRuns.push(runId);
         }
       }
+      const joined = joinedOf[index];
       ownRuns.sort((left, right) => finalRuns.get(left).boundary - finalRuns.get(right).boundary);
       const close = next !== void 0 ? next.opener !== void 0 ? "next-opener" : "next-opener-unresolved" : cutAt !== void 0 ? "time-bound" : "end-of-store";
       const previousAnswer = previousProse(start.boundary);
@@ -626,12 +681,30 @@ function createTranscriptReview(options = {}) {
       },
       spanAt: (position) => position < endPosition ? lastAtOrBefore(spans, position) : void 0,
       runExtent: (runId) => {
-        const run = finalRuns.get(runId);
-        if (run === void 0)
+        const at = runStartIndex.get(runId);
+        return at === void 0 ? void 0 : { start: runStarts[at].boundary, end: runEndAt[at] };
+      },
+      runAt: (position) => {
+        let low = 0;
+        let high = runStarts.length - 1;
+        let found;
+        while (low <= high) {
+          const middle = low + high >> 1;
+          if (runStarts[middle].boundary <= position) {
+            found = middle;
+            low = middle + 1;
+          } else {
+            high = middle - 1;
+          }
+        }
+        if (found === void 0)
+          return void 0;
+        const start = runStarts[found].boundary;
+        while (found > 0 && runStarts[found - 1].boundary === start)
+          found -= 1;
+        if (position >= runEndAt[found])
           return void 0;
-        const at = runStarts.findIndex((candidate) => candidate.runId === runId);
-        const next = runStarts.slice(at + 1).find((candidate) => candidate.boundary > run.boundary);
-        return { start: run.boundary, end: next?.boundary ?? endPosition };
+        return { runId: runStarts[found].runId, start, end: runEndAt[found] };
       },
       inputById: (inputId) => inputById.get(inputId),
       attemptAt: (position, block) => {

package/dist/transcript.d.ts

@@ -15,16 +15,16 @@ export declare const ATTACHMENTS_CUSTOM_TYPE = "attachments";
 export declare function branchEntryIds(entries: readonly TranscriptTreeEntryLike[]): ReadonlySet<string>;
 
 /**
- * Every `type: "custom"` entry of one `customType`, oldest→newest, with every
+ * Every `type: "custom"` entry of one `customType`, oldest->newest, with every
  * field ({@link TranscriptSourceEntryLike}'s id/timestamp/tree links plus the
- * entry's own `data`) preserved unchanged — `data` is returned exactly as it
+ * entry's own `data`) preserved unchanged - `data` is returned exactly as it
  * arrived, opaque and unvalidated, never coerced toward a schema this module
  * cannot know.
  *
  * `options.branch` is required, deliberately: `"active"` filters to
  * {@link branchEntryIds}; `"all"` returns every matching entry in the flat
  * log, rewind-abandoned or not. A silent default would let a caller reach
- * for whichever one it did not mean to — pick `"all"` only when the caller
+ * for whichever one it did not mean to - pick `"all"` only when the caller
  * itself needs to reason about abandoned entries (an audit, a recovery
  * tool); an ordinary reader states `"active"` explicitly.
  */
@@ -53,7 +53,7 @@ declare type ProducedResourceAction = "created" | "updated";
 
 /** One URI a tool call created or updated as a side effect. */
 declare interface ProducedResourceDeclaration {
-    /** A `scheme://…` URI or an absolute local file path, compared as an exact string. */
+    /** A `scheme://...` URI or an absolute local file path, compared as an exact string. */
     readonly uri: string;
     readonly action: ProducedResourceAction;
 }
@@ -92,7 +92,7 @@ export declare interface TranscriptEntryLike {
     readonly id: string;
     readonly type: string;
     readonly customType?: string;
-    /** Opaque. Never parsed or validated here — a feature's own schema owns that. */
+    /** Opaque. Never parsed or validated here - a feature's own schema owns that. */
     readonly data?: unknown;
 }
 
@@ -162,7 +162,9 @@ export declare interface TurnSegment {
  * nothing distinguishes a steer from a fresh request.
  *
  * `throughIndex` bounds the walk for a caller holding only a prefix; segments
- * are returned oldest first.
+ * are returned oldest first. A daemon reader that cannot hold the entry list
+ * looks the run up by run id instead (engine redesign 3.1,
+ * `docs/engine-redesign/decisions/2026-10-28-3.1-turn-definition.md`).
  */
 export declare function turnSegments(entries: readonly TurnBoundaryEntry[], throughIndex?: number): readonly TurnSegment[];