@snail-js/api 0.1.27 → 1.0.0

package/dist/typings/args.d.ts

@@ -0,0 +1,51 @@
+import type { SnailContext } from "../core/context.js";
+/**
+ * Built-in parameter sources.
+ *
+ * `"params"` → path placeholders, `"query"` → query string, `"data"` → request
+ * body, `"header"` → request header.
+ */
+export type SnailBuiltinParamSource = "params" | "query" | "data" | "header";
+/**
+ * A parameter source — a built-in name, or any string a plugin registered
+ * through `createParamDecorator`.
+ */
+export type SnailParamSource = SnailBuiltinParamSource | (string & {});
+/** Everything a parameter resolver needs to place one argument. */
+export interface SnailParamResolverInput {
+    /** Live request context; mutate `ctx.request` to affect the outgoing request. */
+    ctx: SnailContext;
+    /** The runtime argument value at `index`. */
+    value: unknown;
+    /** The key passed to the decorator, when one was given. */
+    key: string | undefined;
+    /** Extra options passed to the decorator, when any. */
+    options: unknown;
+    /** Position of the argument in the method signature. */
+    index: number;
+    /** Method name the argument belongs to. */
+    methodName: string;
+}
+/**
+ * Applies one decorated argument to the request context.
+ *
+ * Built-in sources use the resolvers in `core/args.ts`; plugins add their own
+ * through `createParamDecorator`.
+ */
+export type SnailParamResolver = (input: SnailParamResolverInput) => void;
+/** One `@Query()` / `@Params()` / custom parameter decorator application. */
+export interface SnailParamDescriptor {
+    /** e.g. `"query"`, `"params"`, `"data"`, `"header"`, or a plugin's source name. */
+    readonly source: SnailParamSource;
+    /** Position in the method signature. */
+    readonly index: number;
+    /** Key passed to the decorator, if any. */
+    readonly key?: string;
+    /** Extra options passed to the decorator, if any. */
+    readonly options?: unknown;
+    /** How to apply this argument to the context. */
+    readonly resolve: SnailParamResolver;
+}
+/** A record-shaped value contributed to the request. */
+export type SnailParamRecord = Record<string, unknown>;
+//# sourceMappingURL=args.d.ts.map

package/dist/typings/args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/typings/args.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE7E;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,uBAAuB,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAEvE,mEAAmE;AACnE,MAAM,WAAW,uBAAuB;IACtC,iFAAiF;IACjF,GAAG,EAAE,YAAY,CAAC;IAClB,6CAA6C;IAC7C,KAAK,EAAE,OAAO,CAAC;IACf,2DAA2D;IAC3D,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,uDAAuD;IACvD,OAAO,EAAE,OAAO,CAAC;IACjB,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,CAAC;AAE1E,6EAA6E;AAC7E,MAAM,WAAW,oBAAoB;IACnC,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2CAA2C;IAC3C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,qDAAqD;IACrD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;CACtC;AAED,wDAAwD;AACxD,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC"}

package/dist/typings/index.d.ts

@@ -1,12 +1,8 @@
-export * from "./request.body";
-export * from "./snail.option";
-export * from "./api.option";
-export * from "./versioning.option";
-export * from "./cache.management.option";
-export * from "./cache.type";
-export * from "./response.data";
-export * from "./strategy";
-export * from "./apiProxy";
-export * from "./sse";
-export * from "./snail.method";
-export * from "./snail.event";
+export type { SnailApiOptions, SnailApiProxy, SnailAxiosMethod, SnailMethodDecoratorOptions, SnailMethodMeta, SnailMethodOptions, SnailMethodType, SnailMethodTypeLower, SnailPayloadOf, SnailSendOptions } from "./api.js";
+export type { SnailBuiltinParamSource, SnailParamDescriptor, SnailParamRecord, SnailParamResolver, SnailParamResolverInput, SnailParamSource } from "./args.js";
+export type { SnailStateAdapter, SnailStateRef, SnailStrategyCommonOptions } from "./adapter.js";
+export type { SnailMeta } from "./meta.js";
+export type { SnailHookKind, SnailHookName, SnailNext, SnailPlugin, SnailPluginInstallContext, SnailPluginObject } from "./plugin.js";
+export type { IsRawPayload, SnailCacheHitCallback, SnailCodeErrorCallback, SnailCodeOf, SnailCodeValidator, SnailEnvelope, SnailEnvelopeSchema, SnailErrorCallback, SnailFinishCallback, SnailMessageOf, SnailRawPayload, SnailResponseKeys, SnailResult, SnailSuccessCallback } from "./response.js";
+export type { ResolvedServerOptions, SnailLogLevel, SnailServerEnvelope, SnailServerOptions } from "./server.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/typings/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/typings/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,2BAA2B,EAC3B,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,cAAc,EACd,gBAAgB,EACjB,MAAM,OAAO,CAAC;AAEf,YAAY,EACV,uBAAuB,EACvB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,uBAAuB,EACvB,gBAAgB,EACjB,MAAM,QAAQ,CAAC;AAEhB,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,0BAA0B,EAC3B,MAAM,WAAW,CAAC;AAEnB,YAAY,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAExC,YAAY,EACV,aAAa,EACb,aAAa,EACb,SAAS,EACT,WAAW,EACX,yBAAyB,EACzB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,YAAY,EACZ,qBAAqB,EACrB,sBAAsB,EACtB,WAAW,EACX,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,qBAAqB,EACrB,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,UAAU,CAAC"}

package/dist/typings/meta.d.ts

@@ -0,0 +1,44 @@
+import type { SnailStateRef } from "./adapter.js";
+/**
+ * The caller-visible handles a framework adapter publishes on
+ * `SnailMethod.meta`.
+ *
+ * ## Augmenting it
+ *
+ * This interface is the `declare module` extension point for the adapter types,
+ * mirroring how `SnailEnvelopeSchema` is the one for the response envelope:
+ *
+ * ```ts
+ * // app/env.d.ts
+ * import type { Ref } from "vue";
+ *
+ * declare module "@snail-js/api" {
+ *   interface SnailMeta {
+ *     data: Ref<User>;
+ *     code: Ref<number>;
+ *     message: Ref<string>;
+ *   }
+ * }
+ *
+ * const method = userApi.getUser("1");
+ * method.meta.data; // Ref<User>
+ * ```
+ *
+ * ## Why `data` / `code` / `message` are not declared here
+ *
+ * Their names come from `@Server({ dataKey, codeKey, messageKey })`, which is a
+ * runtime value — a static interface cannot name a key that is only known at
+ * configuration time. Declaring them with a placeholder type would make
+ * augmentation impossible (interface merging can only *add*, never narrow), so
+ * they are left to the application to declare with its real payload type.
+ *
+ * `loading` and `error` are different: every adapter owns those two names and
+ * their types are fixed, so they are declared here and typed precisely.
+ */
+export interface SnailMeta {
+    /** `true` while a request is in flight. Present with any state adapter. */
+    loading?: SnailStateRef<boolean>;
+    /** The most recent failure, or `undefined`. Present with any state adapter. */
+    error?: SnailStateRef<unknown>;
+}
+//# sourceMappingURL=meta.d.ts.map

package/dist/typings/meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/typings/meta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,WAAW,SAAS;IACxB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAEjC,+EAA+E;IAC/E,KAAK,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CAChC"}

package/dist/typings/plugin.d.ts

@@ -0,0 +1,114 @@
+import type { AxiosRequestConfig, InternalAxiosRequestConfig } from "axios";
+import type { SnailContext } from "../core/context.js";
+import type { ResolvedServerOptions } from "./server.js";
+import type { SnailApiOptions, SnailMethodOptions } from "./api.js";
+/**
+ * The `next` callback handed to every chain-style plugin hook.
+ *
+ * Calling it hands control to the next plugin in the chain. It resolves once
+ * every later plugin — and the actual HTTP request — has finished.
+ */
+export type SnailNext = () => Promise<void>;
+/** Stage at which a plugin hook runs. */
+export type SnailHookKind = "config" | "chain" | "effect";
+/** Names of every lifecycle hook, in execution order. */
+export type SnailHookName = "install" | "uninstall" | "configureServer" | "configureApi" | "configureMethod" | "initMeta" | "beforeCreate" | "beforeRequest" | "requestInterceptor" | "afterResponse" | "responseInterceptor" | "onError" | "afterRequest";
+/**
+ * Object returned by a plugin factory. This is the whole plugin contract.
+ *
+ * Only `name` is required. Everything else is an optional lifecycle hook; a
+ * plugin implements just the hooks it cares about.
+ *
+ * @example
+ * ```ts
+ * const Timing = definePlugin(() => ({
+ *   name: "timing",
+ *   beforeRequest: (ctx) => { ctx.state.set("t0", Date.now()); },
+ *   afterRequest: (ctx) => console.log("took", Date.now() - ctx.state.get("t0"))
+ * }));
+ * Service.use(Timing());
+ * ```
+ */
+export interface SnailPluginObject<O = unknown> {
+    /** Unique plugin name. Re-registering the same name on one server is an error. */
+    readonly name: string;
+    /**
+     * Execution order inside each chain. **Higher runs first.** Defaults to `0`.
+     *
+     * Built-in plugins claim the following bands so third-party plugins can slot
+     * between them:
+     * - `100` interceptor
+     * - `50` version
+     * - `0` adapter / framework / user plugins
+     * - `-50` validate
+     * - `-100` cache
+     */
+    readonly priority?: number;
+    /** Plugin names that must be registered before this one. */
+    readonly dependsOn?: readonly string[];
+    /** Options this instance was created with, surfaced for debugging. */
+    readonly options?: O;
+    /** Called once, when the plugin is added to a server. */
+    install?(ctx: SnailPluginInstallContext, options: O): void | Promise<void>;
+    /** Called when the plugin is removed, or when the server is disposed. */
+    uninstall?(ctx: SnailPluginInstallContext, options: O): void | Promise<void>;
+    /** Mutate the resolved server options. Runs when the server instance is built. */
+    configureServer?(options: ResolvedServerOptions): void;
+    /** Mutate the resolved api options. Runs the first time a method is proxied. */
+    configureApi?(options: SnailApiOptions, apiClass: new () => unknown): void;
+    /** Mutate the resolved method options. Runs the first time a method is proxied. */
+    configureMethod?(options: SnailMethodOptions, methodName: string): void;
+    /**
+     * Add the reactive values this plugin owns to `ctx.meta`.
+     *
+     * Runs once per `send()`, before any request work. Framework adapters use it
+     * to expose `loading` / `data` / `error`.
+     */
+    initMeta?(ctx: SnailContext): void;
+    /** Runs after `initMeta`, before the argument decorators are applied. */
+    beforeCreate?(ctx: SnailContext): void;
+    /**
+     * Runs before the request is handed to axios.
+     *
+     * Chain hook: `await next()` to continue. Skipping `next()` aborts the
+     * request. Setting `ctx.response` and calling `ctx.interrupt()` short-circuits
+     * the network call entirely — that is how the cache plugin serves a hit.
+     */
+    beforeRequest?(ctx: SnailContext, next: SnailNext): Promise<void> | void;
+    /**
+     * Low-level rewrite of the final axios config.
+     *
+     * Runs synchronously, right before `axios.request`, in registration order.
+     * Return a new config to replace it. Use this for signing, tracing headers and
+     * anything that must run after every other plugin settled.
+     */
+    requestInterceptor?(config: InternalAxiosRequestConfig, ctx: SnailContext): AxiosRequestConfig | void;
+    /**
+     * Runs after a successful HTTP round-trip, before the envelope is validated.
+     *
+     * Chain hook: `await next()` to continue. Skipping `next()` means later
+     * plugins and the caller see whatever `ctx.response` currently holds.
+     */
+    afterResponse?(ctx: SnailContext, next: SnailNext): Promise<void> | void;
+    /** Low-level rewrite of the axios response, in registration order. */
+    responseInterceptor?(response: import("axios").AxiosResponse, ctx: SnailContext): import("axios").AxiosResponse | void;
+    /** Observe a failure. Cannot recover it; use `beforeRequest` for that. */
+    onError?(ctx: SnailContext, error: unknown): void;
+    /**
+     * Runs in `finally`, whether the request succeeded, failed or was cancelled.
+     * This is where plugins release resources and stop timers.
+     */
+    afterRequest?(ctx: SnailContext): void;
+}
+/** The subset of server capabilities a plugin may use during install. */
+export interface SnailPluginInstallContext {
+    /** Name of the server the plugin was installed on. */
+    readonly serverName: string;
+    /** Resolved server options (mutable, but prefer `configureServer`). */
+    readonly serverOptions: ResolvedServerOptions;
+    /** Names of every plugin currently registered on the server, in chain order. */
+    readonly pluginNames: readonly string[];
+}
+/** A plugin factory: `(options) => SnailPluginObject`. */
+export type SnailPlugin<O = unknown> = (options?: O) => SnailPluginObject<O>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/typings/plugin.d.ts.map

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

package/dist/typings/response.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Response typing.
+ *
+ * The library assumes every JSON endpoint answers with a standard envelope:
+ *
+ * ```json
+ * { "code": 0, "message": "ok", "data": {} }
+ * ```
+ *
+ * Both the *shape* and the *key names* are overridable.
+ *
+ * ## Overriding the shape
+ *
+ * The default envelope is `SnailEnvelopeSchema`, which is module-augmentable:
+ *
+ * ```ts
+ * // app/env.d.ts
+ * declare module "@snail-js/api" {
+ *   interface SnailEnvelopeSchema {
+ *     status: number;
+ *     msg: string;
+ *     result: unknown;
+ *   }
+ * }
+ * ```
+ *
+ * ## Overriding the key names
+ *
+ * ```ts
+ * @Server({
+ *   baseURL: "/api",
+ *   codeKey: "status",
+ *   messageKey: "msg",
+ *   dataKey: "result"
+ * })
+ * class BackEnd extends SnailServer<SnailEnvelopeSchema, "result", "status", "msg"> {}
+ * ```
+ *
+ * This module is types-only on purpose: it is safe to `import type` from, and it
+ * contributes nothing to the runtime bundle.
+ */
+/**
+ * The envelope every JSON endpoint is assumed to return.
+ *
+ * Augment this interface to reshape the default for the whole application.
+ */
+export interface SnailEnvelopeSchema {
+    code: number;
+    message: string;
+    data: unknown;
+}
+/** Key names used to read the envelope. */
+export interface SnailResponseKeys {
+    /** Key holding the business status code. Defaults to `"code"`. */
+    code: string;
+    /** Key holding the human readable message. Defaults to `"message"`. */
+    message: string;
+    /** Key holding the actual payload. Defaults to `"data"`. */
+    data: string;
+}
+/**
+ * Payloads that bypass the envelope entirely.
+ *
+ * A `blob` / `arraybuffer` / `stream` response has no `code`/`message`/`data`,
+ * so the typed result of such a request is the body itself.
+ */
+export type SnailRawPayload = Blob | ArrayBuffer | ReadableStream<Uint8Array> | FormData | Document;
+/** `true` when `T` is a pass-through payload rather than a JSON envelope. */
+export type IsRawPayload<T> = T extends SnailRawPayload ? true : false;
+/**
+ * The full envelope for a payload of type `T`, or `T` itself when `T` is a raw
+ * pass-through payload.
+ */
+export type SnailEnvelope<S, T, D extends string = "data"> = IsRawPayload<T> extends true ? T : S extends Record<string, any> ? S & Record<D, T> : Record<D, T>;
+/** Business status code type, derived from the envelope when possible. */
+export type SnailCodeOf<S, C extends string = "code"> = C extends keyof S ? S[C] : number | string | undefined;
+/** Business message type, derived from the envelope when possible. */
+export type SnailMessageOf<S, M extends string = "message"> = M extends keyof S ? S[M] : string | undefined;
+/**
+ * What every `send()` resolves to.
+ *
+ * Deliberately richer than the old API's bare envelope: `data` is already
+ * unwrapped (the thing you want almost always) while `envelope` and `response`
+ * stay available for everything else.
+ */
+export interface SnailResult<S = SnailEnvelopeSchema, T = unknown, D extends string = "data", C extends string = "code", M extends string = "message"> {
+    /** The raw axios response. */
+    response: import("axios").AxiosResponse<SnailEnvelope<S, T, D>>;
+    /** The parsed backend envelope (`{ code, message, data }` by default). */
+    envelope: SnailEnvelope<S, T, D>;
+    /** The unwrapped payload — `envelope[dataKey]`. */
+    data: T;
+    /** Business code — `envelope[codeKey]`. */
+    code: SnailCodeOf<S, C>;
+    /** Business message — `envelope[messageKey]`. */
+    message: SnailMessageOf<S, M>;
+    /** `true` when the value came from a cache instead of the network. */
+    fromCache: boolean;
+    /** The final request config, after every plugin and strategy ran. */
+    config: import("axios").InternalAxiosRequestConfig;
+}
+/** Callback invoked when a request succeeds. */
+export type SnailSuccessCallback<S, T, D extends string = "data"> = (result: SnailResult<S, T, D, any, any>) => void;
+/** Callback invoked when a request fails. */
+export type SnailErrorCallback = (error: unknown) => void;
+/** Callback invoked when the business code is rejected. */
+export type SnailCodeErrorCallback<T = unknown> = (code: number | string, payload: T, error: unknown) => void;
+/** Callback invoked when a request settles, successfully or not. */
+export type SnailFinishCallback = () => void;
+/** Callback invoked when the response was served from a cache. */
+export type SnailCacheHitCallback = () => void;
+/**
+ * Verdict function deciding whether a business status code is acceptable.
+ *
+ * Return `true` to accept, `false` to reject with a `SnailResponseError`.
+ */
+export type SnailCodeValidator = (code: number | string, envelope: unknown) => boolean;
+//# sourceMappingURL=response.d.ts.map

package/dist/typings/response.d.ts.map

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

package/dist/typings/server.d.ts

@@ -0,0 +1,83 @@
+import type { AxiosRequestConfig } from "axios";
+import type { SnailCodeValidator, SnailEnvelopeSchema } from "./response.js";
+/** Severity used by the logger. */
+export type SnailLogLevel = "silent" | "error" | "warn" | "info" | "debug";
+/**
+ * Options accepted by `@Server(...)`.
+ *
+ * Every field is optional; unspecified fields fall back to
+ * `DEFAULT_SERVER_OPTIONS`.
+ */
+export interface SnailServerOptions {
+    /**
+     * Unique identifier of this server.
+     *
+     * Defaults to the decorated class name. It namespaces plugin registries,
+     * cache entries and log lines, so two servers in one app must not share it.
+     */
+    name?: string;
+    /** Prefix every request url is resolved against. Defaults to `"/"`. */
+    baseURL?: string;
+    /** Request timeout in milliseconds. Defaults to `10000`. */
+    timeout?: number;
+    /**
+     * axios adapter. Leave unset to use axios' own default detection, which picks
+     * `xhr`/`fetch` in a browser and `http` in Node.
+     */
+    adapter?: AxiosRequestConfig["adapter"];
+    /** Extra headers merged into every request of this server. */
+    headers?: AxiosRequestConfig["headers"];
+    /** Extra query params merged into every request of this server. */
+    params?: AxiosRequestConfig["params"];
+    /** Default `responseType` for every request of this server. */
+    responseType?: AxiosRequestConfig["responseType"];
+    /** Send cookies / auth headers on cross-site requests. */
+    withCredentials?: boolean;
+    /**
+     * Key holding the business status code. Defaults to `"code"`.
+     * @see SnailResponseKeys
+     */
+    codeKey?: string;
+    /**
+     * Key holding the business message. Defaults to `"message"`.
+     * @see SnailResponseKeys
+     */
+    messageKey?: string;
+    /**
+     * Key holding the payload. Defaults to `"data"`.
+     * @see SnailResponseKeys
+     */
+    dataKey?: string;
+    /**
+     * Decides whether a business status code is acceptable.
+     *
+     * Defaults to accepting `0` and `200`. Returning `false` rejects the request
+     * with a `SnailResponseError` carrying the full envelope.
+     */
+    validateCode?: SnailCodeValidator;
+    /**
+     * Log level. Defaults to `"silent"`, because a request library must not write
+     * to the console unless the application asked for it.
+     */
+    logLevel?: SnailLogLevel;
+    /** Parse a JSON string body when the server forgot the content-type header. */
+    coerceJSONString?: boolean;
+}
+/**
+ * `SnailServerOptions` with every default applied.
+ *
+ * Plugins receive this, so they never have to re-apply defaults themselves.
+ */
+export interface ResolvedServerOptions extends SnailServerOptions {
+    name: string;
+    baseURL: string;
+    timeout: number;
+    codeKey: string;
+    messageKey: string;
+    dataKey: string;
+    logLevel: SnailLogLevel;
+    coerceJSONString: boolean;
+}
+/** Narrow an arbitrary value to a usable envelope schema. */
+export type SnailServerEnvelope = SnailEnvelopeSchema;
+//# sourceMappingURL=server.d.ts.map

package/dist/typings/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/typings/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAE1E,mCAAmC;AACnC,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3E;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,OAAO,CAAC,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAExC,8DAA8D;IAC9D,OAAO,CAAC,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAExC,mEAAmE;IACnE,MAAM,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IAEtC,+DAA+D;IAC/D,YAAY,CAAC,EAAE,kBAAkB,CAAC,cAAc,CAAC,CAAC;IAElD,0DAA0D;IAC1D,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAElC;;;OAGG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;IAEzB,+EAA+E;IAC/E,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAsB,SAAQ,kBAAkB;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,aAAa,CAAC;IACxB,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,6DAA6D;AAC7D,MAAM,MAAM,mBAAmB,GAAG,mBAAmB,CAAC"}

package/dist/typings/stream.d.ts

@@ -0,0 +1,150 @@
+/** Types for the SSE / WebSocket / HTTP-stream transports. */
+/** Backoff policy shared by the reconnecting transports. */
+export interface SnailReconnectPolicy {
+    /** Extra attempts after the first failure. Defaults to `3`. */
+    retries?: number;
+    /** First delay in milliseconds. Defaults to `1000`. */
+    delayMs?: number;
+    /** Upper bound for the delay. Defaults to `30000`. */
+    maxDelayMs?: number;
+    /** Multiplier applied to the delay after each failure. Defaults to `2`. */
+    factor?: number;
+    /** Add random jitter to avoid a thundering herd. Defaults to `true`. */
+    jitter?: boolean;
+}
+/** One decoded server-sent event. */
+export interface SnailSseMessage {
+    /** Event name — `"message"` for the default event. */
+    event: string;
+    /** Raw payload text. */
+    data: string;
+    /** `id:` field, when the server sent one. */
+    id: string;
+    /** `retry:` hint in milliseconds, when the server sent one. */
+    retry: number | undefined;
+}
+/** Options accepted by `@Sse(path, options)`. */
+export interface SnailSseOptions {
+    /** Request method. Defaults to `"GET"`. */
+    method?: "GET" | "POST";
+    /** Send cookies and auth headers cross-site. */
+    withCredentials?: boolean;
+    /** Extra request headers. */
+    headers?: Record<string, string>;
+    /** Static request body, useful with `method: "POST"`. */
+    data?: unknown;
+    /** Auto-reconnect policy, or `false` to disable reconnecting. */
+    reconnect?: false | SnailReconnectPolicy;
+}
+/** Options accepted by `@WebSocket(path, options)`. */
+export interface SnailWsOptions {
+    /** Sub-protocols passed to the `WebSocket` constructor. */
+    protocols?: string | string[];
+    /** Auto-reconnect policy, or `false` to disable reconnecting. */
+    reconnect?: false | SnailReconnectPolicy;
+    /**
+     * Serialiser used by `send()`.
+     * - `"json"` (default) → `JSON.stringify`
+     * - `"text"` → `String(value)`
+     * - a custom pair of functions
+     */
+    serializer?: "json" | "text" | {
+        serialize?: (value: unknown) => string | ArrayBufferLike | Blob | ArrayBufferView;
+        deserialize?: (raw: string) => unknown;
+    };
+    /** Queue messages sent while the socket is still connecting. Defaults to `true`. */
+    queueWhileConnecting?: boolean;
+}
+/** Options accepted by `@HttpStream(path, options)`. */
+export interface SnailHttpStreamOptions {
+    /** Request method. Defaults to `"POST"`. */
+    method?: import("./api.js").SnailMethodType;
+    /** Request headers, typically `{ accept: "text/event-stream" }`. */
+    headers?: Record<string, string>;
+    /** Decode each chunk as UTF-8 text rather than raw bytes. Defaults to `true`. */
+    decodeText?: boolean;
+    /** Split the stream into lines instead of raw chunks. Defaults to `false`. */
+    lineDelimited?: boolean;
+}
+/**
+ * A live connection returned by `open()`.
+ *
+ * `Symbol.asyncDispose` is implemented so a connection can be driven with
+ * `await using` in runtimes that support explicit resource management.
+ */
+export interface SnailConnection {
+    /** Close the connection and release its resources. */
+    close(): void;
+    /** `true` while the transport is connected. */
+    connected: boolean;
+    /** Resolves once the connection is established. */
+    readonly opened: Promise<void>;
+    /** Resolves once the connection is closed, for any reason. */
+    readonly closed: Promise<void>;
+    /**
+     * Release the connection with `using` / `await using`.
+     *
+     * Both are attached at runtime whenever the running engine provides the well
+     * known symbols, and simply absent otherwise — so `close()` remains the one
+     * portable way to release a connection.
+     */
+    [Symbol.dispose]?(): void;
+    [Symbol.asyncDispose]?(): Promise<void>;
+}
+/**
+ * A WebSocket connection.
+ *
+ * `send` while the socket is still connecting queues the message (unless
+ * `queueWhileConnecting: false`), because a caller that just called `open()`
+ * should not have to race the handshake.
+ */
+export interface SnailSocketConnection extends SnailConnection {
+    /** Send a value, serialised according to the `serializer` option. */
+    send(data: unknown): void;
+}
+/**
+ * A streaming HTTP response.
+ *
+ * The connection is itself async-iterable, so it can be consumed directly:
+ *
+ * ```ts
+ * const stream = aiApi.chat(payload);
+ * for await (const chunk of stream) process(chunk);
+ * ```
+ */
+export interface SnailHttpStreamConnection extends SnailConnection {
+    /** Iterate the decoded chunks. */
+    [Symbol.asyncIterator](): AsyncIterator<string>;
+    /** Buffer the whole stream into a single string. */
+    text(): Promise<string>;
+}
+/**
+ * A Server-Sent Events connection.
+ *
+ * Carries a message surface of its own, on top of the shared connection handle.
+ * Without it the parsed events would only ever reach the decorated class's
+ * `@SseEvent()` handlers, so a hook like `useSSE` — which needs to observe the
+ * stream itself — would have nothing to subscribe to.
+ */
+export interface SnailSseConnection extends SnailConnection {
+    /** Subscribe to every decoded event, whatever its name. Returns an unsubscribe. */
+    onMessage(listener: (message: SnailSseMessage) => void): () => void;
+    /** Subscribe to one named event. Returns an unsubscribe function. */
+    on(event: string, listener: (message: SnailSseMessage) => void): () => void;
+}
+/**
+ * A Server-Sent Events endpoint created by `Service.createSse(EventStream)`.
+ *
+ * Nothing connects until `open()` is called, and every call to `open()` creates
+ * an independent connection with its own reconnect loop.
+ */
+export interface SnailSseEndpoint {
+    /** Open a connection and return its handle. */
+    open(): SnailSseConnection;
+}
+/** A WebSocket endpoint created by `Service.createWebSocket(ChatSocket)`. */
+export interface SnailWsEndpoint {
+    /** Open a connection and return its handle. */
+    open(): SnailSocketConnection;
+}
+//# sourceMappingURL=stream.d.ts.map

package/dist/typings/stream.d.ts.map

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