@snail-js/api 0.1.27 → 1.0.0

package/dist/plugins/vue/index.js

@@ -0,0 +1,114 @@
+import { n as createPlugin } from "../../chunks/plugin-D3RDffDG.js";
+import { t as SnailCancelledError } from "../../chunks/request-qeRhihEF.js";
+import { a as readKey, o as unwrapEnvelope } from "../../chunks/response-D-ubkAFl.js";
+import { t as vueStateAdapter } from "../../chunks/vue-Dd9EhkQ3.js";
+//#region src/plugins/vue/plugin.ts
+/**
+* Vue adapter plugin.
+*
+* Mirrors every request's state onto `ctx.meta` as Vue refs, so a component can
+* render `method.meta.data` / `loading` / `error` without writing a single
+* `ref()` or `watch()` itself.
+*
+* ## Why `initMeta` and not `beforeRequest`
+*
+* `initMeta` runs **once**, when the `SnailMethod` is built; `beforeCreate` runs
+* per `send()`. Creating the refs in the per-send hook is the classic bug where a
+* list keeps rendering the first page forever: the UI captured ref #1 while the
+* second send wrote into ref #2. The handles are created here and only ever
+* *written* afterwards, so the object the caller holds stays live for the whole
+* life of the method.
+*
+* ## Why the work is split across four hooks
+*
+* `ctx.meta` is caller-visible, so each handle is written at the moment its value
+* becomes true: the payload after the response arrives (before the `success`
+* event, so a handler that reads `meta.data` sees fresh data), the error before
+* the `error`/`codeError` event, and `loading` in `afterRequest` — which runs in a
+* `finally`, for success, failure and cancellation alike.
+*/
+/** Key of the `loading` handle. Fixed, and not part of the envelope. */
+var LOADING_KEY = "loading";
+/** Key of the `error` handle. Fixed, and not part of the envelope. */
+var ERROR_KEY = "error";
+/**
+* Create one handle unless the caller already holds one for that key.
+*
+* The guard matters because `send()` re-runs `initMeta` when the context was built
+* before the plugin was installed; recreating refs there would silently detach
+* whatever the UI is rendering.
+*/
+function ensureHandle(ctx, key, initial) {
+	if (vueStateAdapter.isState?.(ctx.meta[key])) return;
+	ctx.meta[key] = vueStateAdapter.create(initial);
+}
+/** Create the five handles. Runs once per `SnailMethod`. */
+function createHandles(ctx) {
+	const { dataKey, codeKey, messageKey } = ctx.serverOptions;
+	ensureHandle(ctx, dataKey, void 0);
+	ensureHandle(ctx, codeKey, void 0);
+	ensureHandle(ctx, messageKey, void 0);
+	ensureHandle(ctx, LOADING_KEY, false);
+	ensureHandle(ctx, ERROR_KEY, void 0);
+}
+/**
+* Write one handle, ignoring a key this plugin never created.
+*
+* A missing handle means the caller removed it or another adapter owns the key;
+* skipping is better than creating a ref nobody holds a reference to.
+*/
+function writeHandle(ctx, key, value) {
+	const handle = ctx.meta[key];
+	if (handle) vueStateAdapter.write(handle, value);
+}
+/** Copy the envelope of the current response into the caller's refs. */
+function captureResponse(ctx) {
+	const response = ctx.getResponse();
+	if (!response) return;
+	const { dataKey, codeKey, messageKey } = ctx.serverOptions;
+	writeHandle(ctx, dataKey, unwrapEnvelope(response.data, dataKey));
+	writeHandle(ctx, codeKey, readKey(response.data, codeKey));
+	writeHandle(ctx, messageKey, readKey(response.data, messageKey));
+}
+/**
+* Create the Vue adapter plugin.
+*
+* ```ts
+* Service.use(VueAdapter());
+*
+* const user = Service.createApi(UserApi).getUser("1");
+* // renders immediately: `user.meta.loading.value === false`
+* await user.send();
+* user.meta.data.value;   // the unwrapped payload
+* ```
+*/
+var VueAdapter = createPlugin({
+	name: "vue-adapter",
+	priority: 0,
+	setup() {
+		return {
+			initMeta(ctx) {
+				createHandles(ctx);
+			},
+			beforeCreate(ctx) {
+				writeHandle(ctx, LOADING_KEY, true);
+				writeHandle(ctx, ERROR_KEY, void 0);
+			},
+			afterResponse(ctx, next) {
+				captureResponse(ctx);
+				return next();
+			},
+			onError(ctx, error) {
+				if (error instanceof SnailCancelledError) return;
+				writeHandle(ctx, ERROR_KEY, error);
+			},
+			afterRequest(ctx) {
+				writeHandle(ctx, LOADING_KEY, false);
+			}
+		};
+	}
+});
+//#endregion
+export { VueAdapter };
+
+//# sourceMappingURL=index.js.map

package/dist/plugins/vue/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/plugins/vue/plugin.ts"],"sourcesContent":["import { vueStateAdapter } from \"../../adapter/vue\";\nimport { createPlugin } from \"../../core/plugin\";\nimport { readKey, unwrapEnvelope } from \"../../core/response\";\nimport { SnailCancelledError } from \"../../error/request\";\nimport type { SnailContext } from \"../../core/context\";\nimport type { SnailStateRef } from \"../../typings/adapter\";\nimport type { VueAdapterOptions } from \"./type\";\n\n/**\n * Vue adapter plugin.\n *\n * Mirrors every request's state onto `ctx.meta` as Vue refs, so a component can\n * render `method.meta.data` / `loading` / `error` without writing a single\n * `ref()` or `watch()` itself.\n *\n * ## Why `initMeta` and not `beforeRequest`\n *\n * `initMeta` runs **once**, when the `SnailMethod` is built; `beforeCreate` runs\n * per `send()`. Creating the refs in the per-send hook is the classic bug where a\n * list keeps rendering the first page forever: the UI captured ref #1 while the\n * second send wrote into ref #2. The handles are created here and only ever\n * *written* afterwards, so the object the caller holds stays live for the whole\n * life of the method.\n *\n * ## Why the work is split across four hooks\n *\n * `ctx.meta` is caller-visible, so each handle is written at the moment its value\n * becomes true: the payload after the response arrives (before the `success`\n * event, so a handler that reads `meta.data` sees fresh data), the error before\n * the `error`/`codeError` event, and `loading` in `afterRequest` — which runs in a\n * `finally`, for success, failure and cancellation alike.\n */\n\n/** Key of the `loading` handle. Fixed, and not part of the envelope. */\nconst LOADING_KEY = \"loading\";\n\n/** Key of the `error` handle. Fixed, and not part of the envelope. */\nconst ERROR_KEY = \"error\";\n\n/**\n * Create one handle unless the caller already holds one for that key.\n *\n * The guard matters because `send()` re-runs `initMeta` when the context was built\n * before the plugin was installed; recreating refs there would silently detach\n * whatever the UI is rendering.\n */\nfunction ensureHandle(ctx: SnailContext, key: string, initial: unknown): void {\n  if (vueStateAdapter.isState?.(ctx.meta[key])) return;\n  ctx.meta[key] = vueStateAdapter.create(initial);\n}\n\n/** Create the five handles. Runs once per `SnailMethod`. */\nfunction createHandles(ctx: SnailContext): void {\n  const { dataKey, codeKey, messageKey } = ctx.serverOptions;\n  ensureHandle(ctx, dataKey, undefined);\n  ensureHandle(ctx, codeKey, undefined);\n  ensureHandle(ctx, messageKey, undefined);\n  ensureHandle(ctx, LOADING_KEY, false);\n  ensureHandle(ctx, ERROR_KEY, undefined);\n}\n\n/**\n * Write one handle, ignoring a key this plugin never created.\n *\n * A missing handle means the caller removed it or another adapter owns the key;\n * skipping is better than creating a ref nobody holds a reference to.\n */\nfunction writeHandle(ctx: SnailContext, key: string, value: unknown): void {\n  const handle = ctx.meta[key];\n  if (handle) vueStateAdapter.write(handle as SnailStateRef, value);\n}\n\n/** Copy the envelope of the current response into the caller's refs. */\nfunction captureResponse(ctx: SnailContext): void {\n  const response = ctx.getResponse();\n  if (!response) return;\n\n  const { dataKey, codeKey, messageKey } = ctx.serverOptions;\n  writeHandle(ctx, dataKey, unwrapEnvelope(response.data, dataKey));\n  writeHandle(ctx, codeKey, readKey(response.data, codeKey));\n  writeHandle(ctx, messageKey, readKey(response.data, messageKey));\n}\n\n/**\n * Create the Vue adapter plugin.\n *\n * ```ts\n * Service.use(VueAdapter());\n *\n * const user = Service.createApi(UserApi).getUser(\"1\");\n * // renders immediately: `user.meta.loading.value === false`\n * await user.send();\n * user.meta.data.value;   // the unwrapped payload\n * ```\n */\nexport const VueAdapter = createPlugin<VueAdapterOptions>({\n  name: \"vue-adapter\",\n  priority: 0,\n\n  setup() {\n    return {\n      initMeta(ctx) {\n        createHandles(ctx);\n      },\n\n      beforeCreate(ctx) {\n        writeHandle(ctx, LOADING_KEY, true);\n        // A new attempt clears the previous failure; otherwise a stale error would\n        // keep rendering next to data that has just loaded successfully.\n        writeHandle(ctx, ERROR_KEY, undefined);\n      },\n\n      afterResponse(ctx, next) {\n        captureResponse(ctx);\n        return next();\n      },\n\n      onError(ctx, error) {\n        // Cancellation is expected control flow, not a failure: writing it would\n        // flash an error state every time a component unmounts mid-request.\n        if (error instanceof SnailCancelledError) return;\n        writeHandle(ctx, ERROR_KEY, error);\n      },\n\n      afterRequest(ctx) {\n        writeHandle(ctx, LOADING_KEY, false);\n      }\n    };\n  }\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAM,cAAc;;AAGpB,IAAM,YAAY;;;;;;;;AASlB,SAAS,aAAa,KAAmB,KAAa,SAAwB;CAC5E,IAAI,gBAAgB,UAAU,IAAI,KAAK,IAAI,GAAG;CAC9C,IAAI,KAAK,OAAO,gBAAgB,OAAO,OAAO;AAChD;;AAGA,SAAS,cAAc,KAAyB;CAC9C,MAAM,EAAE,SAAS,SAAS,eAAe,IAAI;CAC7C,aAAa,KAAK,SAAS,KAAA,CAAS;CACpC,aAAa,KAAK,SAAS,KAAA,CAAS;CACpC,aAAa,KAAK,YAAY,KAAA,CAAS;CACvC,aAAa,KAAK,aAAa,KAAK;CACpC,aAAa,KAAK,WAAW,KAAA,CAAS;AACxC;;;;;;;AAQA,SAAS,YAAY,KAAmB,KAAa,OAAsB;CACzE,MAAM,SAAS,IAAI,KAAK;CACxB,IAAI,QAAQ,gBAAgB,MAAM,QAAyB,KAAK;AAClE;;AAGA,SAAS,gBAAgB,KAAyB;CAChD,MAAM,WAAW,IAAI,YAAY;CACjC,IAAI,CAAC,UAAU;CAEf,MAAM,EAAE,SAAS,SAAS,eAAe,IAAI;CAC7C,YAAY,KAAK,SAAS,eAAe,SAAS,MAAM,OAAO,CAAC;CAChE,YAAY,KAAK,SAAS,QAAQ,SAAS,MAAM,OAAO,CAAC;CACzD,YAAY,KAAK,YAAY,QAAQ,SAAS,MAAM,UAAU,CAAC;AACjE;;;;;;;;;;;;;AAcA,IAAa,aAAa,aAAgC;CACxD,MAAM;CACN,UAAU;CAEV,QAAQ;EACN,OAAO;GACL,SAAS,KAAK;IACZ,cAAc,GAAG;GACnB;GAEA,aAAa,KAAK;IAChB,YAAY,KAAK,aAAa,IAAI;IAGlC,YAAY,KAAK,WAAW,KAAA,CAAS;GACvC;GAEA,cAAc,KAAK,MAAM;IACvB,gBAAgB,GAAG;IACnB,OAAO,KAAK;GACd;GAEA,QAAQ,KAAK,OAAO;IAGlB,IAAI,iBAAiB,qBAAqB;IAC1C,YAAY,KAAK,WAAW,KAAK;GACnC;GAEA,aAAa,KAAK;IAChB,YAAY,KAAK,aAAa,KAAK;GACrC;EACF;CACF;AACF,CAAC"}

package/dist/plugins/vue/plugin.d.ts

@@ -0,0 +1,15 @@
+import type { VueAdapterOptions } from "./type.js";
+/**
+ * Create the Vue adapter plugin.
+ *
+ * ```ts
+ * Service.use(VueAdapter());
+ *
+ * const user = Service.createApi(UserApi).getUser("1");
+ * // renders immediately: `user.meta.loading.value === false`
+ * await user.send();
+ * user.meta.data.value;   // the unwrapped payload
+ * ```
+ */
+export declare const VueAdapter: import("../../index.js").SnailPlugin<VueAdapterOptions>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugins/vue/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/vue/plugin.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AA6EhD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,gDAkCrB,CAAC"}

package/dist/plugins/vue/type.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Options accepted by the Vue adapter plugin.
+ *
+ * Deliberately empty: the adapter mirrors the envelope keys the server already
+ * declares (`dataKey` / `codeKey` / `messageKey`) and adds the two fixed handles
+ * `loading` and `error`, so there is nothing left to configure. A per-plugin key
+ * option was avoided on purpose — two sources of truth for the same key is how a
+ * UI ends up rendering `undefined` while the payload sits one key away.
+ *
+ * The parameter is part of the factory signature anyway, so a future option can
+ * be added without breaking every `VueAdapter()` call site.
+ *
+ * ## Typing the handles
+ *
+ * `method.meta.loading` and `.error` are already typed as `Ref<boolean>` /
+ * `Ref<unknown>` through the `SnailMeta` interface. The envelope handles are named
+ * after the server's configured keys, which a static interface cannot know, so
+ * declare them yourself with your real payload type:
+ *
+ * ```ts
+ * import type { Ref } from "vue";
+ *
+ * declare module "@snail-js/api" {
+ *   interface SnailMeta {
+ *     data: Ref<User>;
+ *     code: Ref<number>;
+ *     message: Ref<string>;
+ *   }
+ * }
+ * ```
+ */
+export interface VueAdapterOptions {
+}
+//# sourceMappingURL=type.d.ts.map

package/dist/plugins/vue/type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../src/plugins/vue/type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,iBAAiB;CAAG"}

package/dist/strategies/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./shared/public.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/strategies/index.ts"],"names":[],"mappings":"AA0BA,cAAc,iBAAiB,CAAC"}

package/dist/strategies/index.js

@@ -0,0 +1,29 @@
+import { t as vueStateAdapter } from "../chunks/vue-Dd9EhkQ3.js";
+import { a as useRetriableRequest, c as useFetcher, d as createStrategyState, f as setStateAdapter, i as useUploader, l as useWatcher, n as useSSE, o as useAutoRequest, r as useTokenAuth, s as usePagination, t as useDownload, u as useRequest } from "../chunks/use-download-FAjtdJ58.js";
+//#region src/strategies/index.ts
+/**
+* `@snail-js/api/strategies` — the default entry point, wired for Vue.
+*
+* ```ts
+* import { useRequest, usePagination } from "@snail-js/api/strategies";
+*
+* const user = useRequest(userApi.getUser);
+* ```
+*
+* ## Why the adapter is installed here and nowhere else
+*
+* A strategy hands the caller state handles; only the framework knows what a
+* handle is. Importing this module is therefore the *only* thing that makes Vue's
+* `ref()` the state primitive, and it is what pulls `vue` into a bundle. An
+* application that never imports this entry (or the Vue adapter plugin) never
+* ships Vue — which is why this file and `react.ts` are the only modules in the
+* strategy layer allowed to import a framework.
+*
+* The assignment runs before the re-export below, so a hook created immediately
+* after the import already sees the Vue adapter.
+*/
+setStateAdapter(vueStateAdapter);
+//#endregion
+export { createStrategyState, useAutoRequest, useDownload, useFetcher, usePagination, useRequest, useRetriableRequest, useSSE, useTokenAuth, useUploader, useWatcher };
+
+//# sourceMappingURL=index.js.map

package/dist/strategies/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/strategies/index.ts"],"sourcesContent":["/**\n * `@snail-js/api/strategies` — the default entry point, wired for Vue.\n *\n * ```ts\n * import { useRequest, usePagination } from \"@snail-js/api/strategies\";\n *\n * const user = useRequest(userApi.getUser);\n * ```\n *\n * ## Why the adapter is installed here and nowhere else\n *\n * A strategy hands the caller state handles; only the framework knows what a\n * handle is. Importing this module is therefore the *only* thing that makes Vue's\n * `ref()` the state primitive, and it is what pulls `vue` into a bundle. An\n * application that never imports this entry (or the Vue adapter plugin) never\n * ships Vue — which is why this file and `react.ts` are the only modules in the\n * strategy layer allowed to import a framework.\n *\n * The assignment runs before the re-export below, so a hook created immediately\n * after the import already sees the Vue adapter.\n */\nimport { vueStateAdapter } from \"../adapter/vue\";\nimport { setStateAdapter } from \"../adapter/registry\";\n\nsetStateAdapter(vueStateAdapter);\n\nexport * from \"./shared/public\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,gBAAgB,eAAe"}

package/dist/strategies/plain.d.ts

@@ -0,0 +1,2 @@
+export * from "./shared/public.js";
+//# sourceMappingURL=plain.d.ts.map

package/dist/strategies/plain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain.d.ts","sourceRoot":"","sources":["../../src/strategies/plain.ts"],"names":[],"mappings":"AAuBA,cAAc,iBAAiB,CAAC"}

package/dist/strategies/plain.js

@@ -0,0 +1,23 @@
+import { a as useRetriableRequest, c as useFetcher, d as createStrategyState, f as setStateAdapter, i as useUploader, l as useWatcher, n as useSSE, o as useAutoRequest, p as plainStateAdapter, r as useTokenAuth, s as usePagination, t as useDownload, u as useRequest } from "../chunks/use-download-FAjtdJ58.js";
+//#region src/strategies/plain.ts
+/**
+* `@snail-js/api/strategies/plain` — the framework-free entry point.
+*
+* ```ts
+* import { useRequest } from "@snail-js/api/strategies/plain";
+*
+* const user = useRequest(userApi.getUser);
+* await user.send("1");
+* user.data.value;      // values update, nothing re-renders
+* ```
+*
+* State handles are plain mutable boxes. Everything works — reads, writes,
+* `bind()`, events — it just does not *trigger* a render, which is exactly right
+* for a script, a server-side pass or a test. This entry is also what the strategy
+* test suite imports, so the whole layer is exercised without a UI framework.
+*/
+setStateAdapter(plainStateAdapter);
+//#endregion
+export { createStrategyState, useAutoRequest, useDownload, useFetcher, usePagination, useRequest, useRetriableRequest, useSSE, useTokenAuth, useUploader, useWatcher };
+
+//# sourceMappingURL=plain.js.map

package/dist/strategies/plain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain.js","names":[],"sources":["../../src/strategies/plain.ts"],"sourcesContent":["/**\n * `@snail-js/api/strategies/plain` — the framework-free entry point.\n *\n * ```ts\n * import { useRequest } from \"@snail-js/api/strategies/plain\";\n *\n * const user = useRequest(userApi.getUser);\n * await user.send(\"1\");\n * user.data.value;      // values update, nothing re-renders\n * ```\n *\n * State handles are plain mutable boxes. Everything works — reads, writes,\n * `bind()`, events — it just does not *trigger* a render, which is exactly right\n * for a script, a server-side pass or a test. This entry is also what the strategy\n * test suite imports, so the whole layer is exercised without a UI framework.\n */\nimport { plainStateAdapter } from \"../adapter/plain\";\nimport { setStateAdapter } from \"../adapter/registry\";\n\n// The registry already defaults to this adapter; setting it explicitly keeps the\n// three entries symmetric and makes the choice visible at the import site.\nsetStateAdapter(plainStateAdapter);\n\nexport * from \"./shared/public\";\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqBA,gBAAgB,iBAAiB"}

package/dist/strategies/react.d.ts

@@ -0,0 +1,2 @@
+export * from "./shared/public.js";
+//# sourceMappingURL=react.d.ts.map

package/dist/strategies/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/strategies/react.ts"],"names":[],"mappings":"AA2BA,cAAc,iBAAiB,CAAC"}

package/dist/strategies/react.js

@@ -0,0 +1,30 @@
+import { t as reactStateAdapter } from "../chunks/react-C1em-gxy.js";
+import { a as useRetriableRequest, c as useFetcher, d as createStrategyState, f as setStateAdapter, i as useUploader, l as useWatcher, n as useSSE, o as useAutoRequest, r as useTokenAuth, s as usePagination, t as useDownload, u as useRequest } from "../chunks/use-download-FAjtdJ58.js";
+//#region src/strategies/react.ts
+/**
+* `@snail-js/api/strategies/react` — the React entry point.
+*
+* ```ts
+* import { useRequest } from "@snail-js/api/strategies/react";
+*
+* const user = useRequest(userApi.getUser);
+* const { data, loading } = user.bind();   // subscribes this component
+* ```
+*
+* ## Why React needs its own entry
+*
+* Vue's `ref()` is tracked by the render effect that reads `.value`, so Vue needs
+* nothing from the strategy layer. React has no such tracking: a component only
+* re-renders when something explicitly tells it to. The React adapter therefore
+* allocates subscribable boxes and implements `useBind` with
+* `useSyncExternalStore`, and it is what `bind()` calls during render.
+*
+* Importing this module is what puts React's adapter in place — and the module is
+* the only place in the strategy layer that imports `react`, so an application
+* built on Vue never pulls it in.
+*/
+setStateAdapter(reactStateAdapter);
+//#endregion
+export { createStrategyState, useAutoRequest, useDownload, useFetcher, usePagination, useRequest, useRetriableRequest, useSSE, useTokenAuth, useUploader, useWatcher };
+
+//# sourceMappingURL=react.js.map

package/dist/strategies/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","names":[],"sources":["../../src/strategies/react.ts"],"sourcesContent":["/**\n * `@snail-js/api/strategies/react` — the React entry point.\n *\n * ```ts\n * import { useRequest } from \"@snail-js/api/strategies/react\";\n *\n * const user = useRequest(userApi.getUser);\n * const { data, loading } = user.bind();   // subscribes this component\n * ```\n *\n * ## Why React needs its own entry\n *\n * Vue's `ref()` is tracked by the render effect that reads `.value`, so Vue needs\n * nothing from the strategy layer. React has no such tracking: a component only\n * re-renders when something explicitly tells it to. The React adapter therefore\n * allocates subscribable boxes and implements `useBind` with\n * `useSyncExternalStore`, and it is what `bind()` calls during render.\n *\n * Importing this module is what puts React's adapter in place — and the module is\n * the only place in the strategy layer that imports `react`, so an application\n * built on Vue never pulls it in.\n */\nimport { reactStateAdapter } from \"../adapter/react\";\nimport { setStateAdapter } from \"../adapter/registry\";\n\nsetStateAdapter(reactStateAdapter);\n\nexport * from \"./shared/public\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,gBAAgB,iBAAiB"}

package/dist/strategies/shared/adapter.d.ts

@@ -0,0 +1,23 @@
+import type { SnailStateAdapter, SnailStateRef } from "../../typings/adapter.js";
+/**
+ * Resolve the state adapter one strategy instance should use.
+ *
+ * The adapter is resolved **once per hook** rather than per read. A hook that
+ * asked the registry on every write could observe two different adapters if an
+ * application called `setStateAdapter()` between two requests, and would then mix
+ * Vue refs with plain boxes in one set of handles.
+ */
+export declare function resolveStateAdapter(options?: {
+    adapter?: SnailStateAdapter;
+}): SnailStateAdapter;
+/**
+ * Read a handle for the current render.
+ *
+ * `useBind` exists for frameworks that only re-render on an explicit
+ * subscription (React's `useSyncExternalStore`); Vue tracks the `.value` access
+ * itself, so its adapter omits the method and the read is the whole story. The
+ * `??` fallback — rather than a truthiness check — keeps a legitimate `false`,
+ * `0` or `""` from being replaced by a second read.
+ */
+export declare function bindRef<T>(adapter: SnailStateAdapter, ref: SnailStateRef<T>): T;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/strategies/shared/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/strategies/shared/adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE9E;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,iBAAiB,CAAA;CAAO,GAAG,iBAAiB,CAEpG;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,iBAAiB,EAAE,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAE/E"}

package/dist/strategies/shared/dom.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Guarded access to the browser globals a strategy listens to.
+ *
+ * The tests for this layer run in Node, where `window` and `document` do not
+ * exist at all. Reading them lazily — inside a function, never at module scope —
+ * is what lets the same module be imported in both environments, and it is the
+ * only reason `useAutoRequest` can be created in a server-side render without
+ * throwing.
+ */
+/**
+ * The subset of `EventTarget` this layer uses.
+ *
+ * `(...args: any[]) => void` rather than `() => void` on purpose: `window`'s own
+ * `addEventListener` expects an `EventListener`, and a zero-argument listener type
+ * would make the real object structurally incompatible.
+ */
+export interface DomEventTargetLike {
+    addEventListener(type: string, listener: (...args: any[]) => void, options?: unknown): void;
+    removeEventListener(type: string, listener: (...args: any[]) => void, options?: unknown): void;
+}
+/** The global `window`, or `undefined` outside a DOM environment. */
+export declare function getWindowTarget(): DomEventTargetLike | undefined;
+/** The global `document`, or `undefined` outside a DOM environment. */
+export declare function getDocumentTarget(): DomEventTargetLike | undefined;
+/**
+ * `true` when the page is on screen.
+ *
+ * Node reports `true` so a `visibilitychange`-driven strategy still works in a
+ * script; there is no hidden page to miss.
+ */
+export declare function isDocumentVisible(): boolean;
+/** A collection of registered listeners that can be removed as one unit. */
+export interface ListenerScope {
+    /**
+     * Register `listener`. Returns `false` when the target does not exist — the
+     * Node case — so the caller can tell "not attached" from "attached".
+     */
+    add(target: DomEventTargetLike | undefined, type: string, listener: (...args: any[]) => void): boolean;
+    /** Remove every listener registered through this scope. Safe to call twice. */
+    removeAll(): void;
+    /** Number of listeners currently attached. */
+    readonly size: number;
+}
+/**
+ * Create a listener bookkeeping scope.
+ *
+ * `stop()` and `dispose()` are called from event handlers, from `finally` blocks
+ * and sometimes twice; without one central registry it is far too easy to remove a
+ * listener with a *different* function reference than the one added, which leaks
+ * silently and keeps the component from being collected.
+ */
+export declare function createListenerScope(): ListenerScope;
+//# sourceMappingURL=dom.d.ts.map

package/dist/strategies/shared/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../../src/strategies/shared/dom.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5F,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAChG;AAED,qEAAqE;AACrE,wBAAgB,eAAe,IAAI,kBAAkB,GAAG,SAAS,CAGhE;AAED,uEAAuE;AACvE,wBAAgB,iBAAiB,IAAI,kBAAkB,GAAG,SAAS,CAGlE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAG3C;AAED,4EAA4E;AAC5E,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,GAAG,CACD,MAAM,EAAE,kBAAkB,GAAG,SAAS,EACtC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GACjC,OAAO,CAAC;IAEX,+EAA+E;IAC/E,SAAS,IAAI,IAAI,CAAC;IAElB,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CA8BnD"}

package/dist/strategies/shared/error.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `true` when an error means "this request was deliberately stopped".
+ *
+ * Cancellation is **expected control flow**, not a failure: `method.abort()` and
+ * a strategy discarding a stale response both produce it. Every strategy must ask
+ * this question before writing `error` state or firing `onError`, otherwise a
+ * user aborting a request would see a spurious error toast.
+ *
+ * The duck-typed `code` check is what catches an `AbortError` produced by a
+ * caller-supplied `AbortSignal`, which axios does not always wrap in its own
+ * cancel class.
+ */
+export declare function isCancellation(error: unknown): boolean;
+/**
+ * Best-effort business/HTTP code of a failure, for the `code` state handle.
+ *
+ * Reading it from the error rather than from a response keeps `code` meaningful
+ * on the failure path too — a `401` should be visible to the UI even though no
+ * envelope ever passed validation.
+ */
+export declare function readErrorCode(error: unknown): number | string | undefined;
+/**
+ * Best-effort human readable message of a failure, for the `message` handle.
+ *
+ * The backend envelope is preferred over the `Error.message` because an axios
+ * transport message ("Request failed with status code 401") is useless to show a
+ * user while `{ message: "token expired" }` is not.
+ */
+export declare function readErrorMessage(error: unknown): string | undefined;
+//# sourceMappingURL=error.d.ts.map

package/dist/strategies/shared/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../src/strategies/shared/error.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAKtD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAUzE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAQnE"}

package/dist/strategies/shared/method.d.ts

@@ -0,0 +1,51 @@
+import type { AxiosProgressEvent } from "axios";
+import type { SnailMethod } from "../../core/method.js";
+/**
+ * A proxied api method — exactly what `Service.createApi(UserApi).getUser` is.
+ *
+ * Calling it **builds** a request (no network); `send()` performs it. A strategy
+ * needs the callable rather than an already-built `SnailMethod` because it must
+ * be able to re-send with different arguments, and because a strategy that
+ * forwards the argument tuple keeps the api class's own signature intact.
+ */
+export type StrategyMethod<TArgs extends readonly unknown[] = readonly unknown[], TData = unknown> = (...args: TArgs) => SnailMethod<any, TData, any, any, any>;
+/** The `SnailMethod` a strategy drives, with its payload type narrowed. */
+export type SnailRequest<TData = unknown> = SnailMethod<any, TData, any, any, any>;
+/**
+ * Holds the single `SnailMethod` a hook reuses across sends.
+ *
+ * `docs/guide/plugin-lifecycle.md` §4.3 is explicit that `initMeta` runs once per method, not
+ * once per send, so the reactive handles a UI captured stay identical across
+ * re-sends. Calling `method(...args)` again would build a *second* context with a
+ * second set of refs — the UI would keep rendering the first, frozen one. This
+ * holder is what makes "one instance, many sends" the default instead of a rule
+ * every hook author has to remember.
+ */
+export interface MethodHolder<TData = unknown> {
+    /** The instance driving every send, or `undefined` before the first one. */
+    readonly instance: SnailRequest<TData> | undefined;
+    /** `true` while this holder's method has a request in flight. */
+    readonly pending: boolean;
+    /** Get-or-create the instance. Only the first call's arguments are captured. */
+    resolve(args: readonly unknown[]): SnailRequest<TData>;
+    /** Cancel the in-flight request, if any. A no-op before the first send. */
+    abort(): void;
+}
+/** Create a {@link MethodHolder} around a proxied api method. */
+export declare function createMethodHolder<TArgs extends readonly unknown[], TData>(method: StrategyMethod<TArgs, TData>): MethodHolder<TData>;
+/**
+ * Attach a per-request upload progress callback.
+ *
+ * The core resolves `onUploadProgress` from `@UploadProgress(...)` metadata when
+ * the `SnailMethod` is built, which is once per method — not once per file. To
+ * vary it per request this writes onto the **live** axios config instead.
+ *
+ * The timing is load-bearing: `send()` calls `begin()` synchronously before its
+ * first `await`, so the config read here is the one axios will send. Calling this
+ * before `send()` would be silently overwritten by `begin()`, and calling it
+ * after an `await` would be too late.
+ *
+ * @returns `false` when there was no live config to attach to.
+ */
+export declare function attachUploadProgress<TData>(snail: SnailRequest<TData>, listener: (event: AxiosProgressEvent) => void): boolean;
+//# sourceMappingURL=method.d.ts.map

package/dist/strategies/shared/method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method.d.ts","sourceRoot":"","sources":["../../../src/strategies/shared/method.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,CACxB,KAAK,SAAS,SAAS,OAAO,EAAE,GAAG,SAAS,OAAO,EAAE,EACrD,KAAK,GAAG,OAAO,IACb,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,WAAW,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAE/D,2EAA2E;AAC3E,MAAM,MAAM,YAAY,CAAC,KAAK,GAAG,OAAO,IAAI,WAAW,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAEnF;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY,CAAC,KAAK,GAAG,OAAO;IAC3C,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAEnD,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B,gFAAgF;IAChF,OAAO,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;IAEvD,2EAA2E;IAC3E,KAAK,IAAI,IAAI,CAAC;CACf;AAED,iEAAiE;AACjE,wBAAgB,kBAAkB,CAChC,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,KAAK,EACL,MAAM,EAAE,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,YAAY,CAAC,KAAK,CAAC,CAoB3D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EACxC,KAAK,EAAE,YAAY,CAAC,KAAK,CAAC,EAC1B,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAC5C,OAAO,CAYT"}

package/dist/strategies/shared/public.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The public surface of `@snail-js/api/strategies`.
+ *
+ * The three entry points (`index.ts` for Vue, `react.ts` for React and `plain.ts`
+ * for everything else) differ in exactly one statement — which state adapter they
+ * install — and then re-export this module. Keeping the export list in one place
+ * is what stops the three entries from drifting apart; a hook added here appears
+ * in all three, and none of them re-implements anything.
+ */
+export { createStrategyState } from "./state.js";
+export type { StrategyBoundState, StrategyState, StrategyStateController, StrategyStateOptions, StrategyStatePatch } from "./state.js";
+export type { MethodHolder, SnailRequest, StrategyMethod } from "./method.js";
+export { useRequest } from "../use-request.js";
+export type { UseRequestOptions, UseRequestResult } from "../use-request.js";
+export { useWatcher } from "../use-watcher.js";
+export type { UseWatcherOptions, UseWatcherResult } from "../use-watcher.js";
+export { useFetcher } from "../use-fetcher.js";
+export type { UseFetcherCore, UseFetcherOptions, UseFetcherResult, UseFetcherStateOptions } from "../use-fetcher.js";
+export { usePagination } from "../use-pagination.js";
+export type { PageRequest, UsePaginationOptions, UsePaginationResult } from "../use-pagination.js";
+export { useAutoRequest } from "../use-auto-request.js";
+export type { UseAutoRequestOptions, UseAutoRequestResult } from "../use-auto-request.js";
+export { useRetriableRequest } from "../use-retriable-request.js";
+export type { UseRetriableRequestOptions, UseRetriableRequestResult } from "../use-retriable-request.js";
+export { useUploader } from "../use-uploader.js";
+export type { UploaderProgress, UploadFileState, UploadFileStatus, UseUploaderOptions, UseUploaderResult } from "../use-uploader.js";
+export { useTokenAuth } from "../use-token-auth.js";
+export type { TokenAuthHandle, TokenAuthOptions } from "../use-token-auth.js";
+export { useSSE } from "../use-sse.js";
+export type { SseConnectionTap, SseEndpoint, UseSseOptions, UseSseResult } from "../use-sse.js";
+export { useDownload } from "../use-download.js";
+export type { DownloadDescriptor, UseDownloadOptions, UseDownloadResult } from "../use-download.js";
+//# sourceMappingURL=public.d.ts.map

package/dist/strategies/shared/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../../src/strategies/shared/public.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAC9C,YAAY,EACV,kBAAkB,EAClB,aAAa,EACb,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAEjB,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAI3E,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAE1E,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAE1E,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,YAAY,EACV,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,YAAY,EAAE,WAAW,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAEhG,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEvF,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,YAAY,EACV,0BAA0B,EAC1B,yBAAyB,EAC1B,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE3E,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACpC,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE7F,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,iBAAiB,CAAC"}

package/dist/strategies/shared/queue.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A bounded-concurrency queue of asynchronous tasks.
+ *
+ * `useUploader` needs this for one reason: a user dropping 200 files must not open
+ * 200 sockets. The queue also owns the "is everything finished?" question, so
+ * `upload()` can hand back a promise that resolves when the batch drains instead
+ * of making the caller poll the file list.
+ */
+export interface TaskQueue {
+    /** Enqueue a task; it starts as soon as a slot is free. */
+    add(task: () => Promise<void>): void;
+    /** Resolves once nothing is running and nothing is waiting. */
+    drain(): Promise<void>;
+    /** Drop every task that has not started yet. Running tasks are untouched. */
+    clear(): void;
+    /** Number of tasks currently running. */
+    readonly active: number;
+    /** Number of tasks waiting for a slot. */
+    readonly pending: number;
+}
+/**
+ * Create a queue that runs at most `concurrency` tasks at a time.
+ *
+ * A task that rejects is swallowed rather than failing the queue: one broken
+ * upload must not stall the remaining ones, and the caller observes the failure
+ * through per-file state anyway. `concurrency` is clamped to at least 1, because a
+ * queue with zero slots would never drain and `drain()` would never resolve.
+ */
+export declare function createTaskQueue(concurrency?: number): TaskQueue;
+//# sourceMappingURL=queue.d.ts.map

package/dist/strategies/shared/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/strategies/shared/queue.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,2DAA2D;IAC3D,GAAG,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAErC,+DAA+D;IAC/D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB,6EAA6E;IAC7E,KAAK,IAAI,IAAI,CAAC;IAEd,yCAAyC;IACzC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,WAAW,SAAI,GAAG,SAAS,CA0D1D"}

package/dist/strategies/shared/retry.d.ts

@@ -0,0 +1,51 @@
+/** Retry knobs shared by `useRetriableRequest` and the reconnect transports. */
+export interface RetryOptions {
+    /** Extra attempts after the first failure. Defaults to `3`. */
+    retries?: number;
+    /** First delay in milliseconds. Defaults to `1000`. */
+    delayMs?: number;
+    /** Upper bound for one delay. Defaults to `30000`. */
+    maxDelayMs?: number;
+    /** Multiplier applied after each failure. Defaults to `2`. */
+    factor?: number;
+    /** Randomise the delay to avoid a thundering herd. Defaults to `true`. */
+    jitter?: boolean;
+}
+/** Fully defaulted retry configuration. */
+export interface RetryPolicy {
+    retries: number;
+    delayMs: number;
+    maxDelayMs: number;
+    factor: number;
+    jitter: boolean;
+}
+/** Decides whether one failed attempt deserves another. */
+export type RetryPredicate = (error: unknown, attempt: number) => boolean;
+/** Defaults are deliberately conservative: three tries, exponential, jittered. */
+export declare const DEFAULT_RETRY_POLICY: RetryPolicy;
+/**
+ * Fill in the retry defaults.
+ *
+ * `retries` is floored and clamped to `>= 0`: a negative value would make the
+ * attempt loop run zero times and resolve without ever sending, which is a
+ * silent no-op rather than a validation error the caller can see.
+ */
+export declare function resolveRetryPolicy(options?: RetryOptions): RetryPolicy;
+/**
+ * Delay before attempt `attempt` (1-based), with exponential growth and an
+ * optional jitter.
+ *
+ * Jitter is *half* the computed delay plus a random share, not a fresh random
+ * pick: full jitter can produce a near-zero delay that turns a retry storm into a
+ * hammering loop, while half jitter still spreads a fleet of clients out.
+ */
+export declare function computeBackoffDelay(attempt: number, policy: RetryPolicy): number;
+/**
+ * The default {@link RetryPredicate}: retry everything except a cancellation.
+ *
+ * Retrying a cancellation is the one case that is always wrong — the caller asked
+ * for the request to stop, so a retry ignores an explicit instruction and keeps
+ * the socket busy.
+ */
+export declare const defaultRetryPredicate: RetryPredicate;
+//# sourceMappingURL=retry.d.ts.map

package/dist/strategies/shared/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/strategies/shared/retry.ts"],"names":[],"mappings":"AAEA,gFAAgF;AAChF,MAAM,WAAW,YAAY;IAC3B,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,2CAA2C;AAC3C,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,2DAA2D;AAC3D,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;AAE1E,kFAAkF;AAClF,eAAO,MAAM,oBAAoB,EAAE,WAMlC,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,YAAiB,GAAG,WAAW,CAiB1E;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,MAAM,CAKhF;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,EAAE,cACZ,CAAC"}