@sqdr2/dsh-fusion 0.0.0-stage → 0.3.2

package/src/host/cache-policy.ts

@@ -0,0 +1,168 @@
+import type { Role } from '../contracts.js'
+import type { SqliteFusionStore } from '../task/sqlite-store.js'
+import { cacheDefaults, type CacheDefaults, type CacheMode } from './cache-defaults.js'
+
+/** The user's choice for one physical model route; absent fields fall back to learned/default values. */
+export interface ModelCacheSetting { mode?: CacheMode; intervalSeconds?: number }
+
+/** One model request that followed a wait: the evidence the policy learns from and the settings page shows. */
+export interface CacheSample { at: string; gapSeconds: number; ping: boolean; hit: boolean; cacheRead: number; input: number; output?: number }
+
+export interface ModelCacheStats {
+  schemaVersion: 1
+  provider: string
+  model: string
+  samples: CacheSample[]
+  totals: {
+    /** Real requests after a wait of at least WAIT_SECONDS, and how many still found their prefix cached. */
+    waits: number; waitHits: number
+    /** Keepalive pings and the tokens they read (mostly at the cache price). */
+    pings: number; pingHits: number; pingTokens: number
+    /** Output tokens of pings; absent on stats recorded before 0.2.3. A route that ignores the output cap shows here. */
+    pingOutputTokens?: number
+    /** Prefix tokens served from cache after a wait, and tokens resent uncached after a wait. */
+    keptWarmTokens: number; resentTokens: number
+  }
+  /** Interval shortened after pings kept missing (never lengthened automatically). */
+  learnedIntervalSeconds?: number
+  /** Rule that produced learnedIntervalSeconds; values from older rules are ignored. */
+  learnedRule?: number
+  updatedAt: string
+}
+
+export interface EffectiveCachePolicy {
+  mode: CacheMode
+  intervalSeconds: number
+  modeSource: 'user' | 'pair' | 'role' | CacheDefaults['source']
+  intervalSource: 'user' | 'learned' | CacheDefaults['source']
+  defaults: CacheDefaults
+}
+
+/** A request counts as a wait when this long passed since the previous request of the same agent. */
+export const WAIT_SECONDS = 120
+/**
+ * Rule 2 (0.2.3): shorten only when most recent pings at this interval missed (3 of the last up to 5).
+ * Rule 1 shortened on 2 misses, and providers also drop single prefixes at random: the live log had
+ * 4 partial misses in 123 pings, each keeping only the shared 3,968-token system+tools head, while
+ * a probe of the same route still hit after 10+ idle minutes. That noise cut a 285 s interval to 214 s.
+ */
+export const LEARNING_RULE = 2
+const SAMPLE_LIMIT = 60
+const MIN_INTERVAL = 60, MAX_INTERVAL = 3_540
+
+/** A request reused its prefix when most of its input came from the cache. */
+export const cacheHit = (cacheRead: number, input: number) => cacheRead > 0 && cacheRead / (cacheRead + input) >= 0.5
+
+const key = (provider: string, model: string) => `${provider}\u0001${model}`
+export const clampInterval = (seconds: number) => Math.min(MAX_INTERVAL, Math.max(MIN_INTERVAL, Math.round(seconds)))
+
+export class CachePolicy {
+  constructor(readonly store: SqliteFusionStore) {}
+
+  setting(provider: string, model: string): ModelCacheSetting | undefined {
+    return this.store.readDocument(`cache-setting:${key(provider, model)}`)?.value as ModelCacheSetting | undefined
+  }
+
+  /** Save or clear (null) the user's choice; invalid values are refused, not coerced. */
+  save(provider: string, model: string, setting: ModelCacheSetting | null): void {
+    const id = `cache-setting:${key(provider, model)}`, prior = this.store.readDocument(id)
+    if (setting === null) { if (prior) this.store.writeDocument(id, prior.revision, {}); return }
+    if (setting.mode !== undefined && !['auto', 'on', 'off'].includes(setting.mode)) throw new Error('Keepalive mode must be auto, on or off')
+    if (setting.intervalSeconds !== undefined && (!Number.isFinite(setting.intervalSeconds)
+      || setting.intervalSeconds < MIN_INTERVAL || setting.intervalSeconds > MAX_INTERVAL)) {
+      throw new Error(`Keepalive interval must be ${MIN_INTERVAL}–${MAX_INTERVAL} seconds`)
+    }
+    this.store.writeDocument(id, prior?.revision ?? 0, { ...(setting.mode ? { mode: setting.mode } : {}),
+      ...(setting.intervalSeconds ? { intervalSeconds: Math.round(setting.intervalSeconds) } : {}) })
+  }
+
+  stats(provider: string, model: string): ModelCacheStats | undefined {
+    return this.store.readDocument(`cache-stats:${key(provider, model)}`)?.value as ModelCacheStats | undefined
+  }
+
+  /**
+   * Record a request that followed a wait (or any keepalive ping). Pings that keep missing at the current
+   * interval shorten it by a quarter: a too-long interval wastes every ping, a too-short one only costs extra
+   * cheap reads, so the rule only ever moves toward safety. Lengthening is left to the user (see suggestion).
+   */
+  observe(provider: string, model: string, sample: Omit<CacheSample, 'at'>, currentIntervalSeconds: number): void {
+    if (!sample.ping && sample.gapSeconds < WAIT_SECONDS) return
+    const id = `cache-stats:${key(provider, model)}`, prior = this.store.readDocument(id)
+    const stats: ModelCacheStats = (prior?.value as ModelCacheStats | undefined) ?? { schemaVersion: 1, provider, model, samples: [],
+      totals: { waits: 0, waitHits: 0, pings: 0, pingHits: 0, pingTokens: 0, keptWarmTokens: 0, resentTokens: 0 }, updatedAt: '' }
+    const row: CacheSample = { at: new Date().toISOString(), ...sample }
+    stats.samples = [...stats.samples, row].slice(-SAMPLE_LIMIT)
+    const totals = stats.totals
+    if (row.ping) {
+      totals.pings++; totals.pingTokens += row.cacheRead + row.input
+      totals.pingOutputTokens = (totals.pingOutputTokens ?? 0) + (row.output ?? 0)
+      if (row.hit) totals.pingHits++
+      const recent = stats.samples.filter(item => item.ping && Math.abs(item.gapSeconds - currentIntervalSeconds) <= currentIntervalSeconds * 0.25).slice(-5)
+      if (recent.filter(item => !item.hit).length >= 3) {
+        stats.learnedIntervalSeconds = clampInterval(currentIntervalSeconds * 0.75); stats.learnedRule = LEARNING_RULE
+        stats.samples = stats.samples.filter(item => !item.ping) // judge the new interval on fresh pings
+      }
+    } else {
+      totals.waits++
+      if (row.hit) { totals.waitHits++; totals.keptWarmTokens += row.cacheRead } else totals.resentTokens += row.input
+    }
+    stats.updatedAt = row.at
+    this.store.writeDocument(id, prior?.revision ?? 0, stats)
+  }
+
+  /**
+   * User setting > pair profile (older explicit choice) > learned interval > our own route's billing default >
+   * model family default > generic. The Worker defaults to off: it rarely waits long enough to need pings.
+   */
+  resolve(provider: string, model: string, role: Role, pairChoice?: boolean | 'auto'): EffectiveCachePolicy {
+    const defaults = cacheDefaults(provider, model)
+    const user = this.setting(provider, model) ?? {}
+    const stats = this.stats(provider, model)
+    const learned = stats?.learnedRule === LEARNING_RULE ? stats.learnedIntervalSeconds : undefined
+    let mode: CacheMode, modeSource: EffectiveCachePolicy['modeSource']
+    if (user.mode) { mode = user.mode; modeSource = 'user' }
+    else if (typeof pairChoice === 'boolean') { mode = pairChoice ? 'on' : 'off'; modeSource = 'pair' }
+    else if (role === 'worker') { mode = 'off'; modeSource = 'role' }
+    else { mode = defaults.keepalive; modeSource = defaults.source }
+    const intervalSeconds = user.intervalSeconds ?? learned ?? defaults.intervalSeconds
+    const intervalSource: EffectiveCachePolicy['intervalSource'] = user.intervalSeconds ? 'user' : learned ? 'learned' : defaults.source
+    return { mode, intervalSeconds, modeSource, intervalSource, defaults }
+  }
+
+  /** Suggest a longer interval only on repeated evidence: real waits that still hit well beyond the interval. */
+  suggestion(provider: string, model: string, intervalSeconds: number): number | undefined {
+    const long = (this.stats(provider, model)?.samples ?? []).filter(item => !item.ping && item.hit && item.gapSeconds >= intervalSeconds * 1.5)
+    if (long.length < 3) return undefined
+    return clampInterval(Math.floor(Math.min(...long.map(item => item.gapSeconds)) / 30) * 30)
+  }
+
+  /** Every route the plugin has evidence or a setting for, plus the given routes (the configured pair). */
+  routes(extra: readonly { provider: string; model: string }[] = []): { provider: string; model: string }[] {
+    const ids = [...this.store.listDocumentIds('cache-stats:'), ...this.store.listDocumentIds('cache-setting:')]
+      .map(id => id.slice(id.indexOf(':') + 1).split('\u0001') as [string, string])
+    const all = [...extra.map(item => [item.provider, item.model] as [string, string]), ...ids]
+    const seen = new Set<string>()
+    return all.filter(([provider, model]) => provider && model && !seen.has(key(provider, model)) && seen.add(key(provider, model)))
+      .map(([provider, model]) => ({ provider, model }))
+  }
+}
+
+type Route = { provider: string; model: string }
+/** One row of the settings page: what applies, why, what the defaults say, and what was observed. */
+export function cacheView(policy: CachePolicy, pair?: { lead: Route; worker: Route }, pairChoice?: { lead?: boolean | 'auto'; worker?: boolean | 'auto' }) {
+  const same = (a: Route | undefined, provider: string, model: string) => a?.provider === provider && a.model === model
+  return policy.routes(pair ? [pair.lead, pair.worker] : []).map(({ provider, model }) => {
+    const role: Role | undefined = same(pair?.lead, provider, model) ? 'lead' : same(pair?.worker, provider, model) ? 'worker' : undefined
+    const effective = policy.resolve(provider, model, role ?? 'lead', role ? pairChoice?.[role] : undefined)
+    const stats = policy.stats(provider, model), { family, route } = effective.defaults
+    return { provider, model, role,
+      mode: effective.mode, intervalSeconds: effective.intervalSeconds, modeSource: effective.modeSource, intervalSource: effective.intervalSource,
+      setting: policy.setting(provider, model) ?? {},
+      defaults: { mode: effective.defaults.keepalive, intervalSeconds: effective.defaults.intervalSeconds, source: effective.defaults.source,
+        ...(family ? { family: { label: family.label, lifetime: family.lifetime, discount: family.discount, docs: family.docs } } : {}),
+        ...(route ? { route: { label: route.label, reason: route.reason } } : {}) },
+      totals: stats?.totals ?? null, learnedIntervalSeconds: stats?.learnedRule === LEARNING_RULE ? stats.learnedIntervalSeconds ?? null : null,
+      suggestion: policy.suggestion(provider, model, effective.intervalSeconds) ?? null,
+      recent: (stats?.samples ?? []).slice(-8).map(item => ({ gapSeconds: Math.round(item.gapSeconds), ping: item.ping, hit: item.hit })) }
+  })
+}

package/src/host/change-evidence.ts

@@ -0,0 +1,156 @@
+import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, readlinkSync, realpathSync } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+import type { ArtifactRef, SnapshotId, TaskId } from '../contracts.js'
+import { sha256Hex } from '../digest.js'
+import type { SqliteFusionStore } from '../task/sqlite-store.js'
+import { evidenceText } from './evidence-page.js'
+import { changedPaths, pathAllowed, workspacePath } from './workspace.js'
+import type { WorkspaceEntry, WorkspaceSnapshot } from './workspace.js'
+
+export interface ChangeBase {
+  schemaVersion: 1
+  snapshot: SnapshotId
+  contents: Record<string, ArtifactRef>
+  /**
+   * Paths the Lead widened the scope to only after they had already changed, so their
+   * delegation-time bytes are gone. Diffs carry no pre-image for them and the
+   * rewritten-test gate cannot compare original lines; the review must say so instead of
+   * pretending the file was untouched (`session-daa71a4a`: refusing to record them at all
+   * left the task with no admissible report and no admissible widening).
+   */
+  unavailable?: readonly string[]
+}
+
+/** Read only the exact leaf described by the snapshot, never its symlink target. */
+function readEntry(snapshot: WorkspaceSnapshot, entry: WorkspaceEntry): Buffer {
+  if (realpathSync.native(snapshot.root) !== snapshot.root) throw new Error('Evidence workspace root changed')
+  const path = join(workspacePath(snapshot.root, dirname(entry.path)), basename(entry.path))
+  const before = lstatSync(path)
+  let bytes: Buffer
+  if (entry.kind === 'symlink') {
+    if (!before.isSymbolicLink()) throw new Error('Evidence file kind changed')
+    bytes = readlinkSync(path, { encoding: 'buffer' })
+  } else {
+    if (!before.isFile() || before.size > 16 * 1024 * 1024) throw new Error('Evidence file is not a bounded regular source file')
+    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW)
+    try {
+      const opened = fstatSync(fd)
+      if (!opened.isFile() || opened.ino !== before.ino || opened.dev !== before.dev || opened.size !== before.size) throw new Error('Evidence source changed while opening')
+      bytes = Buffer.alloc(opened.size)
+      let offset = 0
+      while (offset < bytes.length) {
+        const count = readSync(fd, bytes, offset, bytes.length - offset, offset)
+        if (!count) throw new Error('Evidence source shrank while reading')
+        offset += count
+      }
+      if (readSync(fd, Buffer.alloc(1), 0, 1, offset)) throw new Error('Evidence source grew while reading')
+      const after = fstatSync(fd)
+      if (after.size !== bytes.length || after.mtimeMs !== opened.mtimeMs) throw new Error('Evidence source changed while reading')
+    } finally { closeSync(fd) }
+  }
+  const after = lstatSync(path)
+  if (after.ino !== before.ino || after.dev !== before.dev || after.mtimeMs !== before.mtimeMs
+    || (entry.kind === 'file' && Boolean(after.mode & 0o111) !== entry.executable)
+    || sha256Hex(bytes) !== entry.digest) throw new Error('Evidence bytes do not match the frozen snapshot')
+  // Recheck parents after reading; a replacement must never become trusted evidence.
+  workspacePath(snapshot.root, dirname(entry.path))
+  if (realpathSync.native(snapshot.root) !== snapshot.root) throw new Error('Evidence workspace root changed')
+  return bytes
+}
+
+export function captureChangeBase(store: SqliteFusionStore, taskId: TaskId, base: WorkspaceSnapshot, allowed: readonly string[]): ChangeBase {
+  const entries = base.entries.filter(entry => pathAllowed(entry.path, allowed))
+  const refs = store.putArtifacts(taskId, entries.map(entry => ({ bytes: readEntry(base, entry), mediaType: 'application/octet-stream' })))
+  return { schemaVersion: 1, snapshot: base.id, contents: Object.fromEntries(entries.map((entry, i) => [entry.path, refs[i]])) }
+}
+
+/**
+ * The same base bytes, for paths the Lead adds to the frozen scope after a report. A file the
+ * Worker (or the task's own build command) already changed no longer matches the snapshot, so
+ * its delegation-time bytes cannot be recorded: that path is reported as unavailable instead of
+ * failing, which would leave the task with no admissible report and no admissible widening.
+ */
+export function captureLaterChangeBase(store: SqliteFusionStore, taskId: TaskId, base: WorkspaceSnapshot, allowed: readonly string[]): ChangeBase {
+  const readable: { path: string; bytes: Buffer }[] = [], unavailable: string[] = []
+  for (const entry of base.entries.filter(entry => pathAllowed(entry.path, allowed))) {
+    try { readable.push({ path: entry.path, bytes: readEntry(base, entry) }) } catch { unavailable.push(entry.path) }
+  }
+  const refs = store.putArtifacts(taskId, readable.map(entry => ({ bytes: entry.bytes, mediaType: 'application/octet-stream' })))
+  return { schemaVersion: 1, snapshot: base.id, contents: Object.fromEntries(readable.map((entry, i) => [entry.path, refs[i]])),
+    ...(unavailable.length ? { unavailable } : {}) }
+}
+
+function quotePath(path: string): string {
+  const bytes = Buffer.from(path)
+  if (bytes.every(byte => byte > 32 && byte < 127 && byte !== 34 && byte !== 92)) return path
+  return '"' + Array.from(bytes, byte => byte === 34 || byte === 92 ? '\\' + String.fromCharCode(byte)
+    : byte >= 32 && byte < 127 ? String.fromCharCode(byte) : '\\' + byte.toString(8).padStart(3, '0')).join('') + '"'
+}
+const mode = (entry: WorkspaceEntry) => entry.kind === 'symlink' ? '120000' : entry.executable ? '100755' : '100644'
+
+/** A full, applicable single hunk, trimmed only at unchanged leading/trailing lines. */
+function patch(path: string, before: WorkspaceEntry | undefined, after: WorkspaceEntry | undefined, oldText: string, newText: string): string {
+  const a = quotePath(`a/${path}`), b = quotePath(`b/${path}`)
+  let output = `diff --git ${a} ${b}\n`
+  if (!before) output += `new file mode ${mode(after!)}\n`
+  else if (!after) output += `deleted file mode ${mode(before)}\n`
+  else if (mode(before) !== mode(after)) output += `old mode ${mode(before)}\nnew mode ${mode(after)}\n`
+  if (oldText === newText) return output
+  const oldLines = oldText.match(/[^\n]*\n|[^\n]+$/g) ?? [], newLines = newText.match(/[^\n]*\n|[^\n]+$/g) ?? []
+  let prefix = 0, suffix = 0
+  while (prefix < Math.min(oldLines.length, newLines.length) && oldLines[prefix] === newLines[prefix]) prefix++
+  while (suffix < Math.min(oldLines.length, newLines.length) - prefix && oldLines[oldLines.length - suffix - 1] === newLines[newLines.length - suffix - 1]) suffix++
+  const start = Math.max(0, prefix - 3), oldEnd = oldLines.length - Math.max(0, suffix - 3), newEnd = newLines.length - Math.max(0, suffix - 3)
+  const line = (tag: string, value: string) => tag + value + (value.endsWith('\n') ? '' : '\n\\n')
+  output += `--- ${before ? a : '/dev/null'}\n+++ ${after ? b : '/dev/null'}\n@@ -${oldEnd === start ? 0 : start + 1},${oldEnd - start} +${newEnd === start ? 0 : start + 1},${newEnd - start} @@\n`
+  for (let i = start; i < prefix; i++) output += line(' ', oldLines[i])
+  for (let i = prefix; i < oldLines.length - suffix; i++) output += line('-', oldLines[i])
+  for (let i = prefix; i < newLines.length - suffix; i++) output += line('+', newLines[i])
+  for (let i = oldLines.length - suffix; i < oldEnd; i++) output += line(' ', oldLines[i])
+  return output
+}
+
+export interface ChangeDiff {
+  path: string
+  status: 'text' | 'binary' | 'type-change' | 'unavailable-base'
+  before?: { entry: WorkspaceEntry; content?: ArtifactRef }
+  after?: { entry: WorkspaceEntry; content: ArtifactRef }
+  patch?: ArtifactRef
+}
+
+export function saveChangeManifest(store: SqliteFusionStore, taskId: TaskId, base: WorkspaceSnapshot, candidate: WorkspaceSnapshot, captured?: ChangeBase): ArtifactRef {
+  if (captured && (captured.schemaVersion !== 1 || captured.snapshot !== base.id)) throw new Error('Change evidence belongs to another base snapshot')
+  const changes = changedPaths(base, candidate)
+  const old = new Map(base.entries.map(entry => [entry.path, entry])), now = new Map(candidate.entries.map(entry => [entry.path, entry]))
+  const baseRefs = changes.flatMap(path => {
+    const ref = old.has(path) && captured && Object.hasOwn(captured.contents, path) ? captured.contents[path] : undefined
+    return ref ? [ref] : []
+  })
+  const baseBytes = new Map(store.readArtifacts(taskId, baseRefs.map(ref => ref.id)).map((bytes, i) => [baseRefs[i].id, bytes]))
+  const pending: { bytes: Uint8Array; mediaType: string }[] = []
+  const prepared = changes.map(path => {
+    const before = old.get(path), after = now.get(path)
+    const beforeRef = before && captured && Object.hasOwn(captured.contents, path) ? captured.contents[path] : undefined
+    const oldBytes = beforeRef ? baseBytes.get(beforeRef.id) : undefined
+    if (beforeRef && (!before || beforeRef.digest !== before.digest || sha256Hex(oldBytes!) !== before.digest)) throw new Error('Change evidence does not match the base file')
+    // A path the Lead widened the scope to after it had already changed has no recordable
+    // pre-image; it is reported as `unavailable-base` instead of blocking every report.
+    if (before && captured && !beforeRef && !captured.unavailable?.includes(path)) throw new Error('Frozen change evidence is missing the base file')
+    const newBytes = after ? readEntry(candidate, after) : undefined
+    const afterIndex = pending.length
+    if (newBytes) pending.push({ bytes: newBytes, mediaType: 'application/octet-stream' })
+    const oldText = oldBytes ? evidenceText(oldBytes) : '', newText = newBytes ? evidenceText(newBytes) : ''
+    const status: ChangeDiff['status'] = before && !beforeRef ? 'unavailable-base'
+      : before && after && before.kind !== after.kind ? 'type-change'
+      : oldText === undefined || newText === undefined ? 'binary' : 'text'
+    const patchIndex = pending.length
+    if (status === 'text') pending.push({ bytes: Buffer.from(patch(path, before, after, oldText!, newText!)), mediaType: 'text/x-diff' })
+    return { path, status, before, beforeRef, after, afterIndex, patchIndex }
+  })
+  const refs = store.putArtifacts(taskId, pending)
+  const diffs: ChangeDiff[] = prepared.map(item => ({ path: item.path, status: item.status,
+    ...(item.before ? { before: { entry: item.before, ...(item.beforeRef ? { content: item.beforeRef } : {}) } } : {}),
+    ...(item.after ? { after: { entry: item.after, content: refs[item.afterIndex] } } : {}),
+    ...(item.status === 'text' ? { patch: refs[item.patchIndex] } : {}) }))
+  return store.putArtifact(taskId, Buffer.from(JSON.stringify({ schemaVersion: 2, base: base.id, changes, diffs, candidate })), 'application/vnd.dsh-fusion.change-manifest+json')
+}

package/src/host/compaction-routing.ts

@@ -0,0 +1,46 @@
+import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import type { PhysicalRoute, Role } from '../contracts.js'
+import { digestOf } from '../digest.js'
+import type { SessionBinding } from './bindings.js'
+
+/** Structural v1 optional contract exported by dsh-compact-saviour. */
+interface RouteSnapshot {
+  revision: string
+  context: PhysicalRoute
+  target: PhysicalRoute
+  maxOutputTokens?: number
+}
+interface Registry {
+  apiVersion: number
+  register(owner: string, resolve: (agent: Agent) => RouteSnapshot | undefined): () => void
+}
+interface Owner { binding: SessionBinding; role: Role }
+
+/** Publish exact session routes before another plugin estimates or chunks input. */
+export function installCompactionRouting(ctx: Context, input: {
+  owner(agent: Agent): Owner | undefined
+  route(binding: SessionBinding, role: Role): PhysicalRoute
+  epoch(binding: SessionBinding): number
+}): () => void {
+  let active = true
+  const fiber = ctx.inject(['compactionRoutes'], child => {
+    const registry = child.get('compactionRoutes') as Registry
+    if (registry.apiVersion !== 1 || typeof registry.register !== 'function')
+      throw new Error('Unsupported public compaction routing contract')
+    child.effect(() => registry.register('dsh-fusion', agent => {
+      if (!active) return undefined
+      const owner = input.owner(agent)
+      if (!owner) return undefined
+      const { binding, role } = owner
+      const context = input.route(binding, role)
+      const target = binding.profile.compactor?.route ?? context
+      const maxOutputTokens = binding.profile.compactor?.maxOutputTokens
+      return { context: { ...context }, target: { ...target },
+        ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }),
+        revision: digestOf({ session: agent.id, task: binding.taskId, profile: binding.profile.digest,
+          role, epoch: input.epoch(binding), context, target, maxOutputTokens: maxOutputTokens ?? null }) }
+    }))
+  })
+  return () => { active = false; void fiber.dispose() }
+}