@tangle-network/agent-app 0.60.210 → 0.60.212

package/dist/turn-stream/core.d.ts

@@ -29,15 +29,22 @@ export declare function mintTurnStreamToken(channelName: string, secret: string,
 export declare function verifyTurnStreamToken(channelName: string, token: string, secret: string, now?: () => number): Promise<boolean>;
 /** Define the scope level for acquiring a turn lock within thread or workspace contexts */
 export type TurnLockScope = 'thread' | 'workspace';
-/** Channel for a thread-scoped lock. */
+/** Channel for a thread's viewer signals. */
 export declare function threadChannelKey(workspaceId: string, threadId: string): string;
 /** Channel for workspace signals and the workspace-scoped lock. */
 export declare function workspaceChannelKey(workspaceId: string): string;
-/** The channel a lock lives on: workspace-scope locks serialize every thread
- *  in the workspace (one shared sandbox), thread-scope locks serialize one
- *  thread (router lane). Same keying as the reference consumer, so a product
- *  swapping its fork for this package contends on identical instances. */
-export declare function turnLockChannelKey(workspaceId: string, threadId: string, scope: TurnLockScope): string;
+/** The channel a lock lives on: the workspace channel, for both scopes.
+ *  Workspace-scope locks serialize every thread in the workspace (one shared
+ *  sandbox) and thread-scope locks serialize one thread (router lane); they
+ *  stay independent because each has its own storage key
+ *  ({@link turnLockStorageKey}). A thread lock on its own channel created a
+ *  new Durable Object on every thread's first turn, 0.8-1.9 s inside Creative's
+ *  admission on staging (2026-10-20) against an object that already exists. */
+export declare function turnLockChannelKey(workspaceId: string, _threadId: string, _scope: TurnLockScope): string;
+/** The storage key a lock lives under inside its channel's instance: the
+ *  workspace-scope lock under `TURN_STREAM_STORAGE_KEYS.lock`, each thread's
+ *  lock under `TURN_STREAM_STORAGE_KEYS.threadLockPrefix` + its thread id. */
+export declare function turnLockStorageKey(scope: TurnLockScope, threadId: string): string;
 /** Channel for the optional Durable Object turn-event backend. */
 export declare function turnStorageChannelKey(turnId: string): string;
 /** Running-turn index for the optional Durable Object turn-event backend. */
@@ -147,6 +154,7 @@ export declare const TURN_STREAM_PATHS: {
  *  a product extending the DO must not collide with these. */
 export declare const TURN_STREAM_STORAGE_KEYS: {
     readonly lock: 'chatTurnLock';
+    readonly threadLockPrefix: 'chatTurnLock:thread:';
     readonly activeThreads: 'activeThreads';
     readonly turnStatus: 'turnStatus';
     readonly turnScope: 'turnScopeIndex';

package/dist/turn-stream/do.d.ts

@@ -120,11 +120,16 @@ export declare class TurnStreamDO {
     private handleBroadcast;
     private loadActiveThreads;
     private persistActiveThreads;
-    protected loadActiveLock(now?: number): Promise<DurableTurnLock | null>;
+    /** The live lock under `key` (default: the workspace-scope lock); an
+     *  expired one is deleted and reads as none. */
+    protected loadActiveLock(now?: number, key?: string): Promise<DurableTurnLock | null>;
     private releaseActiveLock;
     /** Park a release on the lock itself; {@link completeDeferredLockRelease}
      *  finishes it once the product's deferred condition settles. */
     private deferLockRelease;
+    /** Delete expired thread locks, so a thread whose release never arrived
+     *  leaves no row behind once its lock's TTL passes. */
+    private pruneExpiredThreadLocks;
     private handleLockAcquire;
     private handleLockRelease;
     private handleLockReleaseInterrupted;

package/dist/turn-stream/index.js

@@ -37,8 +37,11 @@ function threadChannelKey(workspaceId, threadId) {
 function workspaceChannelKey(workspaceId) {
   return workspaceId;
 }
-function turnLockChannelKey(workspaceId, threadId, scope) {
-  return scope === "workspace" ? workspaceChannelKey(workspaceId) : threadChannelKey(workspaceId, threadId);
+function turnLockChannelKey(workspaceId, _threadId, _scope) {
+  return workspaceChannelKey(workspaceId);
+}
+function turnLockStorageKey(scope, threadId) {
+  return scope === "workspace" ? TURN_STREAM_STORAGE_KEYS.lock : `${TURN_STREAM_STORAGE_KEYS.threadLockPrefix}${threadId}`;
 }
 function turnStorageChannelKey(turnId) {
   return `turn:${turnId}`;
@@ -107,6 +110,7 @@ var TURN_STREAM_PATHS = {
 };
 var TURN_STREAM_STORAGE_KEYS = {
   lock: "chatTurnLock",
+  threadLockPrefix: "chatTurnLock:thread:",
   activeThreads: "activeThreads",
   turnStatus: "turnStatus",
   turnScope: "turnScopeIndex",
@@ -130,6 +134,10 @@ async function jsonBody(request) {
   const body = await request.json().catch(() => null);
   return body && typeof body === "object" && !Array.isArray(body) ? body : null;
 }
+function lockStorageKeyOf(body) {
+  const threadId = stringValue(body?.threadId);
+  return body?.scope === "thread" && threadId ? turnLockStorageKey("thread", threadId) : TURN_STREAM_STORAGE_KEYS.lock;
+}
 var MAX_SCOPE_TURNS = 100;
 var TurnStreamDO = class {
   state;
@@ -195,7 +203,7 @@ var TurnStreamDO = class {
         case TURN_STREAM_PATHS.lockAcquire:
           return this.handleLockAcquire(request);
         case TURN_STREAM_PATHS.lockPeek:
-          return jsonResponse({ active: await this.loadActiveLock() });
+          return jsonResponse({ active: await this.loadActiveLock(Date.now(), lockStorageKeyOf(await jsonBody(request))) });
         case TURN_STREAM_PATHS.lockRelease:
           return this.handleLockRelease(request);
         case TURN_STREAM_PATHS.lockReleaseInterrupted:
@@ -236,10 +244,14 @@ var TurnStreamDO = class {
   /** Complete a release parked by {@link shouldDeferLockRelease}. A subclass
    *  calls this when its deferred condition settles. */
   async completeDeferredLockRelease(executionId) {
-    const active = await this.loadActiveLock();
-    if (!active?.releasePending || active.executionId !== executionId) return false;
-    await this.state.storage.delete(TURN_STREAM_STORAGE_KEYS.lock);
-    return true;
+    const threadLocks = await this.state.storage.list({ prefix: TURN_STREAM_STORAGE_KEYS.threadLockPrefix });
+    for (const key of [TURN_STREAM_STORAGE_KEYS.lock, ...threadLocks.keys()]) {
+      const active = await this.loadActiveLock(Date.now(), key);
+      if (!active?.releasePending || active.executionId !== executionId) continue;
+      await this.state.storage.delete(key);
+      return true;
+    }
+    return false;
   }
   /** Extra product state replayed to a socket during its `sync`, after the
    *  base replay for its scope (e.g. an in-flight persistence status card).
@@ -355,27 +367,37 @@ var TurnStreamDO = class {
     await this.state.storage.put(TURN_STREAM_STORAGE_KEYS.activeThreads, Object.fromEntries(map));
   }
   // ── chat-turn lock ────────────────────────────────────────────────────────
-  async loadActiveLock(now = Date.now()) {
-    const stored = await this.state.storage.get(TURN_STREAM_STORAGE_KEYS.lock);
+  /** The live lock under `key` (default: the workspace-scope lock); an
+   *  expired one is deleted and reads as none. */
+  async loadActiveLock(now = Date.now(), key = TURN_STREAM_STORAGE_KEYS.lock) {
+    const stored = await this.state.storage.get(key);
     const lock = activeTurnLock(stored, now);
-    if (stored && !lock) await this.state.storage.delete(TURN_STREAM_STORAGE_KEYS.lock);
+    if (stored && !lock) await this.state.storage.delete(key);
     return lock;
   }
-  async releaseActiveLock(input) {
-    const active = await this.loadActiveLock();
+  async releaseActiveLock(key, input) {
+    const active = await this.loadActiveLock(Date.now(), key);
     if (!active || !turnLockMatchesRelease(active, input)) return false;
-    await this.state.storage.delete(TURN_STREAM_STORAGE_KEYS.lock);
+    await this.state.storage.delete(key);
     return true;
   }
   /** Park a release on the lock itself; {@link completeDeferredLockRelease}
    *  finishes it once the product's deferred condition settles. */
-  async deferLockRelease(input) {
-    const active = await this.loadActiveLock();
+  async deferLockRelease(key, input) {
+    const active = await this.loadActiveLock(Date.now(), key);
     if (!active || !turnLockMatchesRelease(active, input)) return false;
     if (active.releasePending) return true;
-    await this.state.storage.put(TURN_STREAM_STORAGE_KEYS.lock, { ...active, releasePending: true });
+    await this.state.storage.put(key, { ...active, releasePending: true });
     return true;
   }
+  /** Delete expired thread locks, so a thread whose release never arrived
+   *  leaves no row behind once its lock's TTL passes. */
+  async pruneExpiredThreadLocks(now) {
+    const threadLocks = await this.state.storage.list({ prefix: TURN_STREAM_STORAGE_KEYS.threadLockPrefix });
+    for (const [key, stored] of threadLocks) {
+      if (!activeTurnLock(stored, now)) await this.state.storage.delete(key);
+    }
+  }
   async handleLockAcquire(request) {
     const body = await jsonBody(request);
     const workspaceId = stringValue(body?.workspaceId);
@@ -387,16 +409,19 @@ var TurnStreamDO = class {
     if (!workspaceId || !threadId || !executionId || !lockId || !scope) {
       return jsonResponse({ error: "Missing workspaceId, threadId, executionId, lockId, or scope" }, 400);
     }
-    const active = await this.loadActiveLock();
+    const key = turnLockStorageKey(scope, threadId);
+    const now = Date.now();
+    const active = await this.loadActiveLock(now, key);
     if (active) {
       return jsonResponse({ acquired: false, active }, 409);
     }
+    if (scope === "thread") await this.pruneExpiredThreadLocks(now);
     const lock = createTurnLock(
       { workspaceId, threadId, scope, executionId, lockId, ...turnId ? { turnId } : {} },
-      Date.now(),
+      now,
       this.options.lockTtlMs ?? TURN_LOCK_TTL_MS
     );
-    await this.state.storage.put(TURN_STREAM_STORAGE_KEYS.lock, lock);
+    await this.state.storage.put(key, lock);
     return jsonResponse({ acquired: true, lock });
   }
   async handleLockRelease(request) {
@@ -406,11 +431,12 @@ var TurnStreamDO = class {
     if (!executionId || !lockId) {
       return jsonResponse({ error: "Missing executionId or lockId" }, 400);
     }
+    const key = lockStorageKeyOf(body);
     if (await this.shouldDeferLockRelease(executionId)) {
-      const deferred = await this.deferLockRelease({ executionId, lockId });
+      const deferred = await this.deferLockRelease(key, { executionId, lockId });
       return jsonResponse({ released: false, deferred });
     }
-    const released = await this.releaseActiveLock({ executionId, lockId });
+    const released = await this.releaseActiveLock(key, { executionId, lockId });
     return jsonResponse({ released });
   }
   async handleLockReleaseInterrupted(request) {
@@ -421,7 +447,8 @@ var TurnStreamDO = class {
       return jsonResponse({ error: "Missing threadId or interruptedAt" }, 400);
     }
     const turnId = stringValue(body?.turnId) ?? void 0;
-    const active = await this.loadActiveLock();
+    const key = lockStorageKeyOf(body);
+    const active = await this.loadActiveLock(Date.now(), key);
     if (!active) return jsonResponse({ released: false });
     if (await this.shouldDeferLockRelease(active.executionId)) {
       return jsonResponse({ released: false });
@@ -429,7 +456,7 @@ var TurnStreamDO = class {
     if (!interruptedReleaseApplies(active, { threadId, interruptedAt, ...turnId ? { turnId } : {} })) {
       return jsonResponse({ released: false });
     }
-    await this.state.storage.delete(TURN_STREAM_STORAGE_KEYS.lock);
+    await this.state.storage.delete(key);
     return jsonResponse({ released: true });
   }
   // ── durable turn-event storage (TurnEventStore backing) ───────────────────
@@ -594,7 +621,10 @@ async function acquireDurableTurnLock(namespace, input, auth) {
 }
 async function peekDurableTurnLock(namespace, input, auth) {
   const key = turnLockChannelKey(input.workspaceId, input.threadId, input.scope);
-  const result = await postJson(namespace, key, TURN_STREAM_PATHS.lockPeek, {}, auth);
+  const result = await postJson(namespace, key, TURN_STREAM_PATHS.lockPeek, {
+    scope: input.scope,
+    threadId: input.threadId
+  }, auth);
   if (result.status !== 200) throw new Error(`turn-stream lock peek failed with status ${result.status}`);
   return result.body.active ?? null;
 }
@@ -607,6 +637,7 @@ async function releaseInterruptedDurableTurnLock(namespace, input, auth) {
   for (const scope of scopes) {
     const key = turnLockChannelKey(input.workspaceId, input.threadId, scope);
     const result = await postJsonOk(namespace, key, TURN_STREAM_PATHS.lockReleaseInterrupted, {
+      scope,
       threadId: input.threadId,
       interruptedAt: input.interruptedAt,
       ...input.turnId ? { turnId: input.turnId } : {}
@@ -649,8 +680,8 @@ function defaultRefusalResponse(active, diagnostics) {
 }
 function createDurableTurnLock(options) {
   return {
-    // The thread channel is the one a thread's first turn creates; the
-    // workspace channel is shared by every thread and its broadcasts keep it up.
+    // Every lock lives on the workspace channel, so this wakes that object
+    // (evicted after idle) before the turn's acquire reaches it.
     async warm(target) {
       await peekDurableTurnLock(options.namespace, { workspaceId: target.tenantId, threadId: target.threadId, scope: "thread" }, options.auth);
     },
@@ -863,6 +894,7 @@ export {
   turnEventStorageKey,
   turnLockChannelKey,
   turnLockMatchesRelease,
+  turnLockStorageKey,
   turnStorageChannelKey,
   verifyTurnStreamToken,
   workspaceChannelKey