@chatpanel/events 0.101.0 → 0.103.1

package/registry.js

@@ -1,240 +1 @@
-// The capability registry — revertible effects and reactive availability.
-//
-// This is the runtime half of the capability contract: `requires` / `provides` in a
-// declaration (capability.js) only mean something because something binds them here.
-//
-// WHY THIS AND NOT CORDIS. We need exactly two behaviours — effects that carry their own
-// inverse, and dependents that unwind when a capability withdraws and re-arm when it
-// returns. That is roughly 15% of Cordis's surface; we need neither its plugin registry,
-// its Proxy-based ctx, its config schema, its logger nor HMR. At ~200 lines this costs
-// nothing against a first-paint budget that is a release gate, has no CSP surface, and
-// ports to every runtime. The concepts port; the framework does not.
-//
-// THE TWO RULES THAT MATTER, and the bug class each prevents:
-//
-//   1. LIFO disposal. Inverses run in reverse order of registration, so each one meets
-//      the state its own application produced. Anything else hands an inverse a state it
-//      was not built for.
-//
-//   2. Dependents deactivate BEFORE a provider's binding is removed. A component being
-//      torn down because its provider is going away is running its own teardown, and
-//      that teardown frequently NEEDS the very capability being withdrawn — closing a
-//      connection pool means handing connections back to whatever provided them. Remove
-//      the binding first and the teardown reaches for something already gone. This is
-//      the orphaned-monitor / dangling-observer bug class, structurally.
-
-const STATE = Object.freeze({ INACTIVE: 'inactive', ACTIVE: 'active' });
-
-let nextId = 0;
-
-/**
- * @param onEvent optional hook — `{ event, name, key }`. Kept deliberately independent
- *        of the event schema so the registry has no dependency on the log; the caller
- *        maps these to `capability.activated` / `capability.revoked`.
- */
-export function createRegistry({ onEvent = null } = {}) {
-  const bindings = new Map();      // key -> { value, providerId }
-  const components = new Map();    // id  -> record
-  let settling = false;
-  let disposed = false;
-  let withdrawing = false;   // see withdrawSync — suspends settling inside rule 2's window
-
-  const emit = (event, detail) => { if (onEvent) onEvent({ event, ...detail }); };
-
-  function scopeFor(record) {
-    return {
-      /** Register a revertible effect. The returned disposer runs on deactivation, LIFO. */
-      effect(fn) {
-        const dispose = fn();
-        if (typeof dispose === 'function') record.disposers.push(dispose);
-        return () => {
-          const i = record.disposers.indexOf(dispose);
-          if (i >= 0) { record.disposers.splice(i, 1); dispose(); }
-        };
-      },
-
-      /** Provide a capability. This is itself an effect, so it unwinds with the component. */
-      provide(key, value) {
-        if (bindings.has(key)) throw new Error(`registry: '${key}' is already provided`);
-        bindings.set(key, { value, providerId: record.id });
-        record.provided.add(key);
-        emit('provided', { key, name: record.name });
-        record.disposers.push(() => withdrawSync(key));
-        queueSettle();
-      },
-
-      /** Read a required capability. */
-      get(key) {
-        const b = bindings.get(key);
-        return b ? b.value : undefined;
-      },
-
-      /** A nested component. Disposes with its parent, because that is an effect too. */
-      register(child) {
-        const handle = register(child);
-        record.disposers.push(() => handle.dispose());
-        return handle;
-      },
-
-      get name() { return record.name; },
-    };
-  }
-
-  function satisfied(record) {
-    return record.requires.every((k) => bindings.has(k));
-  }
-
-  function activate(record) {
-    record.state = STATE.ACTIVE;
-    try {
-      record.apply(scopeFor(record));
-    } catch (err) {
-      // A failure is recorded on the component and never propagated to its siblings —
-      // one broken component must not take the system down. Whatever it managed to
-      // register still unwinds.
-      record.state = STATE.INACTIVE;
-      record.error = err;
-      runDisposers(record);
-      emit('failed', { name: record.name, error: err });
-      return;
-    }
-    emit('activated', { name: record.name });
-  }
-
-  function runDisposers(record) {
-    const results = [];
-    // LIFO — rule 1.
-    while (record.disposers.length > 0) {
-      const dispose = record.disposers.pop();
-      try { results.push(dispose()); } catch { /* one bad disposer must not strand the rest */ }
-    }
-    record.provided.clear();
-    return results.filter((r) => r && typeof r.then === 'function');
-  }
-
-  function deactivate(record) {
-    if (record.state !== STATE.ACTIVE) return [];
-    record.state = STATE.INACTIVE;
-    const pending = runDisposers(record);
-    emit('deactivated', { name: record.name });
-    return pending;
-  }
-
-  /**
-   * Rule 2: every ACTIVE dependent stands down BEFORE the binding disappears, so its
-   * teardown can still read the capability it is being torn down over.
-   */
-  function withdrawSync(key) {
-    const binding = bindings.get(key);
-    if (!binding) return;
-    // Rule 2 creates a window: dependents are stood down while the binding they need is
-    // still present, precisely so their teardown can use it. Anything that settles inside
-    // that window sees an inactive component whose requirement is still satisfied and
-    // dutifully re-activates it — the component arms, then disarms again a moment later.
-    //
-    // That happens as soon as a second dependent exists, because tearing IT down withdraws
-    // what IT provided, and a nested withdrawal settles. With one dependent the window was
-    // never entered, which is why this survived until a second one was added.
-    //
-    // So the window is closed rather than the re-activation being detected afterwards:
-    // settling is suspended until the binding is actually gone.
-    const outermost = !withdrawing;
-    withdrawing = true;
-    try {
-      for (const record of components.values()) {
-        if (record.state === STATE.ACTIVE && record.requires.includes(key)) deactivate(record);
-      }
-      bindings.delete(key);
-      emit('withdrawn', { key });
-    } finally {
-      if (outermost) withdrawing = false;
-    }
-    queueSettle();
-  }
-
-  /** Fixpoint: activating one component can satisfy another, and so on. */
-  function settle() {
-    if (settling || disposed) return;
-    settling = true;
-    try {
-      for (let pass = 0; pass < 64; pass++) {
-        let moved = false;
-        for (const record of components.values()) {
-          if (record.error) continue;                       // failed stays failed
-          const ok = satisfied(record);
-          if (ok && record.state === STATE.INACTIVE) { activate(record); moved = true; }
-          else if (!ok && record.state === STATE.ACTIVE) { deactivate(record); moved = true; }
-        }
-        if (!moved) return;
-      }
-      throw new Error('registry: settle did not converge in 64 passes');
-    } finally {
-      settling = false;
-    }
-  }
-
-  function queueSettle() { if (!settling && !withdrawing) settle(); }
-
-  function register({ name, requires = [], apply }) {
-    if (typeof apply !== 'function') throw new TypeError('registry: component.apply required');
-    const record = {
-      id: `c${nextId++}`, name: name || 'anonymous', requires: [...requires], apply,
-      state: STATE.INACTIVE, disposers: [], provided: new Set(), error: null,
-    };
-    components.set(record.id, record);
-    queueSettle();
-    return {
-      get name() { return record.name; },
-      get state() { return record.state; },
-      get error() { return record.error; },
-      async dispose() {
-        const pending = deactivate(record);
-        components.delete(record.id);
-        await Promise.all(pending);
-        queueSettle();
-      },
-    };
-  }
-
-  return {
-    register,
-
-    /** Provide from outside any component — the root of the graph. */
-    provide(key, value) {
-      if (bindings.has(key)) throw new Error(`registry: '${key}' is already provided`);
-      bindings.set(key, { value, providerId: null });
-      emit('provided', { key });
-      queueSettle();
-      return () => withdrawSync(key);
-    },
-
-    get: (key) => (bindings.has(key) ? bindings.get(key).value : undefined),
-    has: (key) => bindings.has(key),
-    keys: () => [...bindings.keys()].sort(),
-
-    /**
-     * What is waiting, and on what. A dependency cycle simply leaves its components
-     * permanently inactive — unlike a deadlock that depends on the schedule, this is
-     * visible from the declarations alone, so a host can report it at load time.
-     */
-    pending() {
-      return [...components.values()]
-        .filter((r) => r.state === STATE.INACTIVE && !r.error)
-        .map((r) => ({ name: r.name, waitingFor: r.requires.filter((k) => !bindings.has(k)) }));
-    },
-
-    active: () => [...components.values()].filter((r) => r.state === STATE.ACTIVE).map((r) => r.name).sort(),
-
-    async dispose() {
-      disposed = true;
-      // Reverse registration order — the whole registry is itself one LIFO stack.
-      const all = [...components.values()].reverse();
-      const pending = all.flatMap((r) => deactivate(r));
-      components.clear();
-      bindings.clear();
-      await Promise.all(pending);
-    },
-  };
-}
-
-export const REGISTRY_STATES = STATE;
+const i=Object.freeze({INACTIVE:"inactive",ACTIVE:"active"});let A=0;function y({onEvent:p=null}={}){const r=new Map,a=new Map;let l=!1,c=!1,f=!1;const o=(e,t)=>{p&&p({event:e,...t})};function h(e){return{effect(t){const s=t();return typeof s=="function"&&e.disposers.push(s),()=>{const n=e.disposers.indexOf(s);n>=0&&(e.disposers.splice(n,1),s())}},provide(t,s){if(r.has(t))throw new Error(`registry: '${t}' is already provided`);r.set(t,{value:s,providerId:e.id}),e.provided.add(t),o("provided",{key:t,name:e.name}),e.disposers.push(()=>v(t)),u()},get(t){const s=r.get(t);return s?s.value:void 0},register(t){const s=m(t);return e.disposers.push(()=>s.dispose()),s},get name(){return e.name}}}function I(e){return e.requires.every(t=>r.has(t))}function w(e){e.state=i.ACTIVE;try{e.apply(h(e))}catch(t){e.state=i.INACTIVE,e.error=t,g(e),o("failed",{name:e.name,error:t});return}o("activated",{name:e.name})}function g(e){const t=[];for(;e.disposers.length>0;){const s=e.disposers.pop();try{t.push(s())}catch{}}return e.provided.clear(),t.filter(s=>s&&typeof s.then=="function")}function d(e){if(e.state!==i.ACTIVE)return[];e.state=i.INACTIVE;const t=g(e);return o("deactivated",{name:e.name}),t}function v(e){if(!r.get(e))return;const s=!f;f=!0;try{for(const n of a.values())n.state===i.ACTIVE&&n.requires.includes(e)&&d(n);r.delete(e),o("withdrawn",{key:e})}finally{s&&(f=!1)}u()}function E(){if(!(l||c)){l=!0;try{for(let e=0;e<64;e++){let t=!1;for(const s of a.values()){if(s.error)continue;const n=I(s);n&&s.state===i.INACTIVE?(w(s),t=!0):!n&&s.state===i.ACTIVE&&(d(s),t=!0)}if(!t)return}throw new Error("registry: settle did not converge in 64 passes")}finally{l=!1}}}function u(){!l&&!f&&E()}function m({name:e,requires:t=[],apply:s}){if(typeof s!="function")throw new TypeError("registry: component.apply required");const n={id:`c${A++}`,name:e||"anonymous",requires:[...t],apply:s,state:i.INACTIVE,disposers:[],provided:new Set,error:null};return a.set(n.id,n),u(),{get name(){return n.name},get state(){return n.state},get error(){return n.error},async dispose(){const T=d(n);a.delete(n.id),await Promise.all(T),u()}}}return{register:m,provide(e,t){if(r.has(e))throw new Error(`registry: '${e}' is already provided`);return r.set(e,{value:t,providerId:null}),o("provided",{key:e}),u(),()=>v(e)},get:e=>r.has(e)?r.get(e).value:void 0,has:e=>r.has(e),keys:()=>[...r.keys()].sort(),pending(){return[...a.values()].filter(e=>e.state===i.INACTIVE&&!e.error).map(e=>({name:e.name,waitingFor:e.requires.filter(t=>!r.has(t))}))},active:()=>[...a.values()].filter(e=>e.state===i.ACTIVE).map(e=>e.name).sort(),async dispose(){c=!0;const t=[...a.values()].reverse().flatMap(s=>d(s));a.clear(),r.clear(),await Promise.all(t)}}}const C=i;export{C as REGISTRY_STATES,y as createRegistry};

package/route-graph.js

@@ -1,115 +1 @@
-// The routing decision, as something you can LOOK at.
-//
-// A route currently explains itself in three lines of prose — which model, and two reasons.
-// That is enough to read one decision and not nearly enough to find a wrong one: it cannot
-// say what the alternatives were, how close they came, what was eliminated and why, or where
-// the turn would go next if this model declined. Those are exactly the questions asked when
-// the router picks something surprising, and answering them meant reading the code.
-//
-// So this derives the whole picture from one decision: every candidate with the numbers that
-// decided it, and the failover chain the turn WOULD walk. It is a derivation, not a renderer
-// — no DOM, no colours, no layout — so the side panel, the settings viewer, a desktop app or
-// a CLI can each draw the same graph their own way.
-//
-// THE CHAIN IS COMPUTED BY THE SAME CODE THAT WILL WALK IT (failoverOrder). A projection with
-// its own copy of the ordering would drift from the real thing, and a picture that lies about
-// what the router is going to do is worse than no picture at all.
-//
-// Class R: arithmetic over a decision that has already been made. No model call, no I/O.
-
-import { failoverOrder } from './router.js';
-
-const num = (v) => (Number.isFinite(v) ? v : null);
-
-/**
- * @param decision the object returned by route()/routeWith().
- * @param models   every candidate considered, eligible or not (the router's full model list).
- * @param hops     how far to project the failover chain. The default matches what a user can
- *                 actually sit through rather than the attempt cap.
- * @returns { chosen, strategy, reasons, nodes, chain, eliminated }
- *   nodes   — every candidate, ranked, with why it was eliminated when it was.
- *   chain   — [chosen, ...replacements], the walk each subsequent decline would take.
- */
-export function routeGraph({ decision = null, models = [], hops = 4 } = {}) {
-  if (!decision) return { chosen: null, strategy: null, reasons: [], constraints: [], nodes: [], chain: [], eliminated: 0 };
-
-  const eligible = decision.eligible || [];
-  const eligibleIds = new Set(eligible.map((m) => m.id));
-  const why = new Map((decision.rejected || []).map((r) => [r.id, r.why]));
-  // Rank is position in the router's own ordering — the thing that decided — so a node's
-  // place in the picture is the place it had in the decision, not a re-sort of our own.
-  const rankOf = new Map(eligible.map((m, i) => [m.id, i]));
-
-  const nodes = [...models]
-    .map((m) => ({
-      id: m.id,
-      label: m.label || m.id,
-      reach: m.reach,
-      classUsed: m.classUsed,
-      quality: num(m.quality),
-      costPer1k: num(m.costPer1k),
-      latencyMs: num(m.latencyMs),
-      // An order the user PINNED is a statement; one we inferred is a guess, and a picture
-      // that shows them identically hides why a model won.
-      order: num(m.providerRank),
-      orderPinned: !!m.orderPinned,
-      eligible: eligibleIds.has(m.id),
-      rank: rankOf.has(m.id) ? rankOf.get(m.id) : null,
-      chosen: m.id === decision.model?.id,
-      // Present only when it was ruled out — the whole point of showing the losers.
-      why: eligibleIds.has(m.id) ? null : (why.get(m.id) || 'not eligible'),
-    }))
-    .sort((a, b) => {
-      if (a.eligible !== b.eligible) return a.eligible ? -1 : 1;
-      if (a.eligible) return (a.rank ?? 0) - (b.rank ?? 0);
-      return String(a.label).localeCompare(String(b.label));
-    });
-
-  return {
-    chosen: decision.model?.id || null,
-    strategy: decision.strategy || null,
-    reasons: decision.reasons || [],
-    // WHY the constraints are what they are — which page capped the reach, what set the
-    // quality floor. "reach 'trusted' within 'trusted'" says a ceiling applied and not what
-    // imposed it, and an unexplained restriction is one people switch off wholesale.
-    constraints: decision.constraints || [],
-    nodes,
-    chain: projectChain(decision, hops),
-    eliminated: nodes.filter((n) => !n.eligible).length,
-  };
-}
-
-/**
- * Where the turn goes if this model declines, and the one after that.
- *
- * Walked hop by hop rather than read off the ranking, because that is what actually happens:
- * each replacement is chosen relative to the model that JUST failed, not to the original. A
- * chain read off `eligible` order would be a plausible-looking fiction — it is the ordering
- * for the first choice, not for the fourth.
- */
-export function projectChain(decision, hops = 4) {
-  const first = decision?.model;
-  if (!first) return [];
-  const chain = [{ id: first.id, label: first.label || first.id, reason: null }];
-  const tried = new Set([first.id]);
-  let current = first;
-
-  for (let i = 0; i < hops; i++) {
-    const rest = (decision.eligible || []).filter((m) => !tried.has(m.id));
-    if (!rest.length) break;
-    // 'server' — a provider saying no, which is the ordinary case. A retired model reorders
-    // this, but that is a fact discovered at failure time and cannot be known in advance.
-    const next = failoverOrder(rest, {
-      model: current.model,
-      quality: current.quality,
-      capabilities: current.capabilities,
-      classUsed: current.classUsed,
-      reason: 'server',
-    })[0];
-    if (!next) break;
-    chain.push({ id: next.id, label: next.label || next.id, reason: `closest to ${current.label || current.id}` });
-    tried.add(next.id);
-    current = next;
-  }
-  return chain;
-}
+import{failoverOrder as u}from"./router.js";const d=l=>Number.isFinite(l)?l:null;function h({decision:l=null,models:c=[],hops:t=4}={}){if(!l)return{chosen:null,strategy:null,reasons:[],constraints:[],nodes:[],chain:[],eliminated:0};const r=l.eligible||[],a=new Set(r.map(e=>e.id)),i=new Map((l.rejected||[]).map(e=>[e.id,e.why])),s=new Map(r.map((e,n)=>[e.id,n])),o=[...c].map(e=>({id:e.id,label:e.label||e.id,reach:e.reach,classUsed:e.classUsed,quality:d(e.quality),costPer1k:d(e.costPer1k),latencyMs:d(e.latencyMs),order:d(e.providerRank),orderPinned:!!e.orderPinned,eligible:a.has(e.id),rank:s.has(e.id)?s.get(e.id):null,chosen:e.id===l.model?.id,why:a.has(e.id)?null:i.get(e.id)||"not eligible"})).sort((e,n)=>e.eligible!==n.eligible?e.eligible?-1:1:e.eligible?(e.rank??0)-(n.rank??0):String(e.label).localeCompare(String(n.label)));return{chosen:l.model?.id||null,strategy:l.strategy||null,reasons:l.reasons||[],constraints:l.constraints||[],nodes:o,chain:b(l,t),eliminated:o.filter(e=>!e.eligible).length}}function b(l,c=4){const t=l?.model;if(!t)return[];const r=[{id:t.id,label:t.label||t.id,reason:null}],a=new Set([t.id]);let i=t;for(let s=0;s<c;s++){const o=(l.eligible||[]).filter(n=>!a.has(n.id));if(!o.length)break;const e=u(o,{model:i.model,quality:i.quality,capabilities:i.capabilities,classUsed:i.classUsed,reason:"server"})[0];if(!e)break;r.push({id:e.id,label:e.label||e.id,reason:`closest to ${i.label||i.id}`}),a.add(e.id),i=e}return r}export{b as projectChain,h as routeGraph};

package/route-strategies.js

@@ -1,232 +1,2 @@
-// HOW A MODEL IS CHOSEN — the strategies and the one step that is never optional.
-//
-// The routing CONTRACT (createModelRouter, signals, requirements, failover order) has lived
-// in this package since it was written; the DECISIONS layered on it — escalate hard work,
-// replace like with like, honour "use claude" — were typed in the extension, so the desktop
-// was about to copy them. They are pure functions of the candidates and the need, so they
-// belong here, and both clients build the same router from the same declarations.
-//
-// `needForTurn` builds the need from the turn's facts. The source guard (which page or
-// record the turn is about, and what that caps reach at) is INJECTED as `guard`, because
-// reading it means reading a client's settings; the ceiling itself is enforced here.
-
-import {
-  defineMiddleware, defineRouteStrategy, signalsFrom, requirementsFor, preferenceFor,
-  failoverOrder, pinnedOrderOf,
-} from './router.js';
-
-/**
- * Redaction is REQUIRED for anything that leaves the user's machine.
- *
- * Declared as middleware with `requiredFor` so the router refuses to route to a third party
- * when it is not active. That is the difference between "we always redact" as a habit and as
- * a property: a disabled plugin, a refactor or a new caller cannot quietly skip it.
- */
-export const redactionStep = defineMiddleware({
-  id: 'redaction',
-  label: 'Redaction',
-  stage: 'request',
-  priority: 10,   // before anything that reads the text
-  requiredFor: (model) => model.reach === 'any',
-  // The actual redaction still happens in streamChat's harness. This declares the
-  // REQUIREMENT; wiring the implementation through here is the next step, and doing both at
-  // once would mean changing what redaction does in the same commit that changes when it runs.
-  run: async (request) => request,
-});
-
-/**
- * Escalate when the task is actually hard.
- *
- * The router was picking the cheapest eligible model for everything, which is right for
- * "hello" and wrong for "draw a circle around Mickey" — a request needing spatial reasoning
- * and a structured payload went to a 26B model because it was free. Cost is the correct
- * tie-breaker among models that can all do the job; it is the wrong one when they cannot.
- *
- * Class R: length, code fences, image content and page tools are all readable for nothing.
- * The escalation itself costs no model call — only the answer does, and that is the point.
- */
-export const complexityStrategy = defineRouteStrategy({
-  id: 'escalate-on-complexity',
-  label: 'Escalate hard tasks',
-  classUsed: 'R',
-  decide: async (eligible, need) => {
-    const sig = need.signals;
-    // ASKED FOR NOTHING, ESCALATES TO NOTHING. This fired on 'hello' because the caller was
-    // passing `structured: structured || pageTools`, so every turn on a page with actions
-    // armed looked like exact structured work. Equipment is not demand — the same conflation
-    // that put a quality floor on a greeting, in a second place.
-    if (sig?.smalltalk) return null;
-    // NOR DOES BACKGROUND WORK ESCALATE. Dropping the quality floor for a topic pass and then
-    // letting escalation rank by quality anyway would move the same decision one step down
-    // and change nothing — the floor eliminated the local models, this would simply rank them
-    // last. Both read 'high' from the size of the material rather than the difficulty of the
-    // ask, so both have to abstain.
-    if (need.background) return null;
-    const hard = sig?.complexity === 'high' || sig?.modality === 'vision' || need.structured;
-    if (!hard) return null;   // no opinion on easy work — let cost decide
-    // Prefer a model that claims what this task actually wants. Not a hard filter: declaring
-    // "reasoning" required would eliminate every model on a setup where nobody has ticked
-    // the box, and an empty candidate list is a worse answer than a merely adequate model.
-    const wants = new Set();
-    if (sig?.complexity === 'high') wants.add('reasoning');
-    if (need.structured) wants.add('tools');
-    if (sig?.modality === 'vision') wants.add('vision');
-    if (sig?.approxTokens > 20_000) wants.add('long-context');
-    const fit = (m) => [...wants].filter((c) => m.capabilities.includes(c)).length;
-    const best = Math.max(...eligible.map(fit));
-    let shortlist = best > 0 ? eligible.filter((m) => fit(m) === best) : eligible;
-
-    // STRUCTURED WORK WANTS A MODEL, NOT AN AGENT.
-    //
-    // A canvas or spreadsheet adapter is one call: hand it the data, it applies it, done. A
-    // CLI agent runs its OWN loop — it explores, reads files, decides what to do next — and
-    // having applied the shapes correctly it carries on, because finishing is not something
-    // its loop is told about. A user watched the circle appear and then waited until they
-    // killed the process.
-    //
-    // Not a hard filter: on a setup with only agents, an agent that overruns still beats no
-    // answer.
-    if (need.structured) {
-      const models = shortlist.filter((m) => m.classUsed !== 'A');
-      if (models.length) shortlist = models;
-    }
-    // Rank by declared quality — the axis this strategy exists to judge — then by the ORDER
-    // the user set, and only then by cost. A model with an unknown quality sits mid-table
-    // rather than last, so a newly added model is not permanently skipped.
-    //
-    // ORDER BEFORE COST, and this is the fix for a real complaint: three CLI agents of
-    // identical quality, one of them pinned to Order 1, and escalation picked a different one
-    // because it is cheaper per 1k. A hand-set order is a statement — they can see the prices
-    // and chose anyway — and it was being honoured in the score path and nowhere else, so
-    // the moment any strategy had an opinion the user's own preference stopped existing.
-    //
-    // Still only a TIE-BREAK: quality decides first, so a genuinely better model beats the
-    // pinned one, and an INFERRED order stays below cost where a guess belongs.
-    const q = (m) => (Number.isFinite(m.quality) ? m.quality : 0.5);
-    return [...shortlist].sort((a, b) => q(b) - q(a)
-      || pinnedOrderOf(a) - pinnedOrderOf(b) || a.costPer1k - b.costPer1k);
-  },
-});
-
-/**
- * When a model declines, replace it with the closest thing available — not the cheapest.
- *
- * A frontier model that ran out of credits mid-task should be replaced by the same model at
- * another provider, or by something comparably capable. Falling back to a small local model
- * is how a drawing that was going well turns into a circle in the wrong place: the task did
- * not get easier when the provider said no.
- *
- * Ranked by closeness to what failed, in the order that actually matters:
- *   1. the SAME model somewhere else — identical capability, merely a different bill;
- *   2. a model with every capability the failed one had, best quality first;
- *   3. anything else, so the turn still completes rather than dying.
- */
-export const failoverStrategy = defineRouteStrategy({
-  id: 'failover-to-similar',
-  label: 'Replace like with like',
-  classUsed: 'R',
-  decide: async (eligible, need) => {
-    const failed = need.like;
-    if (!failed) return null;
-    // THE ORDERING ITSELF LIVES IN @chatpanel/events, because two things need it: this
-    // strategy, and the projected chain the trace draws before any of it happens. A picture
-    // computed by a second implementation would eventually disagree with the real failover,
-    // and one that lies about what the router will do is worse than no picture. The strategy
-    // is the thin part — knowing there IS something to replace.
-    return failoverOrder(eligible, failed);
-  },
-});
-
-/**
- * "use claude" is an instruction, not a topic.
- *
- * A user naming a model in their message was being ignored entirely — the router read
- * length, modality and tools, and not the one signal that is an explicit answer to the
- * question it was asking. Asking for a specific model and being given another is the most
- * annoying possible failure of a router, because it looks like the request was not read.
- *
- * DELIBERATELY CONSERVATIVE. Only imperative forms count — "use X", "with X", "ask X",
- * "switch to X" — so "tell me about claude" stays a question about Claude rather than a
- * routing instruction. A false positive here silently sends work to the wrong model, which
- * is worse than missing an unusual phrasing.
- *
- * It still cannot widen reach: like every strategy it only ever chooses among candidates the
- * hard constraints already allowed. A device-only request naming a cloud model still stays
- * on-device.
- */
-export const explicitModelStrategy = defineRouteStrategy({
-  id: 'named-by-user',
-  label: 'Use the model you asked for',
-  classUsed: 'R',
-  decide: async (eligible, need) => {
-    const text = String(need.requestText || '').toLowerCase();
-    if (!text) return null;
-    const directive = /\b(?:use|using|with|via|ask|switch to|route to|try)\s+([a-z0-9][a-z0-9.\- ]{1,28})/g;
-    const asked = [];
-    for (const m of text.matchAll(directive)) asked.push(m[1].trim());
-    if (!asked.length) return null;
-
-    const matches = eligible.filter((cand) => {
-      const names = [cand.label, cand.model, cand.id].filter(Boolean).map((x) => String(x).toLowerCase());
-      return asked.some((want) => names.some((n) => n.includes(want) || want.includes(n.split(' · ')[0])));
-    });
-    if (!matches.length) return null;   // named something we do not have? say nothing and let the rest decide
-    // WHICH ONE, when the name matches several. This took the FIRST match in score order, so
-    // "use claude" on a setup with three Claude routes picked whichever happened to score
-    // best — a cost-and-latency guess deciding a question the user had already answered
-    // twice: once by naming the model, and once by ordering the routes to it.
-    //
-    // Returned as a LIST rather than a single model, so the ones that also matched become the
-    // runners-up: if the first declines, failover replaces it with another route to the model
-    // that was actually asked for.
-    return [...matches].sort((a, b) => pinnedOrderOf(a) - pinnedOrderOf(b));
-  },
-});
-
-// Ordered deliberately: an explicit request outranks every heuristic, because the user has
-// answered the question the router was about to guess at. Failover next — a decline is newer
-// information than the preference that made the original choice. Escalation is the general
-// case.
-export const ROUTE_STRATEGIES = [explicitModelStrategy, failoverStrategy, complexityStrategy];
-export const ROUTE_MIDDLEWARE = [redactionStep];
-
-export function needForTurn({ capabilities = [], request = null, structured = false, pageTools = false, force = false, background = false, guard = null } = {}) {
-  const signals = request ? signalsFrom(request) : {};
-  // REQUIREMENTS FIRST. What the work needs eliminates candidates; cost and speed only order
-  // what survives. A preference lets an unsuitable model win once the better ones decline,
-  // which is exactly how a chain of five ended on one that could not do the job.
-  const req = requirementsFor(signals, { structured, pageTools, hasTools: capabilities.includes('tools'), background });
-  // WHERE IT CAME FROM IS A CEILING, NOT A PREFERENCE. Routing asked what the work needed and
-  // never asked what it was about, so an internal page was summarised by a public inference
-  // host. This narrows reach and can only narrow it — reach is never relaxed (see the
-  // relaxation order in the router), so no later step can trade it away for capability.
-  // WHICH AXIS THIS REQUEST CARES ABOUT, read from the request rather than fixed at
-  // 'balanced' for everything. A greeting means fast — no answer to "hi" is improved by a
-  // frontier model thinking about it. A refactor means good — three seconds saved on an
-  // answer that has to be redone is not a saving. It only ever ORDERS what already
-  // qualifies; `req` above is what eliminates.
-  const pref = preferenceFor(signals, {
-    structured,
-    minQuality: req.minQuality,
-    // The same fact requirementsFor was given: a turn carrying tools is one that might use
-    // them, so it is never "answer fast at any quality".
-    hasTools: capabilities.includes('tools'),
-    background,
-  });
-  return {
-    prefer: pref.prefer,
-    reach: guard ? guard.reach : 'any',
-    capabilities: [...new Set([...capabilities, ...req.required])],
-    minQuality: req.minQuality,
-    // Which requirements may be given up if nothing qualifies — never `tools`, and never
-    // reach. See requirementsFor.
-    negotiable: req.negotiable,
-    requirementReasons: [...(guard ? [...req.why, guard.why] : req.why), pref.why],
-    sourceGuard: guard,
-    signals,
-    requestText: request ? String(request.text || (request.messages || []).map((m) => m?.content || '').join('\n')).slice(-2000) : '',
-    structured,
-    force,
-    background,
-  };
-}
+import{defineMiddleware as m,defineRouteStrategy as f,signalsFrom as y,requirementsFor as h,preferenceFor as p,failoverOrder as x,pinnedOrderOf as u}from"./router.js";const g=m({id:"redaction",label:"Redaction",stage:"request",priority:10,requiredFor:i=>i.reach==="any",run:async i=>i}),w=f({id:"escalate-on-complexity",label:"Escalate hard tasks",classUsed:"R",decide:async(i,r)=>{const t=r.signals;if(t?.smalltalk||r.background||!(t?.complexity==="high"||t?.modality==="vision"||r.structured))return null;const n=new Set;t?.complexity==="high"&&n.add("reasoning"),r.structured&&n.add("tools"),t?.modality==="vision"&&n.add("vision"),t?.approxTokens>2e4&&n.add("long-context");const a=e=>[...n].filter(c=>e.capabilities.includes(c)).length,s=Math.max(...i.map(a));let l=s>0?i.filter(e=>a(e)===s):i;if(r.structured){const e=l.filter(c=>c.classUsed!=="A");e.length&&(l=e)}const o=e=>Number.isFinite(e.quality)?e.quality:.5;return[...l].sort((e,c)=>o(c)-o(e)||u(e)-u(c)||e.costPer1k-c.costPer1k)}}),S=f({id:"failover-to-similar",label:"Replace like with like",classUsed:"R",decide:async(i,r)=>{const t=r.like;return t?x(i,t):null}}),R=f({id:"named-by-user",label:"Use the model you asked for",classUsed:"R",decide:async(i,r)=>{const t=String(r.requestText||"").toLowerCase();if(!t)return null;const d=/\b(?:use|using|with|via|ask|switch to|route to|try)\s+([a-z0-9][a-z0-9.\- ]{1,28})/g,n=[];for(const s of t.matchAll(d))n.push(s[1].trim());if(!n.length)return null;const a=i.filter(s=>{const l=[s.label,s.model,s.id].filter(Boolean).map(o=>String(o).toLowerCase());return n.some(o=>l.some(e=>e.includes(o)||o.includes(e.split(" · ")[0])))});return a.length?[...a].sort((s,l)=>u(s)-u(l)):null}}),T=[R,S,w],v=[g];function q({capabilities:i=[],request:r=null,structured:t=!1,pageTools:d=!1,force:n=!1,background:a=!1,guard:s=null}={}){const l=r?y(r):{},o=h(l,{structured:t,pageTools:d,hasTools:i.includes("tools"),background:a}),e=p(l,{structured:t,minQuality:o.minQuality,hasTools:i.includes("tools"),background:a});return{prefer:e.prefer,reach:s?s.reach:"any",capabilities:[...new Set([...i,...o.required])],minQuality:o.minQuality,negotiable:o.negotiable,requirementReasons:[...s?[...o.why,s.why]:o.why,e.why],sourceGuard:s,signals:l,requestText:r?String(r.text||(r.messages||[]).map(c=>c?.content||"").join(`
+`)).slice(-2e3):"",structured:t,force:n,background:a}}export{v as ROUTE_MIDDLEWARE,T as ROUTE_STRATEGIES,w as complexityStrategy,R as explicitModelStrategy,S as failoverStrategy,q as needForTurn,g as redactionStep};