@cortexkit/common-auth 0.3.0 → 0.4.0

package/dist/logger/engine.js

@@ -8,53 +8,6 @@ const ORDER = {
     trace: 4,
 };
 const MAX_BYTES = 5 * 1024 * 1024;
-/**
- * Where lines are written, and the level floor, as the host supplied them.
- *
- * Both start unset. A host decides where its log lives — that decision reads
- * host environment variables and host directories, neither of which belongs in
- * shared code — and calls `initLogger` before it runs any command. Until then
- * every `log.*` call is a silent no-op: throwing would turn the first command a
- * host forgot to wire into a crash, and buffering would hold credential-bearing
- * lines for an init that may never arrive.
- */
-let logFileSource;
-let initLevelSource;
-let runtimeLevel;
-let redactor = createRedactor();
-let captureSink;
-/**
- * Point the logger at a host's file and level. Idempotent: calling it again
- * replaces both. A runtime level installed by `setLogLevel` is deliberately
- * left alone, because it is the operator's explicit choice and outranks the
- * floor a host computed at start-up.
- */
-export function initLogger(options) {
-    logFileSource = options.file;
-    initLevelSource = options.level;
-    redactor = createRedactor(options);
-    captureSink = options.captureSink;
-}
-export function setLogLevel(l) {
-    if (l === undefined || l in ORDER)
-        runtimeLevel = l;
-}
-function logFilePath() {
-    if (logFileSource === undefined)
-        return undefined;
-    const resolved = typeof logFileSource === 'function' ? logFileSource() : logFileSource;
-    return resolved || undefined;
-}
-function configuredLevel() {
-    if (runtimeLevel)
-        return runtimeLevel;
-    const floor = typeof initLevelSource === 'function' ? initLevelSource() : initLevelSource;
-    if (floor && floor in ORDER)
-        return floor;
-    return 'info';
-}
-let buffer = [];
-let timer;
 const ROTATE_KEEP = 3;
 function chmodPrivate(path) {
     try {
@@ -83,46 +36,6 @@ function rotateIfNeeded(f) {
         /* never throw */
     }
 }
-/**
- * Write whatever is buffered. Safe to call synchronously from a process-exit
- * handler, which is how each host drains the buffer on shutdown.
- */
-export function flushLogs() {
-    if (timer) {
-        clearTimeout(timer);
-        timer = undefined;
-    }
-    if (!buffer.length)
-        return;
-    let file;
-    try {
-        file = logFilePath();
-    }
-    catch {
-        buffer = [];
-        return;
-    }
-    const text = buffer.join('');
-    buffer = [];
-    if (!file)
-        return;
-    try {
-        rotateIfNeeded(file);
-        if (existsSync(file))
-            chmodPrivate(file);
-        appendFileSync(file, text, { encoding: 'utf8', mode: 0o600 });
-    }
-    catch {
-        /* never throw */
-    }
-}
-function schedule() {
-    if (!timer)
-        timer = setTimeout(() => {
-            timer = undefined;
-            flushLogs();
-        }, 500);
-}
 function safeSerialize(data) {
     try {
         return ` ${JSON.stringify(data)}`;
@@ -131,69 +44,199 @@ function safeSerialize(data) {
         return ' [unserializable]';
     }
 }
-function emit(channel, level, message, data) {
-    if (logFileSource === undefined)
-        return;
-    try {
-        if (ORDER[level] > ORDER[configuredLevel()])
+/**
+ * One logger's settings and buffer.
+ *
+ * Where lines are written and the level floor start unset unless `options`
+ * supplies them. A host decides where its log lives (that decision reads host
+ * environment variables and host directories, neither of which belongs in
+ * shared code) and configures the logger before it runs any command. Until
+ * then every `log.*` call is a silent no-op: throwing would turn the first
+ * command a host forgot to wire into a crash, and buffering would hold
+ * credential-bearing lines for a configuration that may never arrive.
+ */
+function createEngine(options) {
+    let logFileSource;
+    let initLevelSource;
+    let runtimeLevel;
+    let redactor = createRedactor();
+    let captureSink;
+    let buffer = [];
+    let timer;
+    function configure(next) {
+        logFileSource = next.file;
+        initLevelSource = next.level;
+        redactor = createRedactor(next);
+        captureSink = next.captureSink;
+    }
+    function setLogLevel(l) {
+        if (l === undefined || l in ORDER)
+            runtimeLevel = l;
+    }
+    function logFilePath() {
+        if (logFileSource === undefined)
+            return undefined;
+        const resolved = typeof logFileSource === 'function' ? logFileSource() : logFileSource;
+        return resolved || undefined;
+    }
+    function configuredLevel() {
+        if (runtimeLevel)
+            return runtimeLevel;
+        const floor = typeof initLevelSource === 'function'
+            ? initLevelSource()
+            : initLevelSource;
+        if (floor && floor in ORDER)
+            return floor;
+        return 'info';
+    }
+    function flushLogs() {
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        if (!buffer.length)
             return;
-        const scrubbedMessage = redactor.redactStrings(message);
-        let scrubbedData;
+        let file;
         try {
-            scrubbedData = redactor.redact(data);
+            file = logFilePath();
         }
         catch {
-            scrubbedData = '[unserializable]';
+            buffer = [];
+            return;
         }
-        const line = `[${new Date().toISOString()}] ${level.toUpperCase()} [${channel}] ${scrubbedMessage}` +
-            (data === undefined ? '' : safeSerialize(scrubbedData)) +
-            '\n';
-        // A failing observer must not prevent file logging or escape into the host.
+        const text = buffer.join('');
+        buffer = [];
+        if (!file)
+            return;
         try {
-            captureSink?.({
-                channel,
-                level,
-                message: scrubbedMessage,
-                data: scrubbedData,
-            });
+            rotateIfNeeded(file);
+            if (existsSync(file))
+                chmodPrivate(file);
+            appendFileSync(file, text, { encoding: 'utf8', mode: 0o600 });
+        }
+        catch {
+            /* never throw */
         }
-        catch { }
-        buffer.push(line);
-        if (buffer.length >= 50)
-            flushLogs();
-        else
-            schedule();
     }
-    catch {
-        // Provider and redaction failures must never turn diagnostics into a host crash.
+    function schedule() {
+        if (!timer)
+            timer = setTimeout(() => {
+                timer = undefined;
+                flushLogs();
+            }, 500);
     }
+    function emit(channel, level, message, data) {
+        if (logFileSource === undefined)
+            return;
+        try {
+            if (ORDER[level] > ORDER[configuredLevel()])
+                return;
+            const scrubbedMessage = redactor.redactStrings(message);
+            let scrubbedData;
+            try {
+                scrubbedData = redactor.redact(data);
+            }
+            catch {
+                scrubbedData = '[unserializable]';
+            }
+            const line = `[${new Date().toISOString()}] ${level.toUpperCase()} [${channel}] ${scrubbedMessage}` +
+                (data === undefined ? '' : safeSerialize(scrubbedData)) +
+                '\n';
+            // A failing observer must not prevent file logging or escape into the host.
+            try {
+                captureSink?.({
+                    channel,
+                    level,
+                    message: scrubbedMessage,
+                    data: scrubbedData,
+                });
+            }
+            catch { }
+            buffer.push(line);
+            if (buffer.length >= 50)
+                flushLogs();
+            else
+                schedule();
+        }
+        catch {
+            // Provider and redaction failures must never turn diagnostics into a host crash.
+        }
+    }
+    function createLogger(channel) {
+        return {
+            error: (m, d) => emit(channel, 'error', m, d),
+            warn: (m, d) => emit(channel, 'warn', m, d),
+            info: (m, d) => emit(channel, 'info', m, d),
+            debug: (m, d) => emit(channel, 'debug', m, d),
+            trace: (m, d) => emit(channel, 'trace', m, d),
+        };
+    }
+    function reset() {
+        buffer = [];
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        logFileSource = undefined;
+        initLevelSource = undefined;
+        runtimeLevel = undefined;
+        redactor = createRedactor();
+        captureSink = undefined;
+    }
+    if (options)
+        configure(options);
+    return { configure, createLogger, setLogLevel, flushLogs, reset };
+}
+/**
+ * A logger instance of its own, configured with `options`. A plugin whose
+ * copy of this module may be shared with another plugin in the same process
+ * uses this instead of `initLogger`, so neither replaces the other's file,
+ * level, redaction or capture sink.
+ */
+export function createLoggerInstance(options) {
+    const { configure, createLogger, setLogLevel, flushLogs } = createEngine(options);
+    return { configure, createLogger, setLogLevel, flushLogs };
+}
+/**
+ * The instance behind the module-level functions below, which keep the
+ * single-plugin API: one plugin per copy of this module calls `initLogger`
+ * and `createLogger` without holding an instance.
+ */
+const defaultEngine = createEngine();
+/**
+ * Point the module's default logger at a host's file and level, and return
+ * it. Idempotent: calling it again replaces both. A runtime level installed
+ * by `setLogLevel` is deliberately left alone, because it is the operator's
+ * explicit choice and outranks the floor a host computed at start-up.
+ */
+export function initLogger(options) {
+    defaultEngine.configure(options);
+    const { configure, createLogger, setLogLevel, flushLogs } = defaultEngine;
+    return { configure, createLogger, setLogLevel, flushLogs };
+}
+export function setLogLevel(l) {
+    defaultEngine.setLogLevel(l);
+}
+/**
+ * Write whatever the default logger has buffered. Safe to call synchronously
+ * from a process-exit handler, which is how each host drains the buffer on
+ * shutdown.
+ */
+export function flushLogs() {
+    defaultEngine.flushLogs();
 }
 export function createLogger(channel) {
-    return {
-        error: (m, d) => emit(channel, 'error', m, d),
-        warn: (m, d) => emit(channel, 'warn', m, d),
-        info: (m, d) => emit(channel, 'info', m, d),
-        debug: (m, d) => emit(channel, 'debug', m, d),
-        trace: (m, d) => emit(channel, 'trace', m, d),
-    };
+    return defaultEngine.createLogger(channel);
 }
 export async function flushForTest() {
-    flushLogs();
+    defaultEngine.flushLogs();
 }
 /**
- * Return the logger to its uninitialised state. Only a test needs this: a
- * single process runs every test file, so a file path left over from one test
- * would keep a later "logger was never initialised" case writing lines.
+ * Return the default logger to its uninitialised state. Only a test needs
+ * this: a single process runs every test file, so a file path left over from
+ * one test would keep a later "logger was never initialised" case writing
+ * lines.
  */
 export function resetLoggerForTest() {
-    buffer = [];
-    if (timer) {
-        clearTimeout(timer);
-        timer = undefined;
-    }
-    logFileSource = undefined;
-    initLevelSource = undefined;
-    runtimeLevel = undefined;
-    redactor = createRedactor();
-    captureSink = undefined;
+    defaultEngine.reset();
 }

package/dist/logger/index.d.ts

@@ -1,6 +1,6 @@
 export type { CaptureSink, LogTestRecord } from './capture-sink.js';
 export { createCaptureSink } from './capture-sink.js';
-export type { InitLoggerOptions, Level } from './engine.js';
-export { createLogger, flushForTest, flushLogs, initLogger, resetLoggerForTest, setLogLevel, } from './engine.js';
+export type { ChannelLogger, InitLoggerOptions, Level, LoggerInstance, } from './engine.js';
+export { createLogger, createLoggerInstance, flushForTest, flushLogs, initLogger, resetLoggerForTest, setLogLevel, } from './engine.js';
 export type { RedactionOptions, Redactor } from './redact.js';
 export { createRedactor, redact, redactStrings } from './redact.js';

package/dist/logger/index.js

@@ -1,3 +1,3 @@
 export { createCaptureSink } from './capture-sink.js';
-export { createLogger, flushForTest, flushLogs, initLogger, resetLoggerForTest, setLogLevel, } from './engine.js';
+export { createLogger, createLoggerInstance, flushForTest, flushLogs, initLogger, resetLoggerForTest, setLogLevel, } from './engine.js';
 export { createRedactor, redact, redactStrings } from './redact.js';

package/dist/opencode2/install.d.ts

@@ -20,9 +20,14 @@ export declare function applyHeaderEdits(target: Record<string, string>, edits:
  *   account, and refuses to retry once output has started.
  *
  * Attribution. An HTTP response belongs to the attempt whose `http.request`
- * produced its request; if the host hands back a different request object,
- * it belongs to the newest attempt of its session and kind only while that
- * attempt went out over HTTP and has no response yet. A WebSocket frame
+ * produced its request object, and to nothing else. The host hands
+ * `http.response` the request object the `http.request` hooks left, so a
+ * different object means a later hook replaced it; nothing then proves which
+ * send the response answers (an earlier attempt's send may still be in
+ * flight, and only the newest attempt of each session and kind is kept), and
+ * its feedback is dropped rather than guessed by recency. No marker can ride
+ * on the request instead: the host builds the wire request from that same
+ * object, so a marker would be sent to the provider. A WebSocket frame
  * belongs to the newest attempt of its session and kind only while that
  * attempt went out over WebSocket and has not ended: the host runs one
  * exchange at a time per session socket, so frames between one handshake

package/dist/opencode2/install.js

@@ -91,9 +91,14 @@ function applyHeaderEditsTo(target, edits) {
  *   account, and refuses to retry once output has started.
  *
  * Attribution. An HTTP response belongs to the attempt whose `http.request`
- * produced its request; if the host hands back a different request object,
- * it belongs to the newest attempt of its session and kind only while that
- * attempt went out over HTTP and has no response yet. A WebSocket frame
+ * produced its request object, and to nothing else. The host hands
+ * `http.response` the request object the `http.request` hooks left, so a
+ * different object means a later hook replaced it; nothing then proves which
+ * send the response answers (an earlier attempt's send may still be in
+ * flight, and only the newest attempt of each session and kind is kept), and
+ * its feedback is dropped rather than guessed by recency. No marker can ride
+ * on the request instead: the host builds the wire request from that same
+ * object, so a marker would be sent to the provider. A WebSocket frame
  * belongs to the newest attempt of its session and kind only while that
  * attempt went out over WebSocket and has not ended: the host runs one
  * exchange at a time per session socket, so frames between one handshake
@@ -107,6 +112,7 @@ export async function installOpenCode2Auth(ctx, adapter, options = {}) {
     const forbidden = (options.hostCredentials ?? [placeholderSecret(providerID)]).filter((value) => value !== '');
     const records = new Map();
     const byRequest = new WeakMap();
+    let warnedUnprovenResponse = false;
     const listeners = new Map();
     let seq = 0;
     const warn = (message, data) => {
@@ -232,7 +238,6 @@ export async function installOpenCode2Auth(ctx, adapter, options = {}) {
                     data,
                 },
             ...(transport === undefined ? {} : { transport }),
-            responded: false,
             outputStarted: false,
         };
         remember(rec);
@@ -374,15 +379,19 @@ export async function installOpenCode2Auth(ctx, adapter, options = {}) {
         });
     }, scoped));
     registrations.push(await ctx.session.hook('http.response', async (draft) => {
-        const latest = records.get(keyOf(draft.sessionID, draft.kind));
-        const rec = byRequest.get(draft.request) ??
-            (latest && !latest.responded ? liveOn(latest, 'http') : undefined);
-        const account = rec && accountOf(rec);
+        const rec = byRequest.get(draft.request);
+        if (!rec) {
+            if (!warnedUnprovenResponse) {
+                warnedUnprovenResponse = true;
+                warn('opencode2 auth dropped an http.response whose request it did not produce', { sessionID: draft.sessionID, kind: draft.kind });
+            }
+            return;
+        }
+        const account = accountOf(rec);
         const attempt = rec?.attempt;
         if (!rec || !account || !attempt)
             return;
         const original = draft.response;
-        rec.responded = true;
         rec.status = original.status;
         const quota = adapter.quotaFromHeaders?.(original.headers, original.status, attempt);
         if (quota !== undefined)

package/dist/opencode2/types.d.ts

@@ -189,9 +189,28 @@ export interface OpenCode2AuthAdapter<Q = unknown, A = unknown> {
      * The rewrite must be a deterministic function of the frame (stable for
      * the session): the host chains turns with `previous_response_id` by
      * diffing its own request as it was before this hook ran, so the server
-     * only stays in step when every frame is rewritten the same way. Do not
-     * touch `input` or `previous_response_id`. Adding or changing settings
-     * fields uniformly keeps the follow-up turn incremental.
+     * only stays in step when every frame is rewritten the same way. Never
+     * alter, drop or reorder the `input` items the host put in the frame, and
+     * never touch `previous_response_id`: the host's next frame assumes the
+     * server holds exactly what it sent. Adding items to `input`, or adding or
+     * changing settings fields, keeps the host's order and continuation when
+     * done the same way for every frame: the added items become part of the
+     * server's history and the follow-up turn stays incremental.
+     *
+     * What inserting `input` items into every frame does not keep is the
+     * equivalence of the two ways a history reaches the server (settings
+     * fields carry no history, so they are not affected). Incrementally, each
+     * frame carries only
+     * the new items, so an item the rewrite inserts into every frame lands at
+     * every network boundary of the accumulated history. After a reconnect the
+     * host replays the whole history in one frame, and the same rewrite
+     * inserts that item once. The two server-side histories, and their cache
+     * prefixes, then differ. A rewrite that only adds or changes settings
+     * fields is unaffected. An adapter that inserts `input` items must show,
+     * for its own insertion, that the accumulated incremental history equals
+     * the rewritten full replay (including across tool loops), or accept the
+     * divergence and name what it costs (a cache miss and a different prompt
+     * after every reconnect).
      *
      * It runs for every frame, including one no attempt can be tied to
      * (`attempt` is then `undefined`), so the rewrite never depends on

package/dist/quota/projection.d.ts

@@ -33,10 +33,17 @@ export interface ProjectedQuota {
 }
 /**
  * Resolves `map` for a request in `scope` (`all` or a model family). A family
- * request sees only its own family's keys and the `all` keys. Per label, a
- * family reading shadows the `all` entry; a family tombstone or absence
- * record says only that no family-specific limit exists, so it does not hide
- * an `all` entry for the same label and is used only when there is none.
+ * request sees only its own family's keys and the `all` keys.
+ *
+ * The label decides how a family limit relates to a general one. Under the
+ * same label, the family reading replaces the `all` reading: use this only
+ * when the provider's family figure is a more specific view of the same cap.
+ * Under different labels both limits are projected and every consumer judges
+ * both, so a family cap that applies on top of a general cap must be stored
+ * under its own label; otherwise the general cap is hidden from a family
+ * request. A family tombstone or absence record says only that no
+ * family-specific limit exists, so it does not hide an `all` entry for the
+ * same label and is used only when there is none.
  */
 export declare function projectQuota(map: QuotaMap | undefined, scope?: string): ProjectedQuota;
 export interface ExhaustionReset {

package/dist/quota/projection.js

@@ -61,10 +61,17 @@ function projectBudget(budget) {
 }
 /**
  * Resolves `map` for a request in `scope` (`all` or a model family). A family
- * request sees only its own family's keys and the `all` keys. Per label, a
- * family reading shadows the `all` entry; a family tombstone or absence
- * record says only that no family-specific limit exists, so it does not hide
- * an `all` entry for the same label and is used only when there is none.
+ * request sees only its own family's keys and the `all` keys.
+ *
+ * The label decides how a family limit relates to a general one. Under the
+ * same label, the family reading replaces the `all` reading: use this only
+ * when the provider's family figure is a more specific view of the same cap.
+ * Under different labels both limits are projected and every consumer judges
+ * both, so a family cap that applies on top of a general cap must be stored
+ * under its own label; otherwise the general cap is hidden from a family
+ * request. A family tombstone or absence record says only that no
+ * family-specific limit exists, so it does not hide an `all` entry for the
+ * same label and is used only when there is none.
  */
 export function projectQuota(map, scope = ALL_SCOPE) {
     const byLabel = new Map();

package/dist/routing/admission.js

@@ -6,7 +6,9 @@
 //
 // A marked or backed-off row is excluded before the gates. Stage 1 then
 // judges each remaining row alone, in gate order:
-//   1. an API-key row is admitted without consulting quota;
+//   1. an API-key row is admitted without consulting quota (a provider that
+//      offers paid rows only after its OAuth rows are spent leaves them out
+//      of `rows` until then);
 //   2. an OAuth row whose projection resolves no entry for the scope needs a
 //      first reading: refused, pull requested;
 //   3. a required label with no entry is unknown: refused, pull requested;

package/dist/routing/index.d.ts

@@ -4,5 +4,5 @@ export type { OrderedAttempt, OrderedPlacement, OrderedRoute, OrderedRouteInput,
 export { DEFAULT_FORMER_MAIN_ID, nextOrderedAttempt, orderForPlacement, resolveRoutingMode, routeOrdered, } from './ordered.js';
 export type { StickyPin } from './pins.js';
 export { isPinValid, pendingBytesForPins } from './pins.js';
-export type { PinAction, StickyBreakDecision, StickyRoute, StickyRouteInput, StickySelection, StickySelectionCandidate, StickySelectionInput, } from './sticky.js';
-export { decideStickyBreak, MIN_RESET_HOURS, MIN_WEIGHT, QUOTA_STALENESS_MS, routeSticky, STICKY_WINDOW_SLOTS, selectStickyCandidate, snapshotCheckedAt, sustainableWindowWeight, } from './sticky.js';
+export type { PinAction, StickyBreakDecision, StickyRoute, StickyRouteInput, StickySelection, StickySelectionCandidate, StickySelectionInput, StickyStatusClass, StickyStatusClassifier, } from './sticky.js';
+export { decideStickyBreak, defaultStickyStatusClass, MIN_RESET_HOURS, MIN_WEIGHT, QUOTA_STALENESS_MS, routeSticky, selectStickyCandidate, snapshotCheckedAt, sustainableWindowWeight, } from './sticky.js';

package/dist/routing/index.js

@@ -1,4 +1,4 @@
 export { admit, exclusionFor } from './admission.js';
 export { DEFAULT_FORMER_MAIN_ID, nextOrderedAttempt, orderForPlacement, resolveRoutingMode, routeOrdered, } from './ordered.js';
 export { isPinValid, pendingBytesForPins } from './pins.js';
-export { decideStickyBreak, MIN_RESET_HOURS, MIN_WEIGHT, QUOTA_STALENESS_MS, routeSticky, STICKY_WINDOW_SLOTS, selectStickyCandidate, snapshotCheckedAt, sustainableWindowWeight, } from './sticky.js';
+export { decideStickyBreak, defaultStickyStatusClass, MIN_RESET_HOURS, MIN_WEIGHT, QUOTA_STALENESS_MS, routeSticky, selectStickyCandidate, snapshotCheckedAt, sustainableWindowWeight, } from './sticky.js';

package/dist/routing/sticky.d.ts

@@ -4,12 +4,6 @@ import { type StickyPin } from './pins.js';
 export declare const QUOTA_STALENESS_MS: number;
 export declare const MIN_RESET_HOURS: number;
 export declare const MIN_WEIGHT = 0.000001;
-/**
- * How many window readings the selection primitives judge, as openai-auth's
- * primary and secondary slots did. The projection's first readings in its
- * order fill the slots; any further window is judged by admission only.
- */
-export declare const STICKY_WINDOW_SLOTS = 2;
 /** The projection's time, else the caller's cache-entry time. */
 export declare function snapshotCheckedAt(quota: ProjectedQuota | null | undefined, entryCheckedAt?: number): number | undefined;
 export type StickyBreakDecision = {
@@ -22,6 +16,23 @@ export type StickyBreakDecision = {
     window?: WindowRef;
     resetsAt?: string;
 };
+/**
+ * How the adapter reads a failed response's HTTP status for the break
+ * decision. `permanent` moves the session off its row before any quota is
+ * consulted; `transient` and `healthy` keep it unless the quota says the row
+ * is spent. A missing status means the request failed without a response.
+ */
+export type StickyStatusClass = 'permanent' | 'transient' | 'healthy';
+export type StickyStatusClassifier = (status: number | undefined) => StickyStatusClass;
+/**
+ * The status rule used when the adapter supplies none, carried from
+ * openai-auth: 401 and 403 are permanent; no response, 0, a non-finite
+ * status, 429 and 5xx are transient; anything else leaves the row healthy.
+ * A provider whose 403 can mean an organisation or model policy rather than
+ * a dead account supplies its own classifier and can fall back to this one
+ * for the statuses it does not single out.
+ */
+export declare function defaultStickyStatusClass(status: number | undefined): StickyStatusClass;
 /** Classifies whether a pinned session should leave its row after a failure. */
 export declare function decideStickyBreak(input: {
     quota: ProjectedQuota | null | undefined;
@@ -29,6 +40,8 @@ export declare function decideStickyBreak(input: {
     status?: number;
     now: number;
     killswitchPasses?: boolean;
+    /** Defaults to `defaultStickyStatusClass`. */
+    classifyStatus?: StickyStatusClassifier;
 }): StickyBreakDecision;
 export declare function sustainableWindowWeight(window: {
     remainingPercent: number;