thinkpool-pair 0.7.364 → 0.7.366

package/dispatch-permission-cleanup.mjs

@@ -1,86 +1 @@
-// Durable cleanup for approvals that no longer have a live bridge promise behind
-// them. A row is human-resolvable only while its originating local intent is live.
-// When that intent is replaced, aborted, or restarted, cancel the exact pending
-// row through the normal authenticated RPC rather than leaving a non-executable
-// card/lifecycle blocker.
-
-const PENDING = new Set(['pending'])
-const SETTLED = new Set(['denied', 'idempotent_replay', 'already_resolved', 'stale_or_already_resolved', 'item_expired'])
-
-const safeString = (value) => typeof value === 'string' && value.length > 0
-
-export function pendingDurablePermissionItems (items, { bridgeId = null, currentBridgeId = null, terminalId = null, permissionIds = null, actionKinds = ['approval', 'dispatch'] } = {}) {
-  if ((bridgeId != null && !safeString(bridgeId)) || (currentBridgeId != null && !safeString(currentBridgeId)) ||
-      (terminalId != null && !safeString(terminalId)) || (terminalId == null && currentBridgeId == null)) return []
-  const requested = permissionIds == null ? null : new Set(permissionIds.filter(safeString))
-  const actions = new Set(actionKinds)
-  return (Array.isArray(items) ? items : []).filter((item) => {
-    const permissionId = item?.request_context?.permission_id
-    return PENDING.has(item?.status) && item?.item_kind === 'approval' && actions.has(item?.action_kind) &&
-      (!bridgeId || item?.bridge_authority_id === bridgeId) &&
-      (!currentBridgeId || item?.bridge_authority_id !== currentBridgeId) &&
-      (!terminalId || item?.local_authority_id === terminalId) &&
-      safeString(permissionId) && (!requested || requested.has(permissionId))
-  })
-}
-
-export function pendingDispatchItems (items, options = {}) {
-  return pendingDurablePermissionItems(items, { ...options, actionKinds: ['dispatch'] })
-}
-
-const rpc = async ({ fetchImpl, supabaseUrl, headers, name, body }) => {
-  const response = await fetchImpl(`${String(supabaseUrl).replace(/\/$/, '')}/rest/v1/rpc/${name}`, {
-    method: 'POST', headers, body: JSON.stringify(body),
-  })
-  if (!response?.ok) throw new Error(`${name}_failed`)
-  return response.json()
-}
-
-// Fetch through list_code_pair_controls so RLS applies to the bridge's current
-// room-member identity.  Never accept an id supplied by a public broadcast.
-export async function cancelDurablePermissions ({
-  fetchImpl = globalThis.fetch, supabaseUrl, anonKey, token, roomCode, bridgeId,
-  currentBridgeId = null, terminalId = null, permissionIds = null,
-  reason = 'permission_aborted', actionKinds = ['approval', 'dispatch'],
-} = {}) {
-  if (typeof fetchImpl !== 'function' || !safeString(supabaseUrl) || !safeString(anonKey) ||
-      !safeString(token) || !safeString(roomCode) || (bridgeId != null && !safeString(bridgeId)) ||
-      (currentBridgeId != null && !safeString(currentBridgeId)) ||
-      (terminalId != null && !safeString(terminalId)) || (terminalId == null && currentBridgeId == null)) {
-    return Object.freeze({ ok: false, code: 'cleanup_unavailable', canceled: 0 })
-  }
-  if (permissionIds != null && (!Array.isArray(permissionIds) || !permissionIds.length)) {
-    return Object.freeze({ ok: true, code: 'nothing_to_cancel', canceled: 0 })
-  }
-  const headers = { apikey: anonKey, Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' }
-  try {
-    const listed = await rpc({ fetchImpl, supabaseUrl, headers, name: 'list_code_pair_controls', body: {
-      p_session_code: String(roomCode).toUpperCase(), p_status: null, p_limit: 100,
-    } })
-    const candidates = pendingDurablePermissionItems(listed, { bridgeId, currentBridgeId, terminalId, permissionIds, actionKinds })
-    const outcomes = await Promise.all(candidates.map(async (item) => {
-      const result = await rpc({ fetchImpl, supabaseUrl, headers, name: 'resolve_code_pair_control', body: {
-        p_item_id: item.id,
-        p_expected_version: item.version,
-        p_decision: 'deny',
-        p_resolution_code: 'canceled',
-        p_resolution_payload: { decision: 'deny', reason },
-        // A restart receives a fresh bridge ID. The old row remains protected
-        // by its immutable authority binding, so resolve it with that exact
-        // value after the owner-authenticated RLS list—not a guessed current ID.
-        p_bridge_authority_id: item.bridge_authority_id,
-        p_local_authority_id: item.local_authority_id,
-        p_idempotency_key: `cancel-permission:${item.id}:${reason}`.slice(0, 160),
-      } })
-      return { id: item.id, code: result?.code || 'invalid_response', ok: Boolean(result?.ok) && SETTLED.has(result.code) }
-    }))
-    const canceled = outcomes.filter((outcome) => outcome.ok).length
-    return Object.freeze({ ok: canceled === outcomes.length, code: canceled === outcomes.length ? 'canceled' : 'cleanup_partial', canceled, outcomes: Object.freeze(outcomes) })
-  } catch {
-    return Object.freeze({ ok: false, code: 'cleanup_failed', canceled: 0 })
-  }
-}
-
-export function cancelDurableDispatchPermissions (options = {}) {
-  return cancelDurablePermissions({ ...options, actionKinds: ['dispatch'] })
-}
+const e=new Set(["pending"]),n=new Set(["denied","idempotent_replay","already_resolved","stale_or_already_resolved","item_expired"]),i=e=>"string"==typeof e&&e.length>0;export function pendingDurablePermissionItems(n,{bridgeId:r=null,currentBridgeId:t=null,terminalId:a=null,permissionIds:o=null,actionKinds:l=["approval","dispatch"]}={}){if(null!=r&&!i(r)||null!=t&&!i(t)||null!=a&&!i(a)||null==a&&null==t)return[];const s=null==o?null:new Set(o.filter(i)),d=new Set(l);return(Array.isArray(n)?n:[]).filter(n=>{const o=n?.request_context?.permission_id;return e.has(n?.status)&&"approval"===n?.item_kind&&d.has(n?.action_kind)&&(!r||n?.bridge_authority_id===r)&&(!t||n?.bridge_authority_id!==t)&&(!a||n?.local_authority_id===a)&&i(o)&&(!s||s.has(o))})}export function pendingDispatchItems(e,n={}){return pendingDurablePermissionItems(e,{...n,actionKinds:["dispatch"]})}const r=async({fetchImpl:e,supabaseUrl:n,headers:i,name:r,body:t})=>{const a=await e(`${String(n).replace(/\/$/,"")}/rest/v1/rpc/${r}`,{method:"POST",headers:i,body:JSON.stringify(t)});if(!a?.ok)throw new Error(`${r}_failed`);return a.json()};export async function cancelDurablePermissions({fetchImpl:e=globalThis.fetch,supabaseUrl:t,anonKey:a,token:o,roomCode:l,bridgeId:s,currentBridgeId:d=null,terminalId:c=null,permissionIds:p=null,reason:u="permission_aborted",actionKinds:_=["approval","dispatch"]}={}){if("function"!=typeof e||!i(t)||!i(a)||!i(o)||!i(l)||null!=s&&!i(s)||null!=d&&!i(d)||null!=c&&!i(c)||null==c&&null==d)return Object.freeze({ok:!1,code:"cleanup_unavailable",canceled:0});if(!(null==p||Array.isArray(p)&&p.length))return Object.freeze({ok:!0,code:"nothing_to_cancel",canceled:0});const h={apikey:a,Authorization:`Bearer ${o}`,"Content-Type":"application/json"};try{const i=pendingDurablePermissionItems(await r({fetchImpl:e,supabaseUrl:t,headers:h,name:"list_code_pair_controls",body:{p_session_code:String(l).toUpperCase(),p_status:null,p_limit:100}}),{bridgeId:s,currentBridgeId:d,terminalId:c,permissionIds:p,actionKinds:_}),a=await Promise.all(i.map(async i=>{const a=await r({fetchImpl:e,supabaseUrl:t,headers:h,name:"resolve_code_pair_control",body:{p_item_id:i.id,p_expected_version:i.version,p_decision:"deny",p_resolution_code:"canceled",p_resolution_payload:{decision:"deny",reason:u},p_bridge_authority_id:i.bridge_authority_id,p_local_authority_id:i.local_authority_id,p_idempotency_key:`cancel-permission:${i.id}:${u}`.slice(0,160)}});return{id:i.id,code:a?.code||"invalid_response",ok:Boolean(a?.ok)&&n.has(a.code)}})),o=a.filter(e=>e.ok).length;return Object.freeze({ok:o===a.length,code:o===a.length?"canceled":"cleanup_partial",canceled:o,outcomes:Object.freeze(a)})}catch{return Object.freeze({ok:!1,code:"cleanup_failed",canceled:0})}}export function cancelDurableDispatchPermissions(e={}){return cancelDurablePermissions({...e,actionKinds:["dispatch"]})}

package/edit-diff.mjs

@@ -1,136 +1 @@
-// Bridge-local diff primitives. Keep this module self-contained: the npm
-// package cannot import the web app's ../src tree.
-export const normalizeEditKind = (value) => {
-  const kind = typeof value === 'object' ? value?.type : value
-  if (kind === 'add' || kind === 'delete' || kind === 'rename') return kind
-  return 'update'
-}
-
-const splitLines = (value) => {
-  if (!value) return []
-  const lines = String(value).replace(/\r\n?/g, '\n').split('\n')
-  if (lines.at(-1) === '') lines.pop()
-  return lines
-}
-
-const fallbackDiff = (before, after) => {
-  let start = 0
-  while (start < before.length && start < after.length && before[start] === after[start]) start++
-  let oldEnd = before.length
-  let newEnd = after.length
-  while (oldEnd > start && newEnd > start && before[oldEnd - 1] === after[newEnd - 1]) {
-    oldEnd--
-    newEnd--
-  }
-  return [
-    ...before.slice(0, start).map((text) => ({ type: 'context', text })),
-    ...before.slice(start, oldEnd).map((text) => ({ type: 'remove', text })),
-    ...after.slice(start, newEnd).map((text) => ({ type: 'add', text })),
-    ...before.slice(oldEnd).map((text) => ({ type: 'context', text })),
-  ]
-}
-
-function lineDiff(before, after, maxDistance = 600) {
-  if (!before.length) return after.map((text) => ({ type: 'add', text }))
-  if (!after.length) return before.map((text) => ({ type: 'remove', text }))
-  const max = Math.min(before.length + after.length, maxDistance)
-  const frontier = new Map([[1, 0]])
-  const trace = []
-  for (let distance = 0; distance <= max; distance++) {
-    trace.push(new Map(frontier))
-    for (let diagonal = -distance; diagonal <= distance; diagonal += 2) {
-      const down = frontier.get(diagonal + 1) ?? -1
-      const right = frontier.get(diagonal - 1) ?? -1
-      let oldIndex = diagonal === -distance || (diagonal !== distance && right < down)
-        ? Math.max(0, down)
-        : Math.max(0, right + 1)
-      let newIndex = oldIndex - diagonal
-      while (oldIndex < before.length && newIndex < after.length && before[oldIndex] === after[newIndex]) {
-        oldIndex++
-        newIndex++
-      }
-      frontier.set(diagonal, oldIndex)
-      if (oldIndex < before.length || newIndex < after.length) continue
-
-      const operations = []
-      let x = before.length
-      let y = after.length
-      for (let d = distance; d >= 0; d--) {
-        const snapshot = trace[d]
-        const k = x - y
-        const snapshotDown = snapshot.get(k + 1) ?? -1
-        const snapshotRight = snapshot.get(k - 1) ?? -1
-        const previousK = k === -d || (k !== d && snapshotRight < snapshotDown) ? k + 1 : k - 1
-        const previousX = Math.max(0, snapshot.get(previousK) ?? 0)
-        const previousY = previousX - previousK
-        while (x > previousX && y > previousY) {
-          operations.push({ type: 'context', text: before[x - 1] })
-          x--
-          y--
-        }
-        if (d === 0) break
-        if (x === previousX) {
-          operations.push({ type: 'add', text: after[y - 1] })
-          y--
-        } else {
-          operations.push({ type: 'remove', text: before[x - 1] })
-          x--
-        }
-      }
-      return operations.reverse()
-    }
-  }
-  return fallbackDiff(before, after)
-}
-
-const previewLine = (type, text = '') => {
-  if (type === 'add') return `+${text}`
-  if (type === 'remove') return `-${text}`
-  if (type === 'context') return ` ${text}`
-  return `…${text}`
-}
-
-function compactOperations(operations, context = 2, maxLines = 80) {
-  const changed = []
-  operations.forEach((operation, index) => {
-    if (operation.type !== 'context') changed.push(index)
-  })
-  if (!changed.length) return []
-
-  const ranges = []
-  for (const index of changed) {
-    const start = Math.max(0, index - context)
-    const end = Math.min(operations.length, index + context + 1)
-    const previous = ranges.at(-1)
-    if (previous && start <= previous.end) previous.end = Math.max(previous.end, end)
-    else ranges.push({ start, end })
-  }
-
-  const compacted = []
-  ranges.forEach((range, index) => {
-    if (index > 0) compacted.push({ type: 'omit', text: `${range.start - ranges[index - 1].end} unchanged lines` })
-    compacted.push(...operations.slice(range.start, range.end))
-  })
-  if (compacted.length <= maxLines) return compacted
-
-  const head = Math.floor((maxLines - 1) / 2)
-  const tail = maxLines - head - 1
-  return [
-    ...compacted.slice(0, head),
-    { type: 'omit', text: `${compacted.length - head - tail} preview lines hidden` },
-    ...compacted.slice(-tail),
-  ]
-}
-
-export function summarizeTextDiff(oldText, newText, options = {}) {
-  const operations = lineDiff(splitLines(oldText), splitLines(newText), options.maxDistance)
-  const added = operations.reduce((total, operation) => total + (operation.type === 'add' ? 1 : 0), 0)
-  const removed = operations.reduce((total, operation) => total + (operation.type === 'remove' ? 1 : 0), 0)
-  const lines = compactOperations(operations, options.context ?? 2, options.maxLines ?? 80)
-  return {
-    added,
-    removed,
-    lines,
-    preview: lines.map((line) => previewLine(line.type, line.text)).join('\n'),
-  }
-}
+export const normalizeEditKind=t=>{const e="object"==typeof t?t?.type:t;return"add"===e||"delete"===e||"rename"===e?e:"update"};const t=t=>{if(!t)return[];const e=String(t).replace(/\r\n?/g,"\n").split("\n");return""===e.at(-1)&&e.pop(),e};export function summarizeTextDiff(e,n,r={}){const o=function(t,e,n=600){if(!t.length)return e.map(t=>({type:"add",text:t}));if(!e.length)return t.map(t=>({type:"remove",text:t}));const r=Math.min(t.length+e.length,n),o=new Map([[1,0]]),a=[];for(let n=0;n<=r;n++){a.push(new Map(o));for(let r=-n;r<=n;r+=2){const p=o.get(r+1)??-1,s=o.get(r-1)??-1;let c=r===-n||r!==n&&s<p?Math.max(0,p):Math.max(0,s+1),l=c-r;for(;c<t.length&&l<e.length&&t[c]===e[l];)c++,l++;if(o.set(r,c),c<t.length||l<e.length)continue;const h=[];let i=t.length,d=e.length;for(let r=n;r>=0;r--){const n=a[r],o=i-d,p=n.get(o+1)??-1,s=n.get(o-1)??-1,c=o===-r||o!==r&&s<p?o+1:o-1,l=Math.max(0,n.get(c)??0),u=l-c;for(;i>l&&d>u;)h.push({type:"context",text:t[i-1]}),i--,d--;if(0===r)break;i===l?(h.push({type:"add",text:e[d-1]}),d--):(h.push({type:"remove",text:t[i-1]}),i--)}return h.reverse()}}return((t,e)=>{let n=0;for(;n<t.length&&n<e.length&&t[n]===e[n];)n++;let r=t.length,o=e.length;for(;r>n&&o>n&&t[r-1]===e[o-1];)r--,o--;return[...t.slice(0,n).map(t=>({type:"context",text:t})),...t.slice(n,r).map(t=>({type:"remove",text:t})),...e.slice(n,o).map(t=>({type:"add",text:t})),...t.slice(r).map(t=>({type:"context",text:t}))]})(t,e)}(t(e),t(n),r.maxDistance),a=o.reduce((t,e)=>t+("add"===e.type?1:0),0),p=o.reduce((t,e)=>t+("remove"===e.type?1:0),0),s=function(t,e=2,n=80){const r=[];if(t.forEach((t,e)=>{"context"!==t.type&&r.push(e)}),!r.length)return[];const o=[];for(const n of r){const r=Math.max(0,n-e),a=Math.min(t.length,n+e+1),p=o.at(-1);p&&r<=p.end?p.end=Math.max(p.end,a):o.push({start:r,end:a})}const a=[];if(o.forEach((e,n)=>{n>0&&a.push({type:"omit",text:e.start-o[n-1].end+" unchanged lines"}),a.push(...t.slice(e.start,e.end))}),a.length<=n)return a;const p=Math.floor((n-1)/2),s=n-p-1;return[...a.slice(0,p),{type:"omit",text:a.length-p-s+" preview lines hidden"},...a.slice(-s)]}(o,r.context??2,r.maxLines??80);return{added:a,removed:p,lines:s,preview:s.map(t=>((t,e="")=>"add"===t?`+${e}`:"remove"===t?`-${e}`:"context"===t?` ${e}`:`…${e}`)(t.type,t.text)).join("\n")}}

package/error-recovery.mjs

@@ -1,50 +1 @@
-// A safe recovery envelope. It records a bounded decision; it never performs a
-// retry and therefore cannot alter native adapter transport behavior.
-
-import { isSecretFreeRoomPayload, runtimeSupportsCapability } from './runtime-contract.mjs'
-
-export const ERROR_RECOVERY_VERSION = 1
-export const MAX_RECOVERY_ATTEMPTS = 3
-const CODE = /^[a-z][a-z0-9_-]{0,79}$/
-const SAFE_REF = /^[A-Za-z0-9][A-Za-z0-9._:@-]{0,159}$/
-
-const policyFor = ({ runtime, capabilityId }) => runtimeSupportsCapability(runtime, capabilityId)
-  ? Object.freeze({ maxAttempts: MAX_RECOVERY_ATTEMPTS })
-  : Object.freeze({ maxAttempts: 1 })
-
-export function normalizeErrorRecovery({ runtime, capabilityId, code = 'runtime_error', retryable = false, attempt = 1, evidenceRefs = [] } = {}) {
-  const policy = policyFor({ runtime, capabilityId })
-  const safeAttempt = Math.max(1, Math.min(policy.maxAttempts, Number.isSafeInteger(attempt) ? attempt : 1))
-  const safeRefs = (Array.isArray(evidenceRefs) ? evidenceRefs : []).slice(0, 16)
-    .filter((ref) => ref && SAFE_REF.test(String(ref.type || '')) && SAFE_REF.test(String(ref.id || '')))
-    .map((ref) => ({ type: String(ref.type), id: String(ref.id) }))
-  const admitted = runtimeSupportsCapability(runtime, capabilityId) && CODE.test(String(code))
-  const canRetry = admitted && retryable === true && safeAttempt < policy.maxAttempts
-  const envelope = {
-    version: ERROR_RECOVERY_VERSION,
-    capabilityId: admitted ? capabilityId : 'unknown',
-    code: admitted ? String(code) : 'invalid_recovery_input',
-    retryable: canRetry,
-    attempt: safeAttempt,
-    maxAttempts: policy.maxAttempts,
-    next: canRetry ? 'retry' : (admitted && retryable === true ? 'ask_human' : 'stop'),
-    evidenceRefs: safeRefs,
-  }
-  return Object.freeze(isSecretFreeRoomPayload(envelope, 4096) ? envelope : {
-    version: ERROR_RECOVERY_VERSION, capabilityId: 'unknown', code: 'invalid_recovery_input', retryable: false,
-    attempt: 1, maxAttempts: 1, next: 'stop', evidenceRefs: [],
-  })
-}
-
-export function recoveryCodeEvent(input) {
-  const recovery = normalizeErrorRecovery(input)
-  return Object.freeze({
-    kind: recovery.next === 'ask_human' ? 'needs-input' : 'error',
-    subtype: 'bounded_recovery',
-    message: recovery.next === 'ask_human'
-      ? `Recovery attempt ${recovery.attempt}/${recovery.maxAttempts} is exhausted; human input is required.`
-      : `Recovery stopped safely (${recovery.code}).`,
-    recovery,
-    verified: false,
-  })
-}
+import{isSecretFreeRoomPayload as e,runtimeSupportsCapability as t}from"./runtime-contract.mjs";export const ERROR_RECOVERY_VERSION=1;export const MAX_RECOVERY_ATTEMPTS=3;const r=/^[a-z][a-z0-9_-]{0,79}$/,n=/^[A-Za-z0-9][A-Za-z0-9._:@-]{0,159}$/;export function normalizeErrorRecovery({runtime:i,capabilityId:a,code:o="runtime_error",retryable:m=!1,attempt:s=1,evidenceRefs:p=[]}={}){const c=(({runtime:e,capabilityId:r})=>t(e,r)?Object.freeze({maxAttempts:3}):Object.freeze({maxAttempts:1}))({runtime:i,capabilityId:a}),d=Math.max(1,Math.min(c.maxAttempts,Number.isSafeInteger(s)?s:1)),y=(Array.isArray(p)?p:[]).slice(0,16).filter(e=>e&&n.test(String(e.type||""))&&n.test(String(e.id||""))).map(e=>({type:String(e.type),id:String(e.id)})),u=t(i,a)&&r.test(String(o)),v=u&&!0===m&&d<c.maxAttempts,x={version:1,capabilityId:u?a:"unknown",code:u?String(o):"invalid_recovery_input",retryable:v,attempt:d,maxAttempts:c.maxAttempts,next:v?"retry":u&&!0===m?"ask_human":"stop",evidenceRefs:y};return Object.freeze(e(x,4096)?x:{version:1,capabilityId:"unknown",code:"invalid_recovery_input",retryable:!1,attempt:1,maxAttempts:1,next:"stop",evidenceRefs:[]})}export function recoveryCodeEvent(e){const t=normalizeErrorRecovery(e);return Object.freeze({kind:"ask_human"===t.next?"needs-input":"error",subtype:"bounded_recovery",message:"ask_human"===t.next?`Recovery attempt ${t.attempt}/${t.maxAttempts} is exhausted; human input is required.`:`Recovery stopped safely (${t.code}).`,recovery:t,verified:!1})}

package/event-bounds.mjs

@@ -1,121 +1 @@
-import { compactEvidenceEnvelope } from './evidence-compact.mjs'
-
-/* Browser-safe structured-event bounding shared by the bridge broadcast path and
-   the web client's persisted reload snapshot. Large Codex/Claude tool payloads
-   must remain recognisable (tool name + a useful preview), but must never turn a
-   replay frame or tx: seed row into a multi-megabyte hydration dependency. */
-
-export const STRUCTURED_EVENT_CAP = 80000
-// 14 × the 150KB replay-frame budget: the largest complete rolling window the
-// transport can deliver without trimming. Older events remain in the JSONL archive.
-export const STRUCTURED_LOG_BYTE_CAP = 2100000
-
-const sizeOf = (value) => {
-  try { return JSON.stringify(value).length } catch { return Infinity }
-}
-
-const clipString = (value, limit) => {
-  if (value.length <= limit) return value
-  return `${value.slice(0, limit)}\n…[truncated ${value.length - limit} bytes]`
-}
-
-function compactValue(value, budget, depth = 0) {
-  if (sizeOf(value) <= budget) return value
-  if (typeof value === 'string') return clipString(value, Math.max(80, budget - 80))
-  if (value == null || typeof value !== 'object') return value
-  if (depth >= 4) return '[nested value omitted — too large]'
-
-  if (Array.isArray(value)) {
-    const out = []
-    const limit = Math.min(value.length, 8)
-    const per = Math.max(240, Math.floor((budget - 180) / Math.max(1, limit)))
-    for (let i = 0; i < limit; i++) out.push(compactValue(value[i], per, depth + 1))
-    if (value.length > limit) out.push(`…[${value.length - limit} more items omitted]`)
-    return out
-  }
-
-  const entries = Object.entries(value)
-  const out = {}
-  const limit = Math.min(entries.length, 16)
-  const per = Math.max(240, Math.floor((budget - 180) / Math.max(1, limit)))
-  for (let i = 0; i < limit; i++) {
-    const [key, nested] = entries[i]
-    out[key] = compactValue(nested, per, depth + 1)
-  }
-  if (entries.length > limit) out._omitted = `${entries.length - limit} more fields`
-  return out
-}
-
-function compactBlock(block, budget) {
-  if (!block || typeof block !== 'object') return compactValue(block, budget)
-  if (sizeOf(block) <= budget) return block
-  if (block.type === 'image') {
-    return { type: 'text', text: '[image omitted from replay — open the live session to view]' }
-  }
-  const out = {}
-  for (const key of ['type', 'id', 'name', 'tool_use_id']) if (block[key] != null) out[key] = block[key]
-  // A replay needs the tool identity and a useful preview, not a second full copy
-  // of a giant patch/result that already lives in the durable archive.
-  const payloadBudget = Math.min(block.type === 'tool_use' ? 12000 : 20000, Math.max(500, budget - 600))
-  if (typeof block.text === 'string') out.text = clipString(block.text, payloadBudget)
-  if (block.input != null) out.input = compactValue(block.input, payloadBudget, 1)
-  if (block.content != null) out.content = compactValue(block.content, payloadBudget, 1)
-  if (!('text' in out) && !('input' in out) && !('content' in out)) out.text = `[${block.type || 'content'} omitted — too large]`
-  return out
-}
-
-export function boundStructuredEvent(event, cap = STRUCTURED_EVENT_CAP) {
-  if (!event || typeof event !== 'object' || sizeOf(event) <= cap) return event
-
-  const out = { ...event, _bounded: true }
-  if (out.evidence) out.evidence = compactEvidenceEnvelope(out.evidence, 0)
-  const stringBudget = Math.min(12000, Math.max(1000, Math.floor(cap / 4)))
-  for (const key of ['text', 'output', 'stdout', 'stderr', 'input']) {
-    if (typeof out[key] === 'string') out[key] = clipString(out[key], stringBudget)
-  }
-  if (typeof out.content === 'string') out.content = clipString(out.content, stringBudget)
-  else if (Array.isArray(out.content)) {
-    const per = Math.max(900, Math.floor((cap - 2000) / Math.max(1, Math.min(out.content.length, 8))))
-    out.content = out.content.slice(0, 8).map(block => compactBlock(block, per))
-    if (event.content.length > 8) out.content.push({ type: 'text', text: `…[${event.content.length - 8} more blocks omitted]` })
-  }
-  if (Array.isArray(out.blocks)) {
-    const per = Math.max(900, Math.floor((cap - 2000) / Math.max(1, Math.min(out.blocks.length, 8))))
-    out.blocks = out.blocks.slice(0, 8).map(block => compactBlock(block, per))
-    if (event.blocks.length > 8) out.blocks.push({ type: 'text', text: `…[${event.blocks.length - 8} more blocks omitted]` })
-  }
-
-  if (sizeOf(out) <= cap) return out
-
-  // Hard fallback: retain ordering/dedup identity and recognisable tool blocks.
-  const identity = {}
-  for (const key of ['kind', 'seq', 'cid', 'ts', 'term', 'toolUseId', 'isError', 'by', 'crosspost', 'relaySourceName']) {
-    if (out[key] != null) identity[key] = out[key]
-  }
-  if (out.evidence) identity.evidence = compactEvidenceEnvelope(out.evidence, 0)
-  if (Array.isArray(out.blocks)) identity.blocks = out.blocks.slice(0, 4).map(block => compactBlock(block, 6000))
-  else if (Array.isArray(out.content)) identity.content = out.content.slice(0, 4).map(block => compactBlock(block, 6000))
-  else if (typeof out.content === 'string') identity.content = clipString(out.content, 12000)
-  else if (typeof out.text === 'string') identity.text = clipString(out.text, 12000)
-  identity._bounded = true
-  identity._notice = 'Large tool payload truncated for fast transcript hydration'
-  return identity
-}
-
-export function boundStructuredLog(events, {
-  eventCap = STRUCTURED_EVENT_CAP,
-  byteCap = STRUCTURED_LOG_BYTE_CAP,
-  countCap = 2000,
-} = {}) {
-  if (!Array.isArray(events) || !events.length) return []
-  const bounded = events.slice(-countCap).map((event) => boundStructuredEvent(event, eventCap))
-  let bytes = 0
-  let start = bounded.length
-  while (start > 0) {
-    const size = sizeOf(bounded[start - 1]) + 1
-    if (start < bounded.length && bytes + size > byteCap) break
-    bytes += size
-    start--
-  }
-  return start === 0 ? bounded : bounded.slice(start)
-}
+import{compactEvidenceEnvelope as t}from"./evidence-compact.mjs";export const STRUCTURED_EVENT_CAP=8e4;export const STRUCTURED_LOG_BYTE_CAP=21e5;const e=t=>{try{return JSON.stringify(t).length}catch{return 1/0}},n=(t,e)=>t.length<=e?t:`${t.slice(0,e)}\n…[truncated ${t.length-e} bytes]`;function o(t,r,c=0){if(e(t)<=r)return t;if("string"==typeof t)return n(t,Math.max(80,r-80));if(null==t||"object"!=typeof t)return t;if(c>=4)return"[nested value omitted — too large]";if(Array.isArray(t)){const e=[],n=Math.min(t.length,8),i=Math.max(240,Math.floor((r-180)/Math.max(1,n)));for(let r=0;r<n;r++)e.push(o(t[r],i,c+1));return t.length>n&&e.push(`…[${t.length-n} more items omitted]`),e}const i=Object.entries(t),s={},a=Math.min(i.length,16),l=Math.max(240,Math.floor((r-180)/Math.max(1,a)));for(let t=0;t<a;t++){const[e,n]=i[t];s[e]=o(n,l,c+1)}return i.length>a&&(s._omitted=i.length-a+" more fields"),s}function r(t,r){if(!t||"object"!=typeof t)return o(t,r);if(e(t)<=r)return t;if("image"===t.type)return{type:"text",text:"[image omitted from replay — open the live session to view]"};const c={};for(const e of["type","id","name","tool_use_id"])null!=t[e]&&(c[e]=t[e]);const i=Math.min("tool_use"===t.type?12e3:2e4,Math.max(500,r-600));return"string"==typeof t.text&&(c.text=n(t.text,i)),null!=t.input&&(c.input=o(t.input,i,1)),null!=t.content&&(c.content=o(t.content,i,1)),"text"in c||"input"in c||"content"in c||(c.text=`[${t.type||"content"} omitted — too large]`),c}export function boundStructuredEvent(o,c=8e4){if(!o||"object"!=typeof o||e(o)<=c)return o;const i={...o,_bounded:!0};i.evidence&&(i.evidence=t(i.evidence,0));const s=Math.min(12e3,Math.max(1e3,Math.floor(c/4)));for(const t of["text","output","stdout","stderr","input"])"string"==typeof i[t]&&(i[t]=n(i[t],s));if("string"==typeof i.content)i.content=n(i.content,s);else if(Array.isArray(i.content)){const t=Math.max(900,Math.floor((c-2e3)/Math.max(1,Math.min(i.content.length,8))));i.content=i.content.slice(0,8).map(e=>r(e,t)),o.content.length>8&&i.content.push({type:"text",text:`…[${o.content.length-8} more blocks omitted]`})}if(Array.isArray(i.blocks)){const t=Math.max(900,Math.floor((c-2e3)/Math.max(1,Math.min(i.blocks.length,8))));i.blocks=i.blocks.slice(0,8).map(e=>r(e,t)),o.blocks.length>8&&i.blocks.push({type:"text",text:`…[${o.blocks.length-8} more blocks omitted]`})}if(e(i)<=c)return i;const a={};for(const t of["kind","seq","cid","ts","term","toolUseId","isError","by","crosspost","relaySourceName"])null!=i[t]&&(a[t]=i[t]);return i.evidence&&(a.evidence=t(i.evidence,0)),Array.isArray(i.blocks)?a.blocks=i.blocks.slice(0,4).map(t=>r(t,6e3)):Array.isArray(i.content)?a.content=i.content.slice(0,4).map(t=>r(t,6e3)):"string"==typeof i.content?a.content=n(i.content,12e3):"string"==typeof i.text&&(a.text=n(i.text,12e3)),a._bounded=!0,a._notice="Large tool payload truncated for fast transcript hydration",a}export function boundStructuredLog(t,{eventCap:n=8e4,byteCap:o=21e5,countCap:r=2e3}={}){if(!Array.isArray(t)||!t.length)return[];const c=t.slice(-r).map(t=>boundStructuredEvent(t,n));let i=0,s=c.length;for(;s>0;){const t=e(c[s-1])+1;if(s<c.length&&i+t>o)break;i+=t,s--}return 0===s?c:c.slice(s)}

package/event-delivery-queue.mjs

@@ -1,60 +1 @@
-// Ordered, acknowledged delivery for bridge-produced transcript events.
-//
-// The bridge's local JSONL archive is durable, but a live `code-event` still
-// has to cross Realtime before either viewer can write its shared tx: snapshot.
-// Never let a failed (or merely late) assistant frame allow its terminal result
-// to overtake it. Keep the head queued until Realtime acknowledges it, then move
-// on in order. A fresh browser replay remains the crash-recovery backstop.
-
-const defaultWait = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
-
-export const acceptedRealtimeDelivery = (result) =>
-  result === 'ok' || result?.success === true
-
-export function createEventDeliveryQueue ({ send, wait = defaultWait, retryDelay = (attempt) => Math.min(10_000, 250 * (2 ** Math.min(attempt, 6))) } = {}) {
-  if (typeof send !== 'function') throw new TypeError('event delivery queue requires send(frame)')
-  const frames = []
-  let running = false
-  let closed = false
-  let idle = Promise.resolve()
-  let settleIdle = null
-
-  const run = async () => {
-    if (running || closed) return
-    running = true
-    try {
-      while (!closed && frames.length) {
-        const head = frames[0]
-        let result = null
-        try { result = await send(head.frame) } catch { result = null }
-        if (acceptedRealtimeDelivery(result)) {
-          frames.shift()
-          continue
-        }
-        head.attempt += 1
-        await wait(retryDelay(head.attempt))
-      }
-    } finally {
-      running = false
-      if (!frames.length && settleIdle) { settleIdle(); settleIdle = null }
-      if (!closed && frames.length) void run()
-    }
-  }
-
-  return {
-    enqueue (frame) {
-      if (closed) return false
-      if (!frames.length && !running) idle = new Promise((resolve) => { settleIdle = resolve })
-      frames.push({ frame, attempt: 0 })
-      void run()
-      return true
-    },
-    pending: () => frames.length,
-    whenIdle: () => idle,
-    close () {
-      closed = true
-      frames.length = 0
-      if (settleIdle) { settleIdle(); settleIdle = null }
-    },
-  }
-}
+const e=e=>new Promise(t=>setTimeout(t,e));export const acceptedRealtimeDelivery=e=>"ok"===e||!0===e?.success;export function createEventDeliveryQueue({send:t,wait:n=e,retryDelay:l=e=>Math.min(1e4,250*2**Math.min(e,6))}={}){if("function"!=typeof t)throw new TypeError("event delivery queue requires send(frame)");const r=[];let i=!1,a=!1,o=Promise.resolve(),s=null;const c=async()=>{if(!i&&!a){i=!0;try{for(;!a&&r.length;){const e=r[0];let i=null;try{i=await t(e.frame)}catch{i=null}acceptedRealtimeDelivery(i)?r.shift():(e.attempt+=1,await n(l(e.attempt)))}}finally{i=!1,!r.length&&s&&(s(),s=null),!a&&r.length&&c()}}};return{enqueue:e=>!a&&(r.length||i||(o=new Promise(e=>{s=e})),r.push({frame:e,attempt:0}),c(),!0),pending:()=>r.length,whenIdle:()=>o,close(){a=!0,r.length=0,s&&(s(),s=null)}}}