@yaklabs-ai/plugin-sdk 0.13.10 → 0.14.1

package/dist/signals.d.ts

@@ -1,5 +1,5 @@
 /**
- * The `signals` a host with no Jev lane or no signals store binds: `observe` never touches the
+ * The `signals` a host with no System One or no signals store binds: `observe` never touches the
  * network, answers `invalid` for an input that breaks the recorded-name grammar exactly as a
  * real host would, and otherwise `unavailable` with `stored: false`; both reads answer
  * `unavailable` with reason `no-store`. So a caller's result handling does not change with host
@@ -10,35 +10,25 @@ export declare function createFallbackOnlySignals(): KayAppSignals;
 /** The engine over one plugin's `observe` (normally `app.signals.observe`). */
 export declare function createSignalEngine(observe: KayAppSignals["observe"]): SignalEngine;
 
-/**
- * The `invalid` observation `observe` answers when a name in `input` breaks the recorded-name
- * grammar, or `undefined` when every name can be recorded. A reader later types these names into
- * an address or a `where` filter, so a row that broke the grammar would be unaddressable or
- * unfilterable forever: the grammars are on {@link KayAppSignalsDetectorInput},
- * {@link KayAppSignalSource}, and {@link KayAppSignalsObserveInput}. Checked first, before any
- * digest, grant, store, or Jev call, by the host and by {@link createFallbackOnlySignals} alike.
- */
-export declare function invalidObservation(input: KayAppSignalsObserveInput): KayAppSignalObservation | undefined;
+declare type DecideAnswer = DecideBoolAnswer | DecideChoiceAnswer | DecideScoreAnswer;
 
-declare type JevAnswer = JevBoolAnswer | JevChoiceAnswer | JevScoreAnswer;
-
-declare interface JevBoolAnswer {
+declare interface DecideBoolAnswer {
     readonly type: "bool";
     /** P(yes), from 0 to 1. */
     readonly probability: number;
 }
 
 /** A yes/no question. `criteria` says what yes and what no mean; omit it to leave both open. */
-declare interface JevBoolQuestion {
+declare interface DecideBoolQuestion {
     readonly type: "bool";
-    readonly instructions: string;
+    readonly instructions: DecideInstructions;
     readonly criteria?: {
         readonly true: string;
         readonly false: string;
     };
 }
 
-declare interface JevChoiceAnswer<L extends string = string> {
+declare interface DecideChoiceAnswer<L extends string = string> {
     readonly type: "choice";
     readonly choice: L;
     readonly confidence: number;
@@ -47,59 +37,43 @@ declare interface JevChoiceAnswer<L extends string = string> {
 }
 
 /** A choice among labels. Each label maps to what it means; an empty string leaves it open. */
-declare interface JevChoiceQuestion<L extends string = string> {
+declare interface DecideChoiceQuestion<L extends string = string> {
     readonly type: "choice";
-    readonly instructions: string;
+    readonly instructions: DecideInstructions;
     readonly criteria: Readonly<Record<L, string>>;
 }
 
-declare type JevQuestion = JevBoolQuestion | JevChoiceQuestion | JevScoreQuestion;
+/** What a question asks: text, or a JSON object the client sends as its JSON text. */
+declare type DecideInstructions = string | object;
+
+declare type DecideQuestion = DecideBoolQuestion | DecideChoiceQuestion | DecideScoreQuestion;
 
-/** A rubric: questions keyed by the name each answer comes back under. */
-declare type JevQuestions = Readonly<Record<string, JevQuestion>>;
+/** Questions keyed by the name each answer comes back under. */
+declare type DecideQuestions = Readonly<Record<string, DecideQuestion>>;
 
-declare interface JevScoreAnswer {
+declare interface DecideScoreAnswer {
     readonly type: "score";
-    /** The expected score, from 0 to the number of rungs minus one. */
+    /** The expected level, from 0 to the number of levels minus one. */
     readonly score: number;
     readonly confidence: number;
 }
 
-/** A score over ordered rungs: the first criterion scores 0, the next 1, and so on. */
-declare interface JevScoreQuestion {
+/** A score over ordered levels: the first criterion scores 0, the next 1, and so on. */
+declare interface DecideScoreQuestion {
     readonly type: "score";
-    readonly instructions: string;
+    readonly instructions: DecideInstructions;
     readonly criteria: readonly string[];
 }
 
 /**
- * ---
- * responsibility: The plugin-facing CONTRACT for Jev typed-decision inference — the shape of
- *   `api.withJev` on both plugin SDK targets, the {@link JevClient} a `use` body receives, the
- *   question and answer vocabulary it speaks, and the fallback-only implementation a host
- *   without a Jev lane binds.
- * owns:
- *   - {@link WithJev}, {@link WithJevOptions}, {@link createFallbackOnlyWithJev}.
- *   - {@link JevClient}, the {@link JevQuestion} and {@link JevAnswer} vocabulary, and
- *     {@link JevCallError}.
- * does_not_own:
- *   - The wire. The host serves `classify` over whichever route the user's Jev provider order
- *     picks; a plugin never sees a vendor client, a vendor type, or a route.
- *   - Credential resolution, the `jev.use` decision, the Jev-branch budget, or usage accounting.
- *     Those are host-side (`@bonsai/agent-runtime`'s `kay/jev/`).
- * ---
- *
- * The vocabulary is Bonsai's own (SDK 0.12.0). Before it, `use` received TypeSafe's `TypeSafeClient`
- * and plugins coded against a vendor's types. It follows pi's classifier contract, which the host
- * runs Jev through: a yes/no question is `bool` and answers a `probability`, every instruction and
- * criterion is text, and the state is a JSON object.
- */
-/**
- * The state a rubric reads: a JSON object, never text or an array. Every value must survive
- * `JSON.stringify` unchanged (no functions or class instances), because it is sent as JSON.
- * Typed as `object` so a state declared as an interface fits without an index signature.
+ * The `invalid` observation `observe` answers when a name in `input` breaks the recorded-name
+ * grammar, or `undefined` when every name can be recorded. A reader later types these names into
+ * an address or a `where` filter, so a row that broke the grammar would be unaddressable or
+ * unfilterable forever: the grammars are on {@link KayAppSignalsDetectorInput},
+ * {@link KayAppSignalSource}, and {@link KayAppSignalsObserveInput}. Checked first, before any
+ * digest, grant, store, or Jev call, by the host and by {@link createFallbackOnlySignals} alike.
  */
-declare type JevState = object;
+export declare function invalidObservation(input: KayAppSignalsObserveInput): KayAppSignalObservation | undefined;
 
 /** One stored signal: the answers exactly as Jev gave them, and where the observed turn is. */
 export declare interface KayAppSignal {
@@ -127,8 +101,8 @@ export declare interface KayAppSignal {
     readonly inputDigest: string;
 }
 
-/** One stored answer: a {@link JevAnswer}, or a yes/no answer recorded before SDK 0.12.0. */
-export declare type KayAppSignalAnswer = JevAnswer | KayAppSignalNoulAnswer;
+/** One stored answer: a {@link DecideAnswer}, or a yes/no answer recorded before SDK 0.12.0. */
+export declare type KayAppSignalAnswer = DecideAnswer | KayAppSignalNoulAnswer;
 
 /** One version of one detector, under one rubric, as the catalog lists it. */
 export declare interface KayAppSignalDetector {
@@ -157,7 +131,7 @@ export declare interface KayAppSignalNoulAnswer {
 /**
  * The result of one observe call. `status` is the only field a caller must switch on:
  *
- * - `classified`: Jev answered; `answers` (one {@link JevAnswer} per question), `model`, and
+ * - `classified`: Jev answered; `answers` (one {@link DecideAnswer} per question), `model`, and
  *   `usage` are what the Jev call returned, and `stored` says whether the row landed in the
  *   durable store.
  * - `unavailable`: Jev could not answer (no key, refused grant, timeout, vendor error, or a
@@ -206,6 +180,25 @@ export declare interface KayAppSignalObservation {
     readonly recordedAtMs: number;
 }
 
+/** Per-call knobs for {@link KayAppSignals.observe}. Every field is optional; the host applies its
+ *  own default budget when none is given, so the Jev branch is never unbounded. */
+export declare interface KayAppSignalObserveOptions {
+    /**
+     * Explicit cancellation. Always propagates as a rejection, because an aborted call means
+     * "stop", not "record nothing and carry on".
+     */
+    readonly signal?: AbortSignal;
+    /** Bounds the Jev branch alone, measured from the call. */
+    readonly timeoutMs?: number;
+    /**
+     * Absolute epoch-ms hard deadline for the whole call. A deadline already passed rejects (like
+     * `signal`); one still ahead derives the Jev branch's budget from it.
+     */
+    readonly deadlineAt?: number;
+    /** Attribution slug for host usage accounting. Never sent to Jev. */
+    readonly purpose?: string;
+}
+
 /** One page of signals, oldest recorded first. */
 export declare interface KayAppSignalPage {
     readonly signals: readonly KayAppSignal[];
@@ -370,7 +363,7 @@ export declare interface KayAppSignalsObserveInput {
      * transcript the source points at. So the projection must be a pure function of the
      * transcript and the detector version, or the row's evidence cannot be reproduced.
      */
-    readonly state: JevState;
+    readonly state: KayAppSignalState;
     /**
      * The typed questions to answer. Stored once per digest. A
      * rubric asks 1 to 64 questions. Each name is an identifier (letters, digits, and `_`, not
@@ -379,8 +372,8 @@ export declare interface KayAppSignalsObserveInput {
      * characters with no `,`, `@`, or control or invisible character (`\p{C}`), and no whitespace
      * but single spaces between words, so a reader can copy it back exactly from rendered text.
      */
-    readonly questions: JevQuestions;
-    readonly options?: WithJevOptions;
+    readonly questions: DecideQuestions;
+    readonly options?: KayAppSignalObserveOptions;
 }
 
 /**
@@ -461,6 +454,9 @@ export declare interface KayAppSignalsSessionQuery {
     readonly limit?: number;
 }
 
+/** The state a signal's questions are asked over: any object, projected from the transcript. */
+export declare type KayAppSignalState = object;
+
 /**
  * What a signal is about, named by the recording plugin. The host stores both values and never
  * interprets them. A signal recorded without a subject has none; every reader treats it as before.
@@ -517,13 +513,13 @@ export declare interface SignalDefinition<I> {
     readonly version: string;
     /** What this signal is about, e.g. `turn`: a lowercase slug, stored on the row. */
     readonly subjectKind: string;
-    readonly questions: JevQuestions;
+    readonly questions: DecideQuestions;
     /**
      * The state Jev reads for this subject, or `undefined` when the subject carries nothing this
      * signal can judge (no row is recorded). Must be a pure function of the subject: the row keeps
      * only its digest.
      */
-    readonly project: (input: I) => JevState | undefined;
+    readonly project: (input: I) => KayAppSignalState | undefined;
     /**
      * The subject's identity across sessions. Required with `maxAgeMs`; without it a row is tied
      * to its own anchor only.
@@ -561,7 +557,7 @@ export declare interface SignalEngine {
      * `source` anchors every row to the transcript; `options` is passed to every observe, with
      * `purpose` set to `signals/<id>`.
      */
-    evaluate<I>(definitions: readonly SignalDefinition<I>[], input: I, source: KayAppSignalSource, options?: WithJevOptions): Promise<readonly SignalEvaluation[]>;
+    evaluate<I>(definitions: readonly SignalDefinition<I>[], input: I, source: KayAppSignalSource, options?: KayAppSignalObserveOptions): Promise<readonly SignalEvaluation[]>;
 }
 
 /**
@@ -611,24 +607,4 @@ export declare interface SignalUpstream<I> {
     readonly pass: readonly KayAppSignalsAnswerFilter[];
 }
 
-/** Per-call knobs for {@link WithJev}. Every field is optional; the host applies its own default
- *  budget when none is given, so the Jev branch is never unbounded. */
-declare interface WithJevOptions {
-    /**
-     * Explicit cancellation. Always propagates as a rejection; never substituted with `fallback`,
-     * because an aborted call means "stop", not "use the cheaper path".
-     */
-    readonly signal?: AbortSignal;
-    /** Bounds the Jev branch alone, measured from the call. */
-    readonly timeoutMs?: number;
-    /**
-     * Absolute epoch-ms hard deadline for the WHOLE call, `fallback` included. A deadline already
-     * passed rejects (like `signal`); one still ahead derives the Jev branch's budget from it and
-     * keeps a small reserve so `fallback` has a window to run.
-     */
-    readonly deadlineAt?: number;
-    /** Attribution slug for host usage accounting. Never sent to Jev. */
-    readonly purpose?: string;
-}
-
 export { }

package/dist/signals.js

@@ -120,7 +120,7 @@ function createFallbackOnlySignals() {
   return {
     observe: (input) => Promise.resolve(invalidObservation(input) ?? {
       status: "unavailable",
-      reason: "no-jev-lane",
+      reason: "no-system-one",
       detector: { ...input.detector, rubricDigest: "" },
       source: input.source,
       stored: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaklabs-ai/plugin-sdk",
-  "version": "0.13.10",
+  "version": "0.14.1",
   "description": "The Kay plugin SDK — types and helpers for authoring a Kay directory plugin.",
   "author": "YakLabs",
   "type": "module",
@@ -17,6 +17,10 @@
       "types": "./dist/kay-app.d.ts",
       "default": "./dist/kay-app.js"
     },
+    "./kay-app/session-summary": {
+      "types": "./dist/kay-app-session-summary.d.ts",
+      "default": "./dist/kay-app-session-summary.js"
+    },
     "./fs": {
       "types": "./dist/fs.d.ts",
       "default": "./dist/fs.js"
@@ -29,10 +33,6 @@
       "types": "./dist/disclosure.d.ts",
       "default": "./dist/disclosure.js"
     },
-    "./jev": {
-      "types": "./dist/jev.d.ts",
-      "default": "./dist/jev.js"
-    },
     "./signals": {
       "types": "./dist/signals.d.ts",
       "default": "./dist/signals.js"

package/skills/directory-plugin-authoring/SKILL.md

@@ -101,7 +101,7 @@ a plugin you install yourself.
 ## The SDK resolution contract
 
 - Plugin source imports `@bonsai/plugin-sdk/<subpath>` as a **bare specifier**
-  (`@bonsai/plugin-sdk/kay-agent`, `/kay-agent/testing`, `/kay-app`, `/disclosure`, `/fs`, `/jev`,
+  (`@bonsai/plugin-sdk/kay-agent`, `/kay-agent/testing`, `/kay-app`, `/disclosure`, `/fs`,
   `/signals`, `/phase-shift`, `/time`, `/transcript`, `/transcript-review`, `/agent-conversation`,
   `/app-data`, `/vendored-mcp`, `/system-one`, `/zod` — only declared exports exist). Take `z`
   from the SDK (`/kay-agent`, or `/zod` in code a page also loads), never from `zod` itself.

package/dist/jev.d.ts

@@ -1,203 +0,0 @@
-/**
- * The `withJev` a host with no Jev lane binds: `use` is never called, no client is ever built,
- * and no network is ever touched. It keeps the cancellation contract identical to the real
- * wrapper's so a caller's `signal`/`deadlineAt` handling does not change with host composition.
- *
- * Deliberately here rather than in the runtime: this is the DEFAULT for the SDK's own host
- * factory, which cannot import the runtime uphill. The runtime also delegates fallback execution
- * here, so both paths share cancellation, deadline enforcement, and cleanup.
- */
-export declare function createFallbackOnlyWithJev(): WithJev;
-
-export declare type JevAnswer = JevBoolAnswer | JevChoiceAnswer | JevScoreAnswer;
-
-/** The answer shape one question gets back. */
-export declare type JevAnswerFor<Q> = Q extends JevBoolQuestion ? JevBoolAnswer : Q extends JevChoiceQuestion<infer L> ? JevChoiceAnswer<L> : Q extends JevScoreQuestion ? JevScoreAnswer : never;
-
-export declare interface JevBoolAnswer {
-    readonly type: "bool";
-    /** P(yes), from 0 to 1. */
-    readonly probability: number;
-}
-
-/** A yes/no question. `criteria` says what yes and what no mean; omit it to leave both open. */
-export declare interface JevBoolQuestion {
-    readonly type: "bool";
-    readonly instructions: string;
-    readonly criteria?: {
-        readonly true: string;
-        readonly false: string;
-    };
-}
-
-/**
- * The one error `classify` rejects with. It carries a classification, never the provider's own
- * message or body: those can echo the request state, and this error reaches logs.
- */
-export declare class JevCallError extends Error {
-    readonly transport: JevTransport;
-    readonly kind: JevCallErrorKind;
-    /** The final attempt's HTTP status, when a response arrived. */
-    readonly status: number | undefined;
-    constructor(init: {
-        readonly transport: JevTransport;
-        readonly kind: JevCallErrorKind;
-        readonly status?: number | undefined;
-    });
-}
-
-/**
- * Why a Jev call failed, as a closed set:
- *
- * - `http`: the route answered with an error status (`status` says which).
- * - `too-large`: the route refused the request's size (413, or a 400 naming the token limit).
- * - `network`: no response arrived.
- * - `aborted`: the call was cancelled.
- * - `invalid-answer`: the route answered, but not with an answer for every asked question.
- */
-export declare type JevCallErrorKind = "http" | "too-large" | "network" | "aborted" | "invalid-answer";
-
-export declare interface JevChoiceAnswer<L extends string = string> {
-    readonly type: "choice";
-    readonly choice: L;
-    readonly confidence: number;
-    /** P(label) for every offered label. */
-    readonly probabilities: Readonly<Record<L, number>>;
-}
-
-/** A choice among labels. Each label maps to what it means; an empty string leaves it open. */
-export declare interface JevChoiceQuestion<L extends string = string> {
-    readonly type: "choice";
-    readonly instructions: string;
-    readonly criteria: Readonly<Record<L, string>>;
-}
-
-/** One answered request: every asked question has an answer of its own kind. */
-export declare interface JevClassification<Q extends JevQuestions = JevQuestions> {
-    /** The Jev model the host asked. */
-    readonly model: string;
-    readonly answers: {
-        readonly [K in keyof Q]: JevAnswerFor<Q[K]>;
-    };
-    /** Token counts, when the route reported them. */
-    readonly usage?: {
-        readonly inputTokens: number;
-        readonly outputTokens: number;
-    };
-}
-
-export declare interface JevClassifyRequest<Q extends JevQuestions = JevQuestions> {
-    readonly state: JevState;
-    readonly questions: Q;
-}
-
-/**
- * The Jev client a `use` body receives. `classify` either resolves with an answer for every
- * asked question, each of its question's kind, or rejects with a {@link JevCallError}; it never
- * resolves with a partial or substituted answer.
- */
-export declare interface JevClient {
-    classify<const Q extends JevQuestions>(request: JevClassifyRequest<Q>, options?: {
-        readonly signal?: AbortSignal;
-    }): Promise<JevClassification<Q>>;
-}
-
-export declare type JevQuestion = JevBoolQuestion | JevChoiceQuestion | JevScoreQuestion;
-
-/** A rubric: questions keyed by the name each answer comes back under. */
-export declare type JevQuestions = Readonly<Record<string, JevQuestion>>;
-
-export declare interface JevScoreAnswer {
-    readonly type: "score";
-    /** The expected score, from 0 to the number of rungs minus one. */
-    readonly score: number;
-    readonly confidence: number;
-}
-
-/** A score over ordered rungs: the first criterion scores 0, the next 1, and so on. */
-export declare interface JevScoreQuestion {
-    readonly type: "score";
-    readonly instructions: string;
-    readonly criteria: readonly string[];
-}
-
-/**
- * ---
- * responsibility: The plugin-facing CONTRACT for Jev typed-decision inference — the shape of
- *   `api.withJev` on both plugin SDK targets, the {@link JevClient} a `use` body receives, the
- *   question and answer vocabulary it speaks, and the fallback-only implementation a host
- *   without a Jev lane binds.
- * owns:
- *   - {@link WithJev}, {@link WithJevOptions}, {@link createFallbackOnlyWithJev}.
- *   - {@link JevClient}, the {@link JevQuestion} and {@link JevAnswer} vocabulary, and
- *     {@link JevCallError}.
- * does_not_own:
- *   - The wire. The host serves `classify` over whichever route the user's Jev provider order
- *     picks; a plugin never sees a vendor client, a vendor type, or a route.
- *   - Credential resolution, the `jev.use` decision, the Jev-branch budget, or usage accounting.
- *     Those are host-side (`@bonsai/agent-runtime`'s `kay/jev/`).
- * ---
- *
- * The vocabulary is Bonsai's own (SDK 0.12.0). Before it, `use` received TypeSafe's `TypeSafeClient`
- * and plugins coded against a vendor's types. It follows pi's classifier contract, which the host
- * runs Jev through: a yes/no question is `bool` and answers a `probability`, every instruction and
- * criterion is text, and the state is a JSON object.
- */
-/**
- * The state a rubric reads: a JSON object, never text or an array. Every value must survive
- * `JSON.stringify` unchanged (no functions or class instances), because it is sent as JSON.
- * Typed as `object` so a state declared as an interface fits without an index signature.
- */
-export declare type JevState = object;
-
-/** The route a Jev call took: the user's own TypeSafe key, or Bonsai's hosted gateway. */
-export declare type JevTransport = "direct" | "hosted";
-
-/**
- * Run `use` against a live Jev client, falling back to `fallback` whenever Jev cannot serve the
- * call. The wrapper exists so a feature can ASK for a typed decision without ever depending on
- * one: `fallback` is required, and it runs whenever no provider in the user's Jev provider
- * order holds a usable credential, the user has not granted `jev.use`, the branch exceeds its budget, `use` throws, or
- * `use` declines by returning `undefined`. With valid options, this rejects on an explicit
- * `signal` abort, reaching `deadlineAt`, or `fallback` itself throwing.
- *
- * ALWAYS PRESENT on the plugin API, on every host. A host that composed no Jev lane binds
- * {@link createFallbackOnlyWithJev}, so a caller never branches on availability — branching is
- * exactly how a fallback gets skipped.
- *
- * `jev` is a {@link JevClient} on the host's Jev model. It is valid only for the duration of
- * the callback: a reference retained past `use`'s scope is refused at the transport, and an
- * in-flight request is aborted when the call stops waiting.
- * The callback itself is ABANDONED, not interrupted — a host cannot stop arbitrary JavaScript
- * that is already running, so `use` must not perform side effects it would mind completing
- * unobserved. The same applies to a running fallback: abort/deadline stops waiting for it but
- * cannot interrupt its JavaScript.
- */
-export declare type WithJev = <T>(
-/** Return `undefined` to decline (the fallback runs). A feature whose real result can itself be
- *  `undefined` should return `null` or its own wrapper type instead. */
-use: (jev: JevClient) => T | undefined | PromiseLike<T | undefined>, 
-/** Required. The behaviour the feature has without Jev. */
-fallback: () => T | PromiseLike<T>, options?: WithJevOptions) => Promise<T>;
-
-/** Per-call knobs for {@link WithJev}. Every field is optional; the host applies its own default
- *  budget when none is given, so the Jev branch is never unbounded. */
-export declare interface WithJevOptions {
-    /**
-     * Explicit cancellation. Always propagates as a rejection; never substituted with `fallback`,
-     * because an aborted call means "stop", not "use the cheaper path".
-     */
-    readonly signal?: AbortSignal;
-    /** Bounds the Jev branch alone, measured from the call. */
-    readonly timeoutMs?: number;
-    /**
-     * Absolute epoch-ms hard deadline for the WHOLE call, `fallback` included. A deadline already
-     * passed rejects (like `signal`); one still ahead derives the Jev branch's budget from it and
-     * keeps a small reserve so `fallback` has a window to run.
-     */
-    readonly deadlineAt?: number;
-    /** Attribution slug for host usage accounting. Never sent to Jev. */
-    readonly purpose?: string;
-}
-
-export { }

package/dist/jev.js

@@ -1,77 +0,0 @@
-// packages/plugin-sdk/dist/jev.js
-var JevCallError = class extends Error {
-  transport;
-  kind;
-  /** The final attempt's HTTP status, when a response arrived. */
-  status;
-  constructor(init) {
-    super(`Jev call failed on the ${init.transport} route: ${init.kind}${init.status === void 0 ? "" : ` (HTTP ${init.status})`}.`);
-    this.name = "JevCallError";
-    this.transport = init.transport;
-    this.kind = init.kind;
-    this.status = init.status;
-  }
-};
-function createFallbackOnlyWithJev() {
-  return async (_use, fallback, options = {}) => {
-    if (typeof fallback !== "function") {
-      throw new TypeError("withJev requires a `fallback` function as its second argument.");
-    }
-    const { signal, deadlineAt } = options;
-    if (deadlineAt !== void 0 && !Number.isFinite(deadlineAt)) {
-      throw new TypeError("withJev's `deadlineAt` must be a finite epoch-ms timestamp.");
-    }
-    const assertWithinBoundaries = () => {
-      if (signal?.aborted === true) {
-        throw signal.reason ?? new DOMException("Aborted", "AbortError");
-      }
-      if (deadlineAt !== void 0 && Date.now() >= deadlineAt) {
-        throw new Error("withJev's deadline has passed.");
-      }
-    };
-    assertWithinBoundaries();
-    let timer;
-    let onAbort;
-    const stopped = new Promise((_resolve, reject) => {
-      if (signal !== void 0) {
-        onAbort = () => reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-      if (deadlineAt !== void 0) {
-        const checkDeadline = () => {
-          const remaining = deadlineAt - Date.now();
-          if (remaining <= 0) {
-            reject(new Error("withJev's deadline has passed."));
-          } else {
-            timer = setTimeout(checkDeadline, Math.min(remaining, 2147483647));
-          }
-        };
-        checkDeadline();
-      }
-    });
-    try {
-      const result = await Promise.race([
-        Promise.resolve().then(() => {
-          assertWithinBoundaries();
-          return fallback();
-        }),
-        stopped
-      ]);
-      assertWithinBoundaries();
-      return result;
-    } catch (error) {
-      assertWithinBoundaries();
-      throw error;
-    } finally {
-      if (timer !== void 0)
-        clearTimeout(timer);
-      if (signal !== void 0 && onAbort !== void 0) {
-        signal.removeEventListener("abort", onAbort);
-      }
-    }
-  };
-}
-export {
-  JevCallError,
-  createFallbackOnlyWithJev
-};