@effect-uai/core 0.17.0 → 0.19.0-dev-20261109183959

package/dist/ToolResult-BsYQRjmW.d.mts

@@ -1,152 +0,0 @@
-import { b as ToolCallOutput, y as ToolCall } from "./Items-C7MyrYPX.mjs";
-import { Data } from "effect";
-declare namespace ToolResult_d_exports {
-  export { ToolResult, cancelled, denied, executionError, failed, isFailure, isOk, nonLocalTool, serializeValue, toToolCallOutput, validationError };
-}
-type ToolResult = Data.TaggedEnum<{
-  Ok: {
-    readonly call_id: string;
-    readonly tool: string;
-    readonly value: unknown;
-  };
-  Failure: {
-    readonly call_id: string;
-    readonly tool: string;
-    readonly kind: string;
-    readonly reason?: string;
-  };
-}>;
-/**
- * Namespace of constructors, type guards, and matchers for `ToolResult`,
- * provided by `Data.taggedEnum`. Use `ToolResult.$is("Ok")` for type
- * narrowing and `ToolResult.$match({ Ok, Failure })` for exhaustive
- * pattern matching. Synthetic-result helpers (`denied`, `cancelled`,
- * `executionError`, `failed`) below are kinder constructors than the
- * raw `ToolResult.Failure(...)`.
- */
-declare const ToolResult: {
-  readonly $is: <Tag extends "Failure" | "Ok">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Failure";
-    readonly call_id: string;
-    readonly tool: string;
-    readonly kind: string;
-    readonly reason?: string;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Ok";
-    readonly call_id: string;
-    readonly tool: string;
-    readonly value: unknown;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Failure" | "Ok"]: (args: Extract<{
-      readonly _tag: "Failure";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly kind: string;
-      readonly reason?: string;
-    } | {
-      readonly _tag: "Ok";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly value: unknown;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Failure";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly kind: string;
-      readonly reason?: string;
-    } | {
-      readonly _tag: "Ok";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly value: unknown;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Failure" | "Ok"]>>;
-    <Cases extends { readonly [Tag in "Failure" | "Ok"]: (args: Extract<{
-      readonly _tag: "Failure";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly kind: string;
-      readonly reason?: string;
-    } | {
-      readonly _tag: "Ok";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly value: unknown;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Failure";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly kind: string;
-      readonly reason?: string;
-    } | {
-      readonly _tag: "Ok";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly value: unknown;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Failure" | "Ok"]>>;
-  };
-  readonly Failure: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Failure";
-    readonly call_id: string;
-    readonly tool: string;
-    readonly kind: string;
-    readonly reason?: string;
-  }, "_tag">;
-  readonly Ok: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Ok";
-    readonly call_id: string;
-    readonly tool: string;
-    readonly value: unknown;
-  }, "_tag">;
-};
-declare const isOk: (u: unknown) => u is {
-  readonly _tag: "Ok";
-  readonly call_id: string;
-  readonly tool: string;
-  readonly value: unknown;
-};
-declare const isFailure: (u: unknown) => u is {
-  readonly _tag: "Failure";
-  readonly call_id: string;
-  readonly tool: string;
-  readonly kind: string;
-  readonly reason?: string;
-};
-declare const failed: (call: ToolCall, kind: string, reason?: string) => ToolResult;
-/** Explicit user/policy rejection. */
-declare const denied: (call: ToolCall, reason?: string) => ToolResult;
-/** Implicit non-answer (follow-up, inactivity, abort). */
-declare const cancelled: (call: ToolCall, reason?: string) => ToolResult;
-/** Tool's own execution failed (JSON parse error, runtime crash). */
-declare const executionError: (call: ToolCall, reason: string) => ToolResult;
-/**
- * The model called a tool that is visible to it but has no local executor — a
- * provider-hosted, signal, or interaction tool routed through `Toolkit.run`.
- * Distinct from `unknown_tool` (no such tool at all): the loop is expected to
- * intercept these kinds before execution, so this kind flags a missing handler.
- */
-declare const nonLocalTool: (call: ToolCall, reason?: string) => ToolResult;
-/**
- * The model's `arguments` failed the tool's input schema. Distinct kind from
- * `execution_error` so recipes can tell a contract violation apart from a
- * runtime crash.
- */
-declare const validationError: (call: ToolCall, reason?: string) => ToolResult;
-/**
- * Serialize a success value for the wire. A `string` passes through raw
- * (models read plain text best; JSON.stringify would quote and escape it);
- * `undefined` becomes `"null"`; anything else is JSON.
- */
-declare const serializeValue: (value: unknown) => string;
-declare const toToolCallOutput: (r: ToolResult) => ToolCallOutput;
-//#endregion
-export { executionError as a, isOk as c, toToolCallOutput as d, validationError as f, denied as i, nonLocalTool as l, ToolResult_d_exports as n, failed as o, cancelled as r, isFailure as s, ToolResult as t, serializeValue as u };
-//# sourceMappingURL=ToolResult-BsYQRjmW.d.mts.map

package/dist/ToolResult-BsYQRjmW.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ToolResult-BsYQRjmW.d.mts","names":[],"sources":["../src/tool/ToolResult.ts"],"mappings":";;;;;KAqBY,aAAa,KAAK;EAC5B;aACW;aACA;aACA;;EAEX;aACW;aACA;aACA;aACA;;;;;;;;;;;cAYA;;;aAfS;aACH;aACA;aACG;;;;;aARA;aACH;aACC;;;;;;;eAGE;eACH;eACA;eACG;;;eARA;eACH;eACC;;;;;;;;;;;;;;;;;eAGE;eACH;eACA;eACG;;;eARA;eACH;eACC;;;;;;;;;;;;;;;;;;aAGE;aACH;aACA;aACG;;;;aARA;aACH;aACC;;;cAoBP,OAAI,eAAA;;WAtBK;WACH;WACC;;cAqBP,YAAS,eAAA;;WAlBA;WACH;WACA;WACG;;cAqBT,SAAM,MAAU,UAAQ,cAAc,oBAAoB;;cAS1D,SAAM,MAAU,UAAQ,oBAAoB;;cAI5C,YAAS,MAAU,UAAQ,oBAAoB;;cAI/C,iBAAc,MAAU,UAAQ,mBAAmB;;;;;;;cASnD,eAAY,MAAU,UAAQ,oBAAoB;;;;;;cAYlD,kBAAe,MAAU,UAAQ,oBAAoB;;;;;;cAYrD,iBAAc;cAOd,mBAAgB,GAAO,eAAa"}

package/dist/Toolkit-tlL0F2YR.d.mts

@@ -1,193 +0,0 @@
-import { o as HistoryItem, y as ToolCall } from "./Items-C7MyrYPX.mjs";
-import { a as Emit, c as SignalTool, d as ToolE, h as ToolR, l as Tool, n as AnyTool, o as InteractionTool, p as ToolFailed, s as ProviderTool, u as ToolDescriptor } from "./Tool-BF78QWtn.mjs";
-import { Turn } from "./domain/Turn.mjs";
-import { r as Step } from "./Loop-ChpaO-ya.mjs";
-import { t as ToolResult } from "./ToolResult-BsYQRjmW.mjs";
-import { t as ToolEvent } from "./ToolEvent-Di4a723B.mjs";
-import { Cause, Effect, Stream } from "effect";
-declare namespace Toolkit_d_exports {
-  export { DuplicateToolName, ExecuteOptions, Middleware, NoDuplicateNames, ToolMap, Toolkit, ToolkitE, ToolkitR, UniqueTools, appendToolResults, collectResults, compose, continueWithResults, describeFailures, descriptors, fromArray, make, makeNamespaced, namespace, run, wrap };
-}
-type ToolMap = Record<string, AnyTool>;
-type Toolkit<Tools extends ToolMap = ToolMap> = Tools;
-declare const make: <const Tools extends ReadonlyArray<AnyTool>>(...tools: UniqueTools<Tools>) => Toolkit<{ [T in Tools[number] as T["name"]]: T; }>;
-/**
- * Build a toolkit from a dynamically-sourced array (MCP server, plugin). Names
- * are not validated (MCP legitimately uses dots / >64 chars — sanitize at the
- * provider adapter); same-named tools resolve last-wins. Cross-source clashes
- * are caught by `compose`.
- */
-declare const fromArray: (tools: ReadonlyArray<AnyTool>) => Toolkit;
-/** Render the provider-facing descriptors for a toolkit on demand. */
-declare const descriptors: (toolkit: Toolkit) => ReadonlyArray<ToolDescriptor>;
-/**
- * Union of every tool's `R` requirements in a toolkit. Surfaced by `run` so the
- * loop's stream type carries the services tools need through to `Effect.provide`.
- *
- * The `ToolMap extends T` guard yields `never` for the wide `Toolkit` type (a
- * toolkit passed through an untyped boundary, where the requirements aren't
- * statically known) instead of `any`, which would otherwise poison the
- * resulting stream's `R`. Concrete toolkits from `make` keep their precise R.
- */
-type ToolkitR<T extends Toolkit> = ToolMap extends T ? never : ToolR<T[keyof T]>;
-/**
- * Union of every tool's `E` error type in a toolkit. `Toolkit.run` reports
- * `Exclude<ToolkitE<T>, string | ToolFailed>` on its stream: the sentinel
- * failures are absorbed into results, everything else propagates typed. The
- * same `ToolMap extends T` guard as `ToolkitR` keeps a wide toolkit at
- * `never` rather than `any`.
- */
-type ToolkitE<T extends Toolkit> = ToolMap extends T ? never : ToolE<T[keyof T]>;
-type DuplicateName<Tools extends ReadonlyArray<AnyTool>, Seen extends string = never> = Tools extends readonly [infer Head extends AnyTool, ...infer Tail extends ReadonlyArray<AnyTool>] ? Head["name"] extends Seen ? Head["name"] : DuplicateName<Tail, Seen | Head["name"]> : never;
-type DuplicateNameError<Name extends string> = {
-  readonly __error: `Duplicate tool name: ${Name}`;
-};
-type NoDuplicateNames<Tools extends ReadonlyArray<AnyTool>> = [DuplicateName<Tools>] extends [never] ? unknown : DuplicateNameError<DuplicateName<Tools>>;
-/** `Tools` constrained so a repeated literal name is a compile error in `make`. */
-type UniqueTools<Tools extends ReadonlyArray<AnyTool>> = Tools & NoDuplicateNames<Tools>;
-type ComposeDuplicateKey<Kits extends ReadonlyArray<Toolkit>, Seen extends string = never> = Kits extends readonly [infer Head extends Toolkit, ...infer Tail extends ReadonlyArray<Toolkit>] ? string extends keyof Head ? ComposeDuplicateKey<Tail, Seen> : Extract<keyof Head & string, Seen> extends never ? ComposeDuplicateKey<Tail, Seen | (keyof Head & string)> : Extract<keyof Head & string, Seen> : never;
-type NoDuplicateComposedKeys<Kits extends ReadonlyArray<Toolkit>> = [ComposeDuplicateKey<Kits>] extends [never] ? unknown : DuplicateNameError<ComposeDuplicateKey<Kits>>;
-type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
-type Composed<Kits extends ReadonlyArray<Toolkit>> = UnionToIntersection<Kits[number]> extends (infer M) ? (M extends ToolMap ? M : ToolMap) : ToolMap;
-declare const DuplicateToolName_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-  readonly _tag: "DuplicateToolName";
-} & Readonly<A>;
-/**
- * Two composed toolkits resolved to the same final name. Carries the colliding
- * `sources` (the positions of the clashing toolkits) so the error says *which*
- * inputs collided. Raised at runtime by `compose` for dynamic sources; static
- * collisions are caught earlier at compile time.
- */
-declare class DuplicateToolName extends DuplicateToolName_base<{
-  readonly name: string;
-  readonly sources: ReadonlyArray<string>;
-}> {}
-type PrefixName<Prefix extends string, Name extends string> = `${Prefix}__${Name}`;
-type PrefixTool<Prefix extends string, T extends AnyTool> = T extends Tool<infer N, infer I, infer Ev, infer O, infer E, infer R> ? Tool<PrefixName<Prefix, N>, I, Ev, O, E, R> : T extends ProviderTool<infer N, infer I, infer P, infer C> ? ProviderTool<PrefixName<Prefix, N>, I, P, C> : T extends SignalTool<infer N, infer I> ? SignalTool<PrefixName<Prefix, N>, I> : T extends InteractionTool<infer N, infer I> ? InteractionTool<PrefixName<Prefix, N>, I> : T;
-type Namespaced<Prefix extends string, T extends ToolMap> = { readonly [K in keyof T & string as PrefixName<Prefix, K>]: T[K] extends AnyTool ? PrefixTool<Prefix, T[K]> : never; };
-/**
- * Prefix every tool name with `<namespace>__`, returning a new toolkit. Use it
- * to keep generic names (`search`) from two sources distinct before `compose`.
- * If two namespaces collide at the `__` separator, the duplicate final name
- * surfaces from `compose` as a `DuplicateToolName`.
- */
-declare const namespace: <const Prefix extends string, const T extends ToolMap>(prefix: Prefix, toolkit: Toolkit<T>) => Toolkit<Namespaced<Prefix, T>>;
-/** `namespace(prefix, make(...tools))` in one step, for static namespaced tools. */
-declare const makeNamespaced: <const Prefix extends string, const Tools extends ReadonlyArray<AnyTool>>(prefix: Prefix, ...tools: UniqueTools<Tools>) => Toolkit<Namespaced<Prefix, { [T in Tools[number] as T["name"]]: T; }>>;
-/**
- * Combine independently-built toolkits into one. This is where names from
- * separate sources can collide, so it is the one effectful constructor: a
- * duplicate final name fails with `DuplicateToolName` (naming the colliding
- * input positions) instead of silently overwriting or 400-ing later at the
- * provider. Statically-known collisions are additionally a compile error.
- */
-declare const compose: <const Kits extends ReadonlyArray<Toolkit>>(...toolkits: Kits & NoDuplicateComposedKeys<Kits>) => Effect.Effect<Toolkit<Composed<Kits>>, DuplicateToolName>;
-type Handler<Input, Event, Output, E, R> = (input: Input, emit: Emit<Event>) => Effect.Effect<Output, E, R>;
-/**
- * A `run` transform, tracking an added requirement `R2` and optional added
- * error `E2`. The tool's own `E` is preserved; `describeFailures` is the
- * combinator that *replaces* it (mapping every error to `string`).
- */
-type Middleware<R2 = never, E2 = never> = <Input, Event, Output, E, R>(run: Handler<Input, Event, Output, E, R>, name: string) => Handler<Input, Event, Output, E | E2, R | R2>;
-type WrapTool<T extends AnyTool, R2, E2> = T extends Tool<infer N, infer I, infer Ev, infer O, infer E, infer R> ? Tool<N, I, Ev, O, E | E2, R | R2> : T;
-type WrapToolkit<T extends ToolMap, R2, E2> = { readonly [K in keyof T]: T[K] extends AnyTool ? WrapTool<T[K], R2, E2> : T[K]; };
-/**
- * Wrap every local tool's `run` with a middleware, preserving each tool's
- * `Input`/`Output` and unioning the middleware's requirement `R2` into the
- * toolkit's `ToolkitR`. Non-local kinds pass through unchanged. Stack with
- * `pipe` - inner-first, so the last `wrap` applied is the outermost and runs
- * first:
- *
- *   const observed = pipe(toolkit, Toolkit.wrap(logging), Toolkit.wrap(authz))
- *   Toolkit.run(observed, calls) // authz runs, then logging, then the tool
- *
- * A middleware that fails with `string` / `ToolFailed` is absorbed by the
- * executor into a `ToolResult.Failure`; any other error propagates typed. Use
- * `describeFailures` for the total "everything to the model" case, or the
- * `Approval` flow for a distinct "denied" verdict.
- */
-declare const wrap: {
-  <R2, E2>(middleware: Middleware<R2, E2>): <T extends Toolkit>(toolkit: T) => WrapToolkit<T, R2, E2>;
-  <T extends Toolkit, R2, E2>(toolkit: T, middleware: Middleware<R2, E2>): WrapToolkit<T, R2, E2>;
-};
-type DescribeTool<T extends AnyTool> = T extends Tool<infer N, infer I, infer Ev, infer O, any, infer R> ? Tool<N, I, Ev, O, string, R> : T;
-type DescribeToolkit<T extends ToolMap> = { readonly [K in keyof T]: T[K] extends AnyTool ? DescribeTool<T[K]> : T[K]; };
-/**
- * Map every local tool's error to a `string`, so `Toolkit.run` absorbs those
- * failures into `ToolResult.Failure` the model reads and adapts to. Pairs
- * with the domain `describe` helpers (`AiError.describe`,
- * `BrowserError.describe`). Non-local kinds pass through.
- *
- *   const kit = yield* Toolkit.compose(
- *     Toolkit.describeFailures(searchKit, AiError.describe),
- *     browserToolkit(session), // failures stay typed
- *   )
- */
-declare const describeFailures: {
-  <E>(describe: (e: E) => string): <T extends Toolkit>(toolkit: T) => DescribeToolkit<T>;
-  <T extends Toolkit>(toolkit: T, describe: (e: ToolkitE<T>) => string): DescribeToolkit<T>;
-};
-type ExecuteOptions = {
-  readonly concurrency?: number | "unbounded";
-};
-/**
- * Execute every provided call. Approval/rejection policy belongs upstream.
- *
- * String and `ToolFailed` failures are absorbed into `ToolResult.Failure`
- * (the model reads and adapts to them); every other tool error propagates
- * typed on the stream, so `Exclude<ToolkitE<T>, string | ToolFailed>` is
- * what a caller catches or lets end the run. If one call in a concurrent
- * batch fails the stream, siblings may go unanswered: a loop that catches
- * and continues must reconcile history first (`HistoryCheck.cancelAllPending`).
- */
-declare const run: <T extends Toolkit>(toolkit: T, calls: ReadonlyArray<ToolCall>, options?: ExecuteOptions) => Stream.Stream<ToolEvent, Exclude<ToolkitE<T>, string | ToolFailed>, ToolkitR<T>>;
-/**
- * Append a completed turn plus tool results to a state's history, converting
- * the results to wire-format `ToolCallOutput`s. Curried so it slots directly
- * into `continueWithResults`:
- *
- *   Toolkit.run(toolkit, calls).pipe(
- *     Toolkit.continueWithResults(Toolkit.appendToolResults(state, turn)),
- *   )
- *
- * Equivalent to `appendToHistory(state, turn, results.map(toToolCallOutput))`
- * — the helper just hides the wire-conversion step.
- */
-declare const appendToolResults: <S extends {
-  readonly history: ReadonlyArray<HistoryItem>;
-}>(state: S, turn: Turn) => (results: ReadonlyArray<ToolResult>) => S;
-/**
- * Drain a `Stream<ToolEvent>` and return the accumulated `ToolResult`s
- * from every `Output` event. One-shot — the type is `Effect<results>`,
- * not a one-element stream — so it composes naturally with `Effect.map`
- * to build state.
- *
- * Counterpart to `continueWithResults`: `continueWithResults` bundles
- * drain + emit Next into one bridge; this one is the right arm of a
- * broadcast/fork-and-merge for callers that want to vary the left arm
- * (e.g., filter/tap ToolEvents before forwarding).
- */
-declare const collectResults: <E, R>(stream: Stream.Stream<ToolEvent, E, R>) => Effect.Effect<ReadonlyArray<ToolResult>, E, R>;
-/**
- * Bridge from a `Stream<ToolEvent>` to the loop's emit shape. Forwards
- * every ToolEvent downstream as a `Loop.value` and at end-of-stream emits
- * one `Loop.next(build(results))` carrying the accumulated `ToolResult`s
- * from terminal `Output` events.
- *
- * Conceptually a broadcast fork (one arm passes events through, the other
- * drains them into a state). Implemented as a single-pass Ref tap + concat
- * for zero buffering — the broadcast version is observationally equivalent
- * but holds events in a PubSub until both arms drain. The public primitives
- * (`Loop.value`, `collectResults`, `Loop.next`) compose the same pattern
- * when you need to vary an arm.
- *
- * Dual: data-first `continueWithResults(stream, build)` and data-last
- * `stream.pipe(continueWithResults(build))` both work.
- */
-declare const continueWithResults: {
-  <S>(build: (results: ReadonlyArray<ToolResult>) => S): <E, R>(stream: Stream.Stream<ToolEvent, E, R>) => Stream.Stream<Step<ToolEvent, S>, E, R>;
-  <S, E, R>(stream: Stream.Stream<ToolEvent, E, R>, build: (results: ReadonlyArray<ToolResult>) => S): Stream.Stream<Step<ToolEvent, S>, E, R>;
-};
-//#endregion
-export { wrap as S, fromArray as _, ToolMap as a, namespace as b, ToolkitR as c, appendToolResults as d, collectResults as f, descriptors as g, describeFailures as h, NoDuplicateNames as i, Toolkit_d_exports as l, continueWithResults as m, ExecuteOptions as n, Toolkit as o, compose as p, Middleware as r, ToolkitE as s, DuplicateToolName as t, UniqueTools as u, make as v, run as x, makeNamespaced as y };
-//# sourceMappingURL=Toolkit-tlL0F2YR.d.mts.map

package/dist/Toolkit-tlL0F2YR.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Toolkit-tlL0F2YR.d.mts","names":[],"sources":["../src/tool/Toolkit.ts"],"mappings":"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"}

package/dist/dist-BaenoU1A.mjs

@@ -1,145 +0,0 @@
-import { t as __commonJSMin } from "./rolldown-runtime-EAsCxrDo.mjs";
-import "./utils-CiH_DjFW.mjs";
-//#region ../../node_modules/.pnpm/vite@7.3.2_@types+node@26.2.0_jiti@2.6.1_lightningcss@1.32.0_tsx@4.23.12_yaml@2.9.0/node_modules/vite/dist/node/module-runner.js
-let SOURCEMAPPING_URL = "sourceMa";
-SOURCEMAPPING_URL += "ppingURL";
-typeof process < "u" && process.platform;
-(async function() {}).constructor;
-var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-var intToChar = /* @__PURE__ */ new Uint8Array(64);
-var charToInt = /* @__PURE__ */ new Uint8Array(128);
-for (let i = 0; i < chars.length; i++) {
-	let c = chars.charCodeAt(i);
-	intToChar[i] = c, charToInt[c] = i;
-}
-`${SOURCEMAPPING_URL}`;
-Error.prepareStackTrace;
-const customizationHookNamespace = "vite-module-runner:import-meta-resolve/v1/";
-`${JSON.stringify(customizationHookNamespace)}${JSON.stringify(customizationHookNamespace)}`;
-new Proxy({}, { get(_, p) {
-	throw Error(`[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`);
-} });
-//#endregion
-//#region ../../node_modules/.pnpm/expect-type@1.3.0/node_modules/expect-type/dist/branding.js
-var require_branding = /* @__PURE__ */ __commonJSMin(((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/expect-type@1.3.0/node_modules/expect-type/dist/messages.js
-var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/expect-type@1.3.0/node_modules/expect-type/dist/overloads.js
-var require_overloads = /* @__PURE__ */ __commonJSMin(((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/expect-type@1.3.0/node_modules/expect-type/dist/utils.js
-var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/vitest@4.1.11_@types+node@26.2.0_vite@7.3.2_@types+node@26.2.0_jiti@2.6.1_lightningcss@1.32.0_tsx@4.23.12_yaml@2.9.0_/node_modules/vitest/dist/index.js
-var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
-	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
-		if (k2 === void 0) k2 = k;
-		var desc = Object.getOwnPropertyDescriptor(m, k);
-		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
-			enumerable: true,
-			get: function() {
-				return m[k];
-			}
-		};
-		Object.defineProperty(o, k2, desc);
-	}) : (function(o, m, k, k2) {
-		if (k2 === void 0) k2 = k;
-		o[k2] = m[k];
-	}));
-	var __exportStar = exports && exports.__exportStar || function(m, exports$1) {
-		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
-	};
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.expectTypeOf = void 0;
-	__exportStar(require_branding(), exports);
-	__exportStar(require_messages(), exports);
-	__exportStar(require_overloads(), exports);
-	__exportStar(require_utils(), exports);
-	const fn = () => true;
-	/**
-	* Similar to Jest's `expect`, but with type-awareness.
-	* Gives you access to a number of type-matchers that let you make assertions about the
-	* form of a reference or generic type parameter.
-	*
-	* @example
-	* ```ts
-	* import { foo, bar } from '../foo'
-	* import { expectTypeOf } from 'expect-type'
-	*
-	* test('foo types', () => {
-	*   // make sure `foo` has type { a: number }
-	*   expectTypeOf(foo).toMatchTypeOf({ a: 1 })
-	*   expectTypeOf(foo).toHaveProperty('a').toBeNumber()
-	*
-	*   // make sure `bar` is a function taking a string:
-	*   expectTypeOf(bar).parameter(0).toBeString()
-	*   expectTypeOf(bar).returns.not.toBeAny()
-	* })
-	* ```
-	*
-	* @description
-	* See the [full docs](https://npmjs.com/package/expect-type#documentation) for lots more examples.
-	*/
-	const expectTypeOf = (_actual) => {
-		const nonFunctionProperties = [
-			"parameters",
-			"returns",
-			"resolves",
-			"not",
-			"items",
-			"constructorParameters",
-			"thisParameter",
-			"instance",
-			"guards",
-			"asserts",
-			"branded"
-		];
-		const obj = {
-			toBeAny: fn,
-			toBeUnknown: fn,
-			toBeNever: fn,
-			toBeFunction: fn,
-			toBeObject: fn,
-			toBeArray: fn,
-			toBeString: fn,
-			toBeNumber: fn,
-			toBeBoolean: fn,
-			toBeVoid: fn,
-			toBeSymbol: fn,
-			toBeNull: fn,
-			toBeUndefined: fn,
-			toBeNullable: fn,
-			toBeBigInt: fn,
-			toMatchTypeOf: fn,
-			toEqualTypeOf: fn,
-			toBeConstructibleWith: fn,
-			toMatchObjectType: fn,
-			toExtend: fn,
-			map: exports.expectTypeOf,
-			toBeCallableWith: exports.expectTypeOf,
-			extract: exports.expectTypeOf,
-			exclude: exports.expectTypeOf,
-			pick: exports.expectTypeOf,
-			omit: exports.expectTypeOf,
-			toHaveProperty: exports.expectTypeOf,
-			parameter: exports.expectTypeOf
-		};
-		nonFunctionProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) }));
-		return obj;
-	};
-	exports.expectTypeOf = expectTypeOf;
-})))();
-//#endregion
-export { import_dist as t };
-
-//# sourceMappingURL=dist-BaenoU1A.mjs.map